Compute static type information for remaining expression types on x64 platfor...

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 7029 matching lines @@
           UNREACHABLE();
           break;
       }
       frame_->Push(&value);
     } else {
       Load(node->expression());
       bool overwrite =
           (node->expression()->AsBinaryOperation() != NULL &&
            node->expression()->AsBinaryOperation()->ResultOverwriteAllowed());
       switch (op) {
+        case Token::NOT:
+        case Token::DELETE:
+        case Token::TYPEOF:
+          UNREACHABLE();  // handled above
+          break;
+
         case Token::SUB: {
           GenericUnaryOpStub stub(Token::SUB, overwrite);
           Result operand = frame_->Pop();
           Result answer = frame_->CallStub(&stub, &operand);
           answer.set_type_info(TypeInfo::Number());
           frame_->Push(&answer);
           break;
         }
         case Token::BIT_NOT: {
           // Smi check.
@@ skipping 20 matching lines @@
             continue_label.Jump(&answer);
 
             smi_label.Bind(&answer);
             answer.ToRegister();
             frame_->Spill(answer.reg());
             // Set smi tag bit. It will be reset by the not operation.
             __ lea(answer.reg(), Operand(answer.reg(), kSmiTagMask));
             __ not_(answer.reg());
 
             continue_label.Bind(&answer);
-            if (operand_info.IsInteger32()) {
-              answer.set_type_info(TypeInfo::Integer32());
-            } else {
-              answer.set_type_info(TypeInfo::Number());
-            }
+            answer.set_type_info(TypeInfo::Integer32());
             frame_->Push(&answer);
           }
           break;
         }
         case Token::ADD: {
           // Smi check.
           JumpTarget continue_label;
           Result operand = frame_->Pop();
           TypeInfo operand_info = operand.type_info();
           operand.ToRegister();
           __ test(operand.reg(), Immediate(kSmiTagMask));
           continue_label.Branch(zero, &operand, taken);
 
           frame_->Push(&operand);
           Result answer = frame_->InvokeBuiltin(Builtins::TO_NUMBER,
                                               CALL_FUNCTION, 1);
 
           continue_label.Bind(&answer);
           if (operand_info.IsSmi()) {
             answer.set_type_info(TypeInfo::Smi());
           } else if (operand_info.IsInteger32()) {
             answer.set_type_info(TypeInfo::Integer32());
           } else {
             answer.set_type_info(TypeInfo::Number());
           }
           frame_->Push(&answer);
           break;
         }
         default:
-          // NOT, DELETE, TYPEOF, and VOID are handled outside the
-          // switch.
           UNREACHABLE();
       }
     }
   }
 }
 
 
 // The value in dst was optimistically incremented or decremented.  The
 // result overflowed or was not smi tagged.  Undo the operation, call
 // into the runtime to convert the argument to a number, and call the
@@ skipping 190 matching lines @@
     } else {
       // If the count operation didn't overflow and the result is a valid
       // smi, we're done. Otherwise, we jump to the deferred slow-case
       // code.
       // We combine the overflow and the smi tag check if we could
       // successfully allocate a temporary byte register.
       if (tmp.is_valid()) {
         __ setcc(overflow, tmp.reg());
         __ or_(Operand(tmp.reg()), new_value.reg());
         __ test(tmp.reg(), Immediate(kSmiTagMask));
-        tmp.Unuse();
+        tmp.Unusec();
         deferred->Branch(not_zero);
       } else {
         // Otherwise we test separately for overflow and smi tag.
         deferred->Branch(overflow);
         __ test(new_value.reg(), Immediate(kSmiTagMask));
         deferred->Branch(not_zero);
       }
     }
     deferred->BindExit();
 
@@ skipping 5574 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal