Implement typeof in fast compiler.

src/x64/fast-codegen-x64.cc

 // Copyright 2009 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 973 matching lines @@
       __ bind(&discard);
       __ addq(rsp, Immediate(kPointerSize));
       __ jmp(true_label_);
       break;
     }
   }
 }
 
 
 void FastCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
-  Comment cmnt(masm_, "[ UnaryOperation");
   switch (expr->op()) {
-    case Token::VOID:
+    case Token::VOID: {
+      Comment cmnt(masm_, "[ UnaryOperation (VOID)");
       Visit(expr->expression());
       ASSERT_EQ(Expression::kEffect, expr->expression()->context());
       switch (expr->context()) {
         case Expression::kUninitialized:
           UNREACHABLE();
           break;
         case Expression::kEffect:
           break;
         case Expression::kValue:
           __ PushRoot(Heap::kUndefinedValueRootIndex);
           break;
         case Expression::kTestValue:
           // Value is false so it's needed.
           __ PushRoot(Heap::kUndefinedValueRootIndex);
           // Fall through.
         case Expression::kTest:  // Fall through.
         case Expression::kValueTest:
           __ jmp(false_label_);
           break;
       }
       break;
+    }
 
     case Token::NOT: {
+      Comment cmnt(masm_, "[ UnaryOperation (NOT)");
       ASSERT_EQ(Expression::kTest, expr->expression()->context());
 
       Label push_true;
       Label push_false;
       Label done;
       Label* saved_true = true_label_;
       Label* saved_false = false_label_;
       switch (expr->context()) {
         case Expression::kUninitialized:
           UNREACHABLE();
@@ skipping 40 matching lines @@
           __ bind(&push_false);
           __ PushRoot(Heap::kFalseValueRootIndex);
           __ jmp(saved_false);
           break;
       }
       true_label_ = saved_true;
       false_label_ = saved_false;
       break;
     }
 
+    case Token::TYPEOF: {
+      Comment cmnt(masm_, "[ UnaryOperation (TYPEOF)");
+      ASSERT_EQ(Expression::kValue, expr->expression()->context());
+
+      VariableProxy* proxy = expr->expression()->AsVariableProxy();
+      if (proxy != NULL && proxy->var()->is_global()) {
+        Comment cmnt(masm_, "Global variable");
+        __ push(CodeGenerator::GlobalObject());
+        __ Move(rcx, proxy->name());
+        Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
+        // Use a regular load, not a contextual load, to avoid reference error.
+        __ Call(ic, RelocInfo::CODE_TARGET);
+        __ movq(Operand(rsp, 0), rax);
+      } else if (proxy != NULL &&
+                 proxy->var()->slot() != NULL &&
+                 proxy->var()->slot()->type() == Slot::LOOKUP) {
+        __ push(rsi);
+        __ Push(proxy->name());
+        __ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
+        __ push(rax);
+      } else {
+        // This expression cannot throw a reference error at the top level.
+        Visit(expr->expression());
+      }
+
+      __ CallRuntime(Runtime::kTypeof, 1);
+      Move(expr->context(), rax);
+      break;
+    }
+
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
   Comment cmnt(masm_, "[ BinaryOperation");
   switch (expr->op()) {
     case Token::COMMA:
@@ skipping 191 matching lines @@
   true_label_ = saved_true;
   false_label_ = saved_false;
   // Convert current context to test context: End post-test code.
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal