templatize operand constructors

src/a64/builtins-a64.cc

 // Copyright 2013 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 1009 matching lines @@
   // 2. Get the function to call (passed as receiver) from the stack, check
   //    if it is a function.
   Label slow, non_function;
   __ Peek(function, Operand(argc, LSL, kXRegSizeInBytesLog2));
   __ JumpIfSmi(function, &non_function);
   __ JumpIfNotObjectType(function, scratch1, receiver_type,
                          JS_FUNCTION_TYPE, &slow);
 
   // 3a. Patch the first argument if necessary when calling a function.
   Label shift_arguments;
-  __ Mov(call_type, call_type_JS_func);
+  __ Mov(call_type, static_cast<int>(call_type_JS_func));
   { Label convert_to_object, use_global_receiver, patch_receiver;
     // Change context eagerly in case we need the global receiver.
     __ Ldr(cp, FieldMemOperand(function, JSFunction::kContextOffset));
 
     // Do not transform the receiver for strict mode functions.
     // Also do not transform the receiver for native (Compilerhints already in
     // x3).
     __ Ldr(scratch1,
            FieldMemOperand(function, JSFunction::kSharedFunctionInfoOffset));
     __ Ldr(scratch2.W(),
@@ skipping 30 matching lines @@
       __ Mov(receiver, x0);
 
       __ Pop(argc);
       __ SmiUntag(argc);
 
       // Exit the internal frame.
     }
 
     // Restore the function and flag in the registers.
     __ Peek(function, Operand(argc, LSL, kXRegSizeInBytesLog2));
-    __ Mov(call_type, call_type_JS_func);
+    __ Mov(call_type, static_cast<int>(call_type_JS_func));
     __ B(&patch_receiver);
 
     __ Bind(&use_global_receiver);
     __ Ldr(receiver, GlobalObjectMemOperand());
     __ Ldr(receiver,
            FieldMemOperand(receiver, GlobalObject::kGlobalReceiverOffset));
 
 
     __ Bind(&patch_receiver);
     __ Sub(scratch1, argc, 1);
     __ Poke(receiver, Operand(scratch1, LSL, kXRegSizeInBytesLog2));
 
     __ B(&shift_arguments);
   }
 
   // 3b. Check for function proxy.
   __ Bind(&slow);
-  __ Mov(call_type, call_type_func_proxy);
+  __ Mov(call_type, static_cast<int>(call_type_func_proxy));
   __ Cmp(receiver_type, JS_FUNCTION_PROXY_TYPE);
   __ B(eq, &shift_arguments);
   __ Bind(&non_function);
-  __ Mov(call_type, call_type_non_func);
+  __ Mov(call_type, static_cast<int>(call_type_non_func));
 
   // 3c. Patch the first argument when calling a non-function.  The
   //     CALL_NON_FUNCTION builtin expects the non-function callee as
   //     receiver, so overwrite the first argument which will ultimately
   //     become the receiver.
   // call type (0: JS function, 1: function proxy, 2: non-function)
   __ Sub(scratch1, argc, 1);
   __ Poke(function, Operand(scratch1, LSL, kXRegSizeInBytesLog2));
 
   // 4. Shift arguments and return address one slot down on the stack
@@ skipping 17 matching lines @@
     __ Drop(1);
   }
 
   // 5a. Call non-function via tail call to CALL_NON_FUNCTION builtin,
   //     or a function proxy via CALL_FUNCTION_PROXY.
   // call type (0: JS function, 1: function proxy, 2: non-function)
   { Label js_function, non_proxy;
     __ Cbz(call_type, &js_function);
     // Expected number of arguments is 0 for CALL_NON_FUNCTION.
     __ Mov(x2, 0);
-    __ Cmp(call_type, call_type_func_proxy);
+    __ Cmp(call_type, static_cast<int>(call_type_func_proxy));
     __ B(ne, &non_proxy);
 
     __ Push(function);  // Re-add proxy object as additional argument.
     __ Add(argc, argc, 1);
     __ GetBuiltinFunction(function, Builtins::CALL_FUNCTION_PROXY);
     __ Jump(masm->isolate()->builtins()->ArgumentsAdaptorTrampoline(),
             RelocInfo::CODE_TARGET);
 
     __ Bind(&non_proxy);
     __ GetBuiltinFunction(function, Builtins::CALL_NON_FUNCTION);
@@ skipping 318 matching lines @@
   __ Bind(&dont_adapt_arguments);
   __ Jump(x3);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM