1 files changed, 69 insertions, 16 deletions

diff --git a/deps/v8/src/compiler/graph-assembler.cc b/deps/v8/src/compiler/graph-assembler.cc
index 68f645150b..cc9dbd9dfd 100644
--- a/deps/v8/src/compiler/graph-assembler.cc
+++ b/deps/v8/src/compiler/graph-assembler.cc
@@ -4,7 +4,7 @@
 
 #include "src/compiler/graph-assembler.h"
 
-#include "src/code-factory.h"
+#include "src/codegen/code-factory.h"
 #include "src/compiler/linkage.h"
 
 namespace v8 {
@@ -112,20 +112,26 @@ Node* GraphAssembler::Allocate(AllocationType allocation, Node* size) {
 }
 
 Node* GraphAssembler::LoadField(FieldAccess const& access, Node* object) {
-  return current_effect_ =
-             graph()->NewNode(simplified()->LoadField(access), object,
-                              current_effect_, current_control_);
+  Node* value = current_effect_ =
+      graph()->NewNode(simplified()->LoadField(access), object, current_effect_,
+                       current_control_);
+  return InsertDecompressionIfNeeded(access.machine_type.representation(),
+                                     value);
 }
 
 Node* GraphAssembler::LoadElement(ElementAccess const& access, Node* object,
                                   Node* index) {
-  return current_effect_ =
-             graph()->NewNode(simplified()->LoadElement(access), object, index,
-                              current_effect_, current_control_);
+  Node* value = current_effect_ =
+      graph()->NewNode(simplified()->LoadElement(access), object, index,
+                       current_effect_, current_control_);
+  return InsertDecompressionIfNeeded(access.machine_type.representation(),
+                                     value);
 }
 
 Node* GraphAssembler::StoreField(FieldAccess const& access, Node* object,
                                  Node* value) {
+  value =
+      InsertCompressionIfNeeded(access.machine_type.representation(), value);
   return current_effect_ =
              graph()->NewNode(simplified()->StoreField(access), object, value,
                               current_effect_, current_control_);
@@ -133,6 +139,8 @@ Node* GraphAssembler::StoreField(FieldAccess const& access, Node* object,
 
 Node* GraphAssembler::StoreElement(ElementAccess const& access, Node* object,
                                    Node* index, Node* value) {
+  value =
+      InsertCompressionIfNeeded(access.machine_type.representation(), value);
   return current_effect_ =
              graph()->NewNode(simplified()->StoreElement(access), object, index,
                               value, current_effect_, current_control_);
@@ -150,15 +158,16 @@ Node* GraphAssembler::Unreachable() {
 
 Node* GraphAssembler::Store(StoreRepresentation rep, Node* object, Node* offset,
                             Node* value) {
+  value = InsertCompressionIfNeeded(rep.representation(), value);
   return current_effect_ =
              graph()->NewNode(machine()->Store(rep), object, offset, value,
                               current_effect_, current_control_);
 }
 
-Node* GraphAssembler::Load(MachineType rep, Node* object, Node* offset) {
-  return current_effect_ =
-             graph()->NewNode(machine()->Load(rep), object, offset,
-                              current_effect_, current_control_);
+Node* GraphAssembler::Load(MachineType type, Node* object, Node* offset) {
+  Node* value = current_effect_ = graph()->NewNode(
+      machine()->Load(type), object, offset, current_effect_, current_control_);
+  return InsertDecompressionIfNeeded(type.representation(), value);
 }
 
 Node* GraphAssembler::StoreUnaligned(MachineRepresentation rep, Node* object,
@@ -172,13 +181,13 @@ Node* GraphAssembler::StoreUnaligned(MachineRepresentation rep, Node* object,
                                             current_effect_, current_control_);
 }
 
-Node* GraphAssembler::LoadUnaligned(MachineType rep, Node* object,
+Node* GraphAssembler::LoadUnaligned(MachineType type, Node* object,
                                     Node* offset) {
   Operator const* const op =
-      (rep.representation() == MachineRepresentation::kWord8 ||
-       machine()->UnalignedLoadSupported(rep.representation()))
-          ? machine()->Load(rep)
-          : machine()->UnalignedLoad(rep);
+      (type.representation() == MachineRepresentation::kWord8 ||
+       machine()->UnalignedLoadSupported(type.representation()))
+          ? machine()->Load(type)
+          : machine()->UnalignedLoad(type);
   return current_effect_ = graph()->NewNode(op, object, offset, current_effect_,
                                             current_control_);
 }
@@ -274,6 +283,50 @@ Node* GraphAssembler::ExtractCurrentEffect() {
   return result;
 }
 
+Node* GraphAssembler::InsertDecompressionIfNeeded(MachineRepresentation rep,
+                                                  Node* value) {
+  if (COMPRESS_POINTERS_BOOL) {
+    switch (rep) {
+      case MachineRepresentation::kCompressedPointer:
+        value = graph()->NewNode(
+            machine()->ChangeCompressedPointerToTaggedPointer(), value);
+        break;
+      case MachineRepresentation::kCompressedSigned:
+        value = graph()->NewNode(
+            machine()->ChangeCompressedSignedToTaggedSigned(), value);
+        break;
+      case MachineRepresentation::kCompressed:
+        value = graph()->NewNode(machine()->ChangeCompressedToTagged(), value);
+        break;
+      default:
+        break;
+    }
+  }
+  return value;
+}
+
+Node* GraphAssembler::InsertCompressionIfNeeded(MachineRepresentation rep,
+                                                Node* value) {
+  if (COMPRESS_POINTERS_BOOL) {
+    switch (rep) {
+      case MachineRepresentation::kCompressedPointer:
+        value = graph()->NewNode(
+            machine()->ChangeTaggedPointerToCompressedPointer(), value);
+        break;
+      case MachineRepresentation::kCompressedSigned:
+        value = graph()->NewNode(
+            machine()->ChangeTaggedSignedToCompressedSigned(), value);
+        break;
+      case MachineRepresentation::kCompressed:
+        value = graph()->NewNode(machine()->ChangeTaggedToCompressed(), value);
+        break;
+      default:
+        break;
+    }
+  }
+  return value;
+}
+
 void GraphAssembler::Reset(Node* effect, Node* control) {
   current_effect_ = effect;
   current_control_ = control;