Add support for unary plus in hydrogen compiler.

src/hydrogen.cc

 // 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 467 matching lines @@
   if (!pointer->is_set()) {
     HConstant* constant = new HConstant(Handle<Object>(value),
                                         Representation::Tagged());
     constant->InsertAfter(GetConstantUndefined());
     pointer->set(constant);
   }
   return pointer->get();
 }
 
 
+HConstant* HGraph::GetConstant0() {
+  return GetConstant(&constant_0_, Smi::FromInt(0));
+}
+
+
 HConstant* HGraph::GetConstant1() {
   return GetConstant(&constant_1_, Smi::FromInt(1));
 }
 
 
 HConstant* HGraph::GetConstantMinus1() {
   return GetConstant(&constant_minus1_, Smi::FromInt(-1));
 }
 
 
@@ skipping 4014 matching lines @@
 
       HBasicBlock* join =
           CreateJoin(materialize_false, materialize_true, expr->id());
       set_current_block(join);
       ast_context()->ReturnValue(Pop());
     } else {
       ASSERT(ast_context()->IsEffect());
       VisitForEffect(expr->expression());
     }
 
-  } else if (op == Token::BIT_NOT || op == Token::SUB) {
+  } else if (op == Token::BIT_NOT || op == Token::SUB || op == Token::ADD) {
     VISIT_FOR_VALUE(expr->expression());
     HValue* value = Pop();
     HInstruction* instr = NULL;
     switch (op) {
       case Token::BIT_NOT:
         instr = new HBitNot(value);
         break;
       case Token::SUB:
-        instr = new HMul(graph_->GetConstantMinus1(), value);
+        instr = new HSub(graph_->GetConstant0(), value);

[Kevin Millikin (Chromium), 2011/03/14 14:18:46]

I'm suspicious of this case.  Isn't it true that:

-(0) = 0-0 = 0+(-0) = +0

?  We should probably have a test that checks the corner cases for unary minus.

There is type feedback for the stub in unoptimized code, so it seems better to
call HGraphBuilder::BuildBinaryOperation and get our hands on that feedback.

[Lasse Reichstein, 2011/03/15 12:18:33]

Argh, foiled again by -0.
Yes, you are correct.
Incidentally, it would work if we used a ConstantMinus0 instead, but then we
would lose smi-ness.
I guess multiplication is safer (and the slight speedup I saw was probably due
to suddently being able to ignore -0)

         break;
+      case Token::ADD:
+        instr = new HSub(value, graph_->GetConstant0());

[Kevin Millikin (Chromium), 2011/03/14 14:18:46]

I'm also suspicious of this:

+(-0) = 0-(-0) = 0+0 = +0

[Lasse Reichstein, 2011/03/15 12:18:33]

Agree, that's bad too.

       default:
         UNREACHABLE();
         break;
     }
     ast_context()->ReturnInstruction(instr, expr->id());
   } else if (op == Token::TYPEOF) {
     VISIT_FOR_VALUE(expr->expression());
     HValue* value = Pop();
     ast_context()->ReturnInstruction(new HTypeof(value), expr->id());
   } else {
@@ skipping 1363 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal