Remove TypeFeedbackId parameters from assembler and full-code.

src/crankshaft/arm/lithium-codegen-arm.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/crankshaft/arm/lithium-codegen-arm.h"
 
 #include "src/assembler-inl.h"
 #include "src/base/bits.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/code-factory.h"
@@ skipping 653 matching lines @@
 
 void LCodeGen::CallCodeGeneric(Handle<Code> code,
                                RelocInfo::Mode mode,
                                LInstruction* instr,
                                SafepointMode safepoint_mode,
                                TargetAddressStorageMode storage_mode) {
   DCHECK(instr != NULL);
   // Block literal pool emission to ensure nop indicating no inlined smi code
   // is in the correct position.
   Assembler::BlockConstPoolScope block_const_pool(masm());
-  __ Call(code, mode, TypeFeedbackId::None(), al, storage_mode, false);
+  __ Call(code, mode, al, storage_mode, false);
   RecordSafepointWithLazyDeopt(instr, safepoint_mode);
 
   // Signal that we don't inline smi code before these stubs in the
   // optimizing code generator.
   if (code->kind() == Code::BINARY_OP_IC ||
       code->kind() == Code::COMPARE_IC) {
     __ nop();
   }
 }
 
@@ skipping 2866 matching lines @@
     LPointerMap* pointers = instr->pointer_map();
     SafepointGenerator generator(this, pointers, Safepoint::kLazyDeopt);
 
     if (instr->target()->IsConstantOperand()) {
       LConstantOperand* target = LConstantOperand::cast(instr->target());
       Handle<Code> code = Handle<Code>::cast(ToHandle(target));
       generator.BeforeCall(__ CallSize(code, RelocInfo::CODE_TARGET));
       PlatformInterfaceDescriptor* call_descriptor =
           instr->descriptor().platform_specific_descriptor();
       if (call_descriptor != NULL) {
-        __ Call(code, RelocInfo::CODE_TARGET, TypeFeedbackId::None(), al,
+        __ Call(code, RelocInfo::CODE_TARGET, al,
                 call_descriptor->storage_mode());
       } else {
-        __ Call(code, RelocInfo::CODE_TARGET, TypeFeedbackId::None(), al);
+        __ Call(code, RelocInfo::CODE_TARGET, al);
       }
     } else {
       DCHECK(instr->target()->IsRegister());
       Register target = ToRegister(instr->target());
       generator.BeforeCall(__ CallSize(target));
       // Make sure we don't emit any additional entries in the constant pool
       // before the call to ensure that the CallCodeSize() calculated the
       // correct
       // number of instructions for the constant pool load.
       {
@@ skipping 1785 matching lines @@
   __ ldr(result, FieldMemOperand(scratch,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ bind(deferred->exit());
   __ bind(&done);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8