Implement representation selection as part of SimplifiedLowering. Representation selection also req…

src/compiler/representation-change.h

 // 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.
 
 #ifndef V8_COMPILER_REPRESENTATION_CHANGE_H_
 #define V8_COMPILER_REPRESENTATION_CHANGE_H_
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 18 matching lines @@
   // Types.
   tBool = 1 << 5,
   tInt32 = 1 << 6,
   tUint32 = 1 << 7,
   tInt64 = 1 << 8,
   tUint64 = 1 << 9,
   tNumber = 1 << 10,
   tAny = 1 << 11
 };
 
+#define REP_TYPE_STRLEN 24
+
 typedef uint16_t RepTypeUnion;
 
+
+inline void RenderRepTypeUnion(char* buf, RepTypeUnion info) {
+  snprintf(buf, REP_TYPE_STRLEN, "{%s%s%s%s%s %s%s%s%s%s%s%s}",
+           (info & rBit) ? "k" : " ", (info & rWord32) ? "w" : " ",
+           (info & rWord64) ? "q" : " ", (info & rFloat64) ? "f" : " ",
+           (info & rTagged) ? "t" : " ", (info & tBool) ? "Z" : " ",
+           (info & tInt32) ? "I" : " ", (info & tUint32) ? "U" : " ",
+           (info & tInt64) ? "L" : " ", (info & tUint64) ? "J" : " ",
+           (info & tNumber) ? "N" : " ", (info & tAny) ? "*" : " ");
+}
+
+
 const RepTypeUnion rMask = rBit | rWord32 | rWord64 | rFloat64 | rTagged;
 const RepTypeUnion tMask =
     tBool | tInt32 | tUint32 | tInt64 | tUint64 | tNumber | tAny;
 const RepType rPtr = kPointerSize == 4 ? rWord32 : rWord64;
 
-
 // Contains logic related to changing the representation of values for constants
 // and other nodes, as well as lowering Simplified->Machine operators.
 // Eagerly folds any representation changes for constants.
 class RepresentationChanger {
  public:
   RepresentationChanger(JSGraph* jsgraph, SimplifiedOperatorBuilder* simplified,
                         MachineOperatorBuilder* machine, Isolate* isolate)
       : jsgraph_(jsgraph),
         simplified_(simplified),
         machine_(machine),
@@ skipping 280 matching lines @@
     RepType rElement = TypeForMachineRepresentation(access.representation);
     return static_cast<RepType>(tElement | rElement);
   }
 
   RepType TypeForElement(const ElementAccess& access) {
     RepType tElement = static_cast<RepType>(0);  // TODO(titzer)
     RepType rElement = TypeForMachineRepresentation(access.representation);
     return static_cast<RepType>(tElement | rElement);
   }
 
-  RepType TypeForBasePointer(Node* node) {
-    Type* upper = NodeProperties::GetBounds(node).upper;
-    if (upper->Is(Type::UntaggedPtr())) return rPtr;
-    return static_cast<RepType>(tAny | rTagged);
+  RepType TypeForBasePointer(const FieldAccess& access) {
+    if (access.tag() != 0) return static_cast<RepType>(tAny | rTagged);
+    return kPointerSize == 8 ? rWord64 : rWord32;
+  }
+
+  RepType TypeForBasePointer(const ElementAccess& access) {
+    if (access.tag() != 0) return static_cast<RepType>(tAny | rTagged);
+    return kPointerSize == 8 ? rWord64 : rWord32;
   }
 
  private:
   JSGraph* jsgraph_;
   SimplifiedOperatorBuilder* simplified_;
   MachineOperatorBuilder* machine_;
   Isolate* isolate_;
 
   friend class RepresentationChangerTester;  // accesses the below fields.
 
   bool testing_type_errors_;  // If {true}, don't abort on a type error.
   bool type_error_;           // Set when a type error is detected.
 
   Node* TypeError(Node* node, RepTypeUnion output_type, RepTypeUnion use) {
     type_error_ = true;
     if (!testing_type_errors_) {
-      UNREACHABLE();  // TODO(titzer): report nicer type error
+      char buf1[REP_TYPE_STRLEN];
+      char buf2[REP_TYPE_STRLEN];
+      RenderRepTypeUnion(buf1, output_type);
+      RenderRepTypeUnion(buf2, use);
+      V8_Fatal(__FILE__, __LINE__,
+               "RepresentationChangerError: node #%d:%s of rep"
+               "%s cannot be changed to rep%s",
+               node->id(), node->op()->mnemonic(), buf1, buf2);
     }
     return node;
   }
 
   JSGraph* jsgraph() { return jsgraph_; }
   Isolate* isolate() { return isolate_; }
   SimplifiedOperatorBuilder* simplified() { return simplified_; }
   MachineOperatorBuilder* machine() { return machine_; }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_REPRESENTATION_CHANGE_H_