Remaining (forgotten) feedback for pixel array deopt fix

TBR=kmillikin@chromium.org
BUG=none
TEST=none

Review URL: http://codereview.chromium.org/7019008

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@7903 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/arm/lithium-arm.cc b/src/arm/lithium-arm.cc
index 48c3ea39de6787a88e074916945ffb99d2ebfd7c..752341b30ca86478de82a1ae03ef4881f657ef32 100644 (file)
--- a/src/arm/lithium-arm.cc
+++ b/src/arm/lithium-arm.cc
@@ -1756,14 +1756,14 @@ LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
   Representation input_rep = value->representation();
   LOperand* reg = UseRegister(value);
   if (input_rep.IsDouble()) {
-    return DefineAsRegister(new LClampDoubleToUint8(reg, FixedTemp(d1)));
+    return DefineAsRegister(new LClampDToUint8(reg, FixedTemp(d1)));
   } else if (input_rep.IsInteger32()) {
     return DefineAsRegister(new LClampIToUint8(reg));
   } else {
     ASSERT(input_rep.IsTagged());
     // Register allocator doesn't (yet) support allocation of double
     // temps. Reserve d1 explicitly.
-    LClampTaggedToUint8* result = new LClampTaggedToUint8(reg, FixedTemp(d1));
+    LClampTToUint8* result = new LClampTToUint8(reg, FixedTemp(d1));
     return AssignEnvironment(DefineAsRegister(result));
   }
 }

diff --git a/src/arm/lithium-arm.h b/src/arm/lithium-arm.h
index 5a90f7a2ce4cdd5413e8238df9e13c8112c5b18e..e039fc651901f64d0eaf9f2bdbfa1f5755a94ed1 100644 (file)
--- a/src/arm/lithium-arm.h
+++ b/src/arm/lithium-arm.h
@@ -73,9 +73,9 @@ class LCodeGen;
   V(CheckMap)                                   \
   V(CheckPrototypeMaps)                         \
   V(CheckSmi)                                   \
-  V(ClampDoubleToUint8)                         \
+  V(ClampDToUint8)                              \
   V(ClampIToUint8)                              \
-  V(ClampTaggedToUint8)                         \
+  V(ClampTToUint8)                              \
   V(ClassOfTest)                                \
   V(ClassOfTestAndBranch)                       \
   V(CmpID)                                      \
@@ -1930,16 +1930,16 @@ class LCheckNonSmi: public LTemplateInstruction<0, 1, 0> {
 };
 
 
-class LClampDoubleToUint8: public LTemplateInstruction<1, 1, 1> {
+class LClampDToUint8: public LTemplateInstruction<1, 1, 1> {
  public:
-  explicit LClampDoubleToUint8(LOperand* value, LOperand* temp) {
+  LClampDToUint8(LOperand* value, LOperand* temp) {
     inputs_[0] = value;
     temps_[0] = temp;
   }
 
   LOperand* unclamped() { return inputs_[0]; }
 
-  DECLARE_CONCRETE_INSTRUCTION(ClampDoubleToUint8, "clamp-d-to-uint8")
+  DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8")
 };
 
 
@@ -1955,16 +1955,16 @@ class LClampIToUint8: public LTemplateInstruction<1, 1, 0> {
 };
 
 
-class LClampTaggedToUint8: public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8: public LTemplateInstruction<1, 1, 1> {
  public:
-  explicit LClampTaggedToUint8(LOperand* value, LOperand* temp) {
+  LClampTToUint8(LOperand* value, LOperand* temp) {
     inputs_[0] = value;
     temps_[0] = temp;
   }
 
   LOperand* unclamped() { return inputs_[0]; }
 
-  DECLARE_CONCRETE_INSTRUCTION(ClampTaggedToUint8, "clamp-t-to-uint8")
+  DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8")
 };
 
 

diff --git a/src/arm/lithium-codegen-arm.cc b/src/arm/lithium-codegen-arm.cc
index 878f09d21a22f57fa463275e7e5887846bacf06b..95ee13a343dc5afce087022ceef7c861f42b658d 100644 (file)
--- a/src/arm/lithium-codegen-arm.cc
+++ b/src/arm/lithium-codegen-arm.cc
@@ -4011,7 +4011,7 @@ void LCodeGen::DoCheckMap(LCheckMap* instr) {
 }
 
 
-void LCodeGen::DoClampDoubleToUint8(LClampDoubleToUint8* instr) {
+void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
   DoubleRegister value_reg = ToDoubleRegister(instr->unclamped());
   Register result_reg = ToRegister(instr->result());
   DoubleRegister temp_reg = ToDoubleRegister(instr->TempAt(0));
@@ -4026,7 +4026,7 @@ void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
 }
 
 
-void LCodeGen::DoClampTaggedToUint8(LClampTaggedToUint8* instr) {
+void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
   Register scratch = scratch0();
   Register input_reg = ToRegister(instr->unclamped());
   Register result_reg = ToRegister(instr->result());

diff --git a/src/ia32/lithium-codegen-ia32.cc b/src/ia32/lithium-codegen-ia32.cc
index a9fa79273d0d8dea8b9d8d1f24ba3aa4b4776435..25961b28524e1c796f58a0662886f3fa2223e635 100644 (file)
--- a/src/ia32/lithium-codegen-ia32.cc
+++ b/src/ia32/lithium-codegen-ia32.cc
@@ -3951,7 +3951,7 @@ void LCodeGen::DoCheckMap(LCheckMap* instr) {
 }
 
 
-void LCodeGen::DoClampDoubleToUint8(LClampDoubleToUint8* instr) {
+void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
   XMMRegister value_reg = ToDoubleRegister(instr->unclamped());
   Register result_reg = ToRegister(instr->result());
   __ ClampDoubleToUint8(value_reg, xmm0, result_reg);
@@ -3965,7 +3965,7 @@ void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
 }
 
 
-void LCodeGen::DoClampTaggedToUint8(LClampTaggedToUint8* instr) {
+void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
   ASSERT(instr->unclamped()->Equals(instr->result()));
   Register input_reg = ToRegister(instr->unclamped());
   Label is_smi, done, heap_number;

diff --git a/src/ia32/lithium-ia32.cc b/src/ia32/lithium-ia32.cc
index ee4f5c66826a5a8ebe1ba50630e6ec58c17d7ac5..fed25a046a4dac7b9295506cf12ce2d7058bb9da 100644 (file)
--- a/src/ia32/lithium-ia32.cc
+++ b/src/ia32/lithium-ia32.cc
@@ -1783,7 +1783,7 @@ LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
   Representation input_rep = value->representation();
   if (input_rep.IsDouble()) {
     LOperand* reg = UseRegister(value);
-    return DefineAsRegister(new LClampDoubleToUint8(reg));
+    return DefineAsRegister(new LClampDToUint8(reg));
   } else if (input_rep.IsInteger32()) {
     LOperand* reg = UseFixed(value, eax);
     return DefineFixed(new LClampIToUint8(reg), eax);
@@ -1793,7 +1793,7 @@ LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
     // Register allocator doesn't (yet) support allocation of double
     // temps. Reserve xmm1 explicitly.
     LOperand* temp = FixedTemp(xmm1);
-    LClampTaggedToUint8* result = new LClampTaggedToUint8(reg, temp);
+    LClampTToUint8* result = new LClampTToUint8(reg, temp);
     return AssignEnvironment(DefineFixed(result, eax));
   }
 }

diff --git a/src/ia32/lithium-ia32.h b/src/ia32/lithium-ia32.h
index 516222348e4a802baae30c06fdaf5633bd005de7..13139ea2f6c05b8786f61f1b7e1be69dea66d6da 100644 (file)
--- a/src/ia32/lithium-ia32.h
+++ b/src/ia32/lithium-ia32.h
@@ -67,9 +67,9 @@ class LCodeGen;
   V(CheckNonSmi)                                \
   V(CheckPrototypeMaps)                         \
   V(CheckSmi)                                   \
-  V(ClampDoubleToUint8)                         \
+  V(ClampDToUint8)                              \
   V(ClampIToUint8)                              \
-  V(ClampTaggedToUint8)                         \
+  V(ClampTToUint8)                              \
   V(ClassOfTest)                                \
   V(ClassOfTestAndBranch)                       \
   V(CmpID)                                      \
@@ -1977,15 +1977,15 @@ class LCheckSmi: public LTemplateInstruction<0, 1, 0> {
 };
 
 
-class LClampDoubleToUint8: public LTemplateInstruction<1, 1, 0> {
+class LClampDToUint8: public LTemplateInstruction<1, 1, 0> {
  public:
-  explicit LClampDoubleToUint8(LOperand* value) {
+  explicit LClampDToUint8(LOperand* value) {
     inputs_[0] = value;
   }
 
   LOperand* unclamped() { return inputs_[0]; }
 
-  DECLARE_CONCRETE_INSTRUCTION(ClampDoubleToUint8, "clamp-d-to-uint8")
+  DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8")
 };
 
 
@@ -2001,16 +2001,16 @@ class LClampIToUint8: public LTemplateInstruction<1, 1, 0> {
 };
 
 
-class LClampTaggedToUint8: public LTemplateInstruction<1, 1, 1> {
+class LClampTToUint8: public LTemplateInstruction<1, 1, 1> {
  public:
-  explicit LClampTaggedToUint8(LOperand* value, LOperand* temp) {
+  LClampTToUint8(LOperand* value, LOperand* temp) {
     inputs_[0] = value;
     temps_[0] = temp;
   }
 
   LOperand* unclamped() { return inputs_[0]; }
 
-  DECLARE_CONCRETE_INSTRUCTION(ClampTaggedToUint8, "clamp-t-to-uint8")
+  DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8")
 };
 
 

diff --git a/src/x64/lithium-codegen-x64.cc b/src/x64/lithium-codegen-x64.cc
index c0ef079dc5bedea5bfaee021323c187a47a71c9e..c35f5e9042680242fba365bdf09ab1b58255f0dc 100644 (file)
--- a/src/x64/lithium-codegen-x64.cc
+++ b/src/x64/lithium-codegen-x64.cc
@@ -3775,7 +3775,7 @@ void LCodeGen::DoCheckMap(LCheckMap* instr) {
 }
 
 
-void LCodeGen::DoClampDoubleToUint8(LClampDoubleToUint8* instr) {
+void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
   XMMRegister value_reg = ToDoubleRegister(instr->unclamped());
   Register result_reg = ToRegister(instr->result());
   Register temp_reg = ToRegister(instr->TempAt(0));
@@ -3790,7 +3790,7 @@ void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
 }
 
 
-void LCodeGen::DoClampTaggedToUint8(LClampTaggedToUint8* instr) {
+void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
   ASSERT(instr->unclamped()->Equals(instr->result()));
   Register input_reg = ToRegister(instr->unclamped());
   Register temp_reg = ToRegister(instr->TempAt(0));

diff --git a/src/x64/lithium-x64.cc b/src/x64/lithium-x64.cc
index 69c8c476b9332c101419af852f8aac87471ccabd..00fd1bb8fc187d2e5f3a76e80ce87e365b073843 100644 (file)
--- a/src/x64/lithium-x64.cc
+++ b/src/x64/lithium-x64.cc
@@ -1747,17 +1747,17 @@ LInstruction* LChunkBuilder::DoClampToUint8(HClampToUint8* instr) {
   Representation input_rep = value->representation();
   LOperand* reg = UseRegister(value);
   if (input_rep.IsDouble()) {
-    return DefineAsRegister(new LClampDoubleToUint8(reg,
-                                                    TempRegister()));
+    return DefineAsRegister(new LClampDToUint8(reg,
+                                               TempRegister()));
   } else if (input_rep.IsInteger32()) {
     return DefineSameAsFirst(new LClampIToUint8(reg));
   } else {
     ASSERT(input_rep.IsTagged());
     // Register allocator doesn't (yet) support allocation of double
     // temps. Reserve xmm1 explicitly.
-    LClampTaggedToUint8* result = new LClampTaggedToUint8(reg,
-                                                          TempRegister(),
-                                                          FixedTemp(xmm1));
+    LClampTToUint8* result = new LClampTToUint8(reg,
+                                                TempRegister(),
+                                                FixedTemp(xmm1));
     return AssignEnvironment(DefineSameAsFirst(result));
   }
 }

diff --git a/src/x64/lithium-x64.h b/src/x64/lithium-x64.h
index 0a16b65cb856df1e6503afd58516888e532ba779..0e3369cbce5720467f6ad4349d4ab01440f4fa6a 100644 (file)
--- a/src/x64/lithium-x64.h
+++ b/src/x64/lithium-x64.h
@@ -73,9 +73,9 @@ class LCodeGen;
   V(CheckNonSmi)                                \
   V(CheckPrototypeMaps)                         \
   V(CheckSmi)                                   \
-  V(ClampDoubleToUint8)                         \
+  V(ClampDToUint8)                              \
   V(ClampIToUint8)                              \
-  V(ClampTaggedToUint8)                         \
+  V(ClampTToUint8)                              \
   V(ClassOfTest)                                \
   V(ClassOfTestAndBranch)                       \
   V(CmpID)                                      \
@@ -1910,16 +1910,16 @@ class LCheckSmi: public LTemplateInstruction<0, 1, 0> {
 };
 
 
-class LClampDoubleToUint8: public LTemplateInstruction<1, 1, 1> {
+class LClampDToUint8: public LTemplateInstruction<1, 1, 1> {
  public:
-  explicit LClampDoubleToUint8(LOperand* value, LOperand* temp) {
+  LClampDToUint8(LOperand* value, LOperand* temp) {
     inputs_[0] = value;
     temps_[0] = temp;
   }
 
   LOperand* unclamped() { return inputs_[0]; }
 
-  DECLARE_CONCRETE_INSTRUCTION(ClampDoubleToUint8, "clamp-d-to-uint8")
+  DECLARE_CONCRETE_INSTRUCTION(ClampDToUint8, "clamp-d-to-uint8")
 };
 
 
@@ -1935,11 +1935,11 @@ class LClampIToUint8: public LTemplateInstruction<1, 1, 0> {
 };
 
 
-class LClampTaggedToUint8: public LTemplateInstruction<1, 1, 2> {
+class LClampTToUint8: public LTemplateInstruction<1, 1, 2> {
  public:
-  explicit LClampTaggedToUint8(LOperand* value,
-                               LOperand* temp,
-                               LOperand* temp2) {
+  LClampTToUint8(LOperand* value,
+                 LOperand* temp,
+                 LOperand* temp2) {
     inputs_[0] = value;
     temps_[0] = temp;
     temps_[1] = temp2;
@@ -1947,7 +1947,7 @@ class LClampTaggedToUint8: public LTemplateInstruction<1, 1, 2> {
 
   LOperand* unclamped() { return inputs_[0]; }
 
-  DECLARE_CONCRETE_INSTRUCTION(ClampTaggedToUint8, "clamp-t-to-uint8")
+  DECLARE_CONCRETE_INSTRUCTION(ClampTToUint8, "clamp-t-to-uint8")
 };