Add a genuine unary minus instruction to Crankshaft....

src/ia32/lithium-ia32.h

Index: src/ia32/lithium-ia32.h
===================================================================
--- src/ia32/lithium-ia32.h	(revision 6698)
+++ src/ia32/lithium-ia32.h	(working copy)
@@ -126,6 +126,9 @@
   V(LoadNamedGeneric)                           \
   V(ModI)                                       \
   V(MulI)                                       \
+  V(NegI)                                       \
+  V(NegD)                                       \
+  V(NegT)                                       \
   V(NumberTagD)                                 \
   V(NumberTagI)                                 \
   V(NumberUntagD)                               \
@@ -1051,6 +1054,38 @@
 };
 
 
+class LNegI: public LTemplateInstruction<1, 1, 0> {
+ public:
+  explicit LNegI(LOperand* value) {

[Kevin Millikin (Chromium), 2011/02/11 12:12:59]

I've been trying to create simple accessors for the inputs (e.g., LOperand*
value() { return inputs_[0]; }).

It's not so bad for unary operations, but for the others I don't want the
programmer to have to remember the position of the arguments.

It also makes it easier to add arguments or reorder them in the LInstruction
without having to guard against explicit use of indices.

[fschneider, 2011/02/11 12:44:12]

Done.

+    inputs_[0] = value;
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(NegI, "neg-i")
+  DECLARE_HYDROGEN_ACCESSOR(Neg)
+};
+
+
+class LNegD: public LTemplateInstruction<1, 1, 1> {
+ public:
+  explicit LNegD(LOperand* value, LOperand* temp) {
+    inputs_[0] = value;
+    temps_[0] = temp;
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(NegD, "neg-d")
+};
+
+
+class LNegT: public LTemplateInstruction<1, 1, 0> {
+ public:
+  explicit LNegT(LOperand* value) {
+    inputs_[0] = value;
+  }
+
+  DECLARE_CONCRETE_INSTRUCTION(NegT, "neg-t")
+};
+
+
 class LAddI: public LTemplateInstruction<1, 2, 0> {
  public:
   LAddI(LOperand* left, LOperand* right) {