Use Chrome compatible naming for compiler specifics.

src/compiler/js-generic-lowering.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/code-stubs.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-aux-data-inl.h"
@@ skipping 21 matching lines @@
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class LoadICStubShim : public HydrogenCodeStub {
  public:
   LoadICStubShim(Isolate* isolate, ContextualMode contextual_mode)
       : HydrogenCodeStub(isolate), contextual_mode_(contextual_mode) {
     i::compiler::GetInterfaceDescriptor(isolate, this);
   }
 
-  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+  virtual Handle<Code> GenerateCode() OVERRIDE {
     ExtraICState extra_state = LoadIC::ComputeExtraICState(contextual_mode_);
     return LoadIC::initialize_stub(isolate(), extra_state);
   }
 
   virtual void InitializeInterfaceDescriptor(
-      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+      CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     CallInterfaceDescriptor* call_descriptor =
         isolate()->call_descriptor(CallDescriptorKey::LoadICCall);
     descriptor->Initialize(MajorKey(), call_descriptor);
   }
 
  private:
-  virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
-  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
-  virtual bool UseSpecialCache() V8_OVERRIDE { return true; }
+  virtual Major MajorKey() const OVERRIDE { return NoCache; }
+  virtual int NotMissMinorKey() const OVERRIDE { return 0; }
+  virtual bool UseSpecialCache() OVERRIDE { return true; }
 
   ContextualMode contextual_mode_;
 };
 
 
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class KeyedLoadICStubShim : public HydrogenCodeStub {
  public:
   explicit KeyedLoadICStubShim(Isolate* isolate) : HydrogenCodeStub(isolate) {
     i::compiler::GetInterfaceDescriptor(isolate, this);
   }
 
-  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+  virtual Handle<Code> GenerateCode() OVERRIDE {
     return isolate()->builtins()->KeyedLoadIC_Initialize();
   }
 
   virtual void InitializeInterfaceDescriptor(
-      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+      CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     CallInterfaceDescriptor* call_descriptor =
         isolate()->call_descriptor(CallDescriptorKey::LoadICCall);
     descriptor->Initialize(MajorKey(), call_descriptor);
   }
 
  private:
-  virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
-  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
-  virtual bool UseSpecialCache() V8_OVERRIDE { return true; }
+  virtual Major MajorKey() const OVERRIDE { return NoCache; }
+  virtual int NotMissMinorKey() const OVERRIDE { return 0; }
+  virtual bool UseSpecialCache() OVERRIDE { return true; }
 };
 
 
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class StoreICStubShim : public HydrogenCodeStub {
  public:
   StoreICStubShim(Isolate* isolate, StrictMode strict_mode)
       : HydrogenCodeStub(isolate), strict_mode_(strict_mode) {
     i::compiler::GetInterfaceDescriptor(isolate, this);
   }
 
-  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+  virtual Handle<Code> GenerateCode() OVERRIDE {
     return StoreIC::initialize_stub(isolate(), strict_mode_);
   }
 
   virtual void InitializeInterfaceDescriptor(
-      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+      CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     CallInterfaceDescriptor* call_descriptor =
         isolate()->call_descriptor(CallDescriptorKey::StoreICCall);
     descriptor->Initialize(MajorKey(), call_descriptor);
   }
 
  private:
-  virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
-  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
-  virtual bool UseSpecialCache() V8_OVERRIDE { return true; }
+  virtual Major MajorKey() const OVERRIDE { return NoCache; }
+  virtual int NotMissMinorKey() const OVERRIDE { return 0; }
+  virtual bool UseSpecialCache() OVERRIDE { return true; }
 
   StrictMode strict_mode_;
 };
 
 
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class KeyedStoreICStubShim : public HydrogenCodeStub {
  public:
   KeyedStoreICStubShim(Isolate* isolate, StrictMode strict_mode)
       : HydrogenCodeStub(isolate), strict_mode_(strict_mode) {
     i::compiler::GetInterfaceDescriptor(isolate, this);
   }
 
-  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+  virtual Handle<Code> GenerateCode() OVERRIDE {
     return strict_mode_ == SLOPPY
                ? isolate()->builtins()->KeyedStoreIC_Initialize()
                : isolate()->builtins()->KeyedStoreIC_Initialize_Strict();
   }
 
   virtual void InitializeInterfaceDescriptor(
-      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+      CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     CallInterfaceDescriptor* call_descriptor =
         isolate()->call_descriptor(CallDescriptorKey::StoreICCall);
     descriptor->Initialize(MajorKey(), call_descriptor);
   }
 
  private:
-  virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
-  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
-  virtual bool UseSpecialCache() V8_OVERRIDE { return true; }
+  virtual Major MajorKey() const OVERRIDE { return NoCache; }
+  virtual int NotMissMinorKey() const OVERRIDE { return 0; }
+  virtual bool UseSpecialCache() OVERRIDE { return true; }
 
   StrictMode strict_mode_;
 };
 
 
 JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph,
                                      MachineOperatorBuilder* machine)
     : info_(info),
       jsgraph_(jsgraph),
       linkage_(new (jsgraph->zone()) Linkage(info)),
@@ skipping 387 matching lines @@
 Node* JSGenericLowering::LowerJSCallRuntime(Node* node) {
   Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(node);
   int arity = OperatorProperties::GetValueInputCount(node->op());
   ReplaceWithRuntimeCall(node, function, arity);
   return node;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8