Add support for adding an external and a tagged pointer

src/hydrogen-instructions.h

 // Copyright 2012 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.
 
 #ifndef V8_HYDROGEN_INSTRUCTIONS_H_
 #define V8_HYDROGEN_INSTRUCTIONS_H_
 
 #include <cstring>
 #include <iosfwd>
 
@@ skipping 4812 matching lines @@
     SetFlag(kUseGVN);
     SetChangesFlag(kNewSpacePromotion);
   }
 
   bool IsDeletable() const override {
     return !right()->representation().IsTagged();
   }
 };
 
 
+enum ExternalAddType {
+  AddOfExternalAndTagged,
+  AddOfExternalAndInt32,
+  NoExternalAdd
+};
+
+
 class HAdd final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
                            Strength strength = Strength::WEAK);
+  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
+                           HValue* left, HValue* right, Strength strength,
+                           ExternalAddType external_add_type);
 
   // Add is only commutative if two integer values are added and not if two
   // tagged values are added (because it might be a String concatenation).
   // We also do not commute (pointer + offset).
   bool IsCommutative() const override {
     return !representation().IsTagged() && !representation().IsExternal();
   }
 
   HValue* Canonicalize() override;
 
@@ skipping 22 matching lines @@
     if (to.IsTagged()) {
       SetChangesFlag(kNewSpacePromotion);
       ClearFlag(kAllowUndefinedAsNaN);
     }
   }
 
   Representation RepresentationFromInputs() override;
 
   Representation RequiredInputRepresentation(int index) override;
 
+  ExternalAddType external_add_type() const { return external_add_type_; }
+
   DECLARE_CONCRETE_INSTRUCTION(Add)
 
  protected:
   bool DataEquals(HValue* other) override { return true; }
 
   Range* InferRange(Zone* zone) override;
 
  private:
-  HAdd(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HArithmeticBinaryOperation(context, left, right, strength) {
+  HAdd(HValue* context, HValue* left, HValue* right, Strength strength,
+       ExternalAddType external_add_type = NoExternalAdd)
+      : HArithmeticBinaryOperation(context, left, right, strength),
+        external_add_type_(external_add_type) {
     SetFlag(kCanOverflow);
+    if (left->representation().IsExternal()) {
+      if (right->representation().IsTagged()) {
+        DCHECK_EQ(external_add_type_, AddOfExternalAndTagged);
+        SetDependsOnFlag(kNewSpacePromotion);
+      } else {
+        // This is a bit of a hack: The call to this constructor is generated
+        // by a macro that also supports sub and mul, so it doesn't pass in
+        // a value for external_add_type but uses the default.
+        DCHECK_EQ(external_add_type_, NoExternalAdd);
+        external_add_type_ = AddOfExternalAndInt32;
+      }
+    } else {
+      DCHECK_EQ(external_add_type_, NoExternalAdd);
+    }

[Jarin, 2015/07/20 14:17:56]

Hmm, I was imagining you would drive it the other way:

if (external_add_type == AddOfExternalAndTagged) {
  DCHECK(left->representation().IsExternal());
  DCHECK(right->representation().IsTagged());
  SetDependsOnFlag(kNewSpacePromotion);
} else {
  ...
}

   }
+
+  ExternalAddType external_add_type_;
 };
 
 
 class HSub final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right,
                            Strength strength = Strength::WEAK);
 
   HValue* Canonicalize() override;
@@ skipping 3140 matching lines @@
 };
 
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_