[wasm] remove faux code objects

src/compiler/arm/code-generator-arm.cc

 // Copyright 2014 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/compiler/code-generator.h"
 
 #include "src/arm/macro-assembler-arm.h"
 #include "src/ast/scopes.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
@@ skipping 452 matching lines @@
 
 // Assembles an instruction after register allocation, producing machine code.
 CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     Instruction* instr) {
   ArmOperandConverter i(this, instr);
 
   __ MaybeCheckConstPool();
   InstructionCode opcode = instr->opcode();
   ArchOpcode arch_opcode = ArchOpcodeField::decode(opcode);
   switch (arch_opcode) {
     case kArchCallCodeObject: {

[titzer, 2016/06/02 13:17:08]

We should add another enum case here and not overload the CallCodeObject logic.

[Mircea Trofin, 2016/06/02 14:46:21]

Happy to.

I intend to do the same thing for imports (add a WASM_IMPORT_CALL, traverse
reloc info to patch). This would help with decoupling compilation from
instantiation: compilation gets you a fixed array of code objects, not yet tied
to imports, and with possibly wrong memory size. Instantiation then means deep
cloning the FixedArray of code objects (haven't looked at how.
serialize/deserialize would work, worse case), linking the imports, and patching
the mem size (we probably want, then, to patch mem size with "0" at compile time
or something). 

I believe the only remaining parameter embedded in the compiled code is the
native context, which is fine in the same isolate.

Now the question: do we want to have one kArchWasmCall covering both imports and
internal calls - letting the reloc info distinguish which is which - or do we
want to have 2 codes? I locally have a patch (x64 only) validating we can do the
former (with the current design, where we piggyback on kArchCallCodeObject).
There may be other considerations, though, for having 2 codes.

Thoughts?

       EnsureSpaceForLazyDeopt();
       if (instr->InputAt(0)->IsImmediate()) {
-        __ Call(Handle<Code>::cast(i.InputHeapObject(0)),
-                RelocInfo::CODE_TARGET);
+        Constant callee_operand = i.ToConstant(instr->InputAt(0));
+        if (callee_operand.type() == Constant::Type::kInt32) {
+          __ Call(reinterpret_cast<Address>(callee_operand.ToInt32()),
+                  RelocInfo::WASM_DIRECT_CALL);
+        } else {
+          __ Call(Handle<Code>::cast(i.InputHeapObject(0)),
+                  RelocInfo::CODE_TARGET);
+        }
       } else {
         __ add(ip, i.InputRegister(0),
                Operand(Code::kHeaderSize - kHeapObjectTag));
         __ Call(ip);
       }
       RecordCallPosition(instr);
       DCHECK_EQ(LeaveCC, i.OutputSBit());
       frame_access_state()->ClearSPDelta();
       break;
     }
@@ skipping 1199 matching lines @@
       padding_size -= v8::internal::Assembler::kInstrSize;
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8