[wasm] remove faux code objects

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

Index: src/compiler/arm/code-generator-arm.cc
diff --git a/src/compiler/arm/code-generator-arm.cc b/src/compiler/arm/code-generator-arm.cc
index cef16c2faa09ad8085c9110d7e34aae5a7000a8d..a98fe51c2bcd66e029532fd61646c4b94ddfbddb 100644
--- a/src/compiler/arm/code-generator-arm.cc
+++ b/src/compiler/arm/code-generator-arm.cc
@@ -473,8 +473,14 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
     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));