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

src/ia32/lithium-ia32.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 108 matching lines @@
   V(LoadContextSlot)                            \
   V(LoadElements)                               \
   V(LoadFunctionPrototype)                      \
   V(LoadGlobal)                                 \
   V(LoadKeyedFastElement)                       \
   V(LoadKeyedGeneric)                           \
   V(LoadNamedField)                             \
   V(LoadNamedGeneric)                           \
   V(ModI)                                       \
   V(MulI)                                       \
+  V(NegI)                                       \
+  V(NegD)                                       \
+  V(NegT)                                       \
   V(NumberTagD)                                 \
   V(NumberTagI)                                 \
   V(NumberUntagD)                               \
   V(ObjectLiteral)                              \
   V(OsrEntry)                                   \
   V(OuterContext)                               \
   V(Parameter)                                  \
   V(Power)                                      \
   V(PushArgument)                               \
   V(RegExpLiteral)                              \
@@ skipping 905 matching lines @@
 class LBitNotI: public LTemplateInstruction<1, 1, 0> {
  public:
   explicit LBitNotI(LOperand* value) {
     inputs_[0] = value;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(BitNotI, "bit-not-i")
 };
 
 
+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) {
     inputs_[0] = left;
     inputs_[1] = right;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i")
   DECLARE_HYDROGEN_ACCESSOR(Add)
 };
@@ skipping 942 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_LITHIUM_IA32_H_