| Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame^] | 1 | // Copyright 2014 the V8 project authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include <cmath> |
| 6 | #include <functional> |
| 7 | #include <limits> |
| 8 | |
| 9 | #include "src/assembler.h" |
| 10 | #include "src/base/bits.h" |
| 11 | #include "src/base/utils/random-number-generator.h" |
| 12 | #include "src/codegen.h" |
| 13 | #include "src/compiler.h" |
| 14 | #include "src/compiler/linkage.h" |
| 15 | #include "src/macro-assembler.h" |
| 16 | #include "test/cctest/cctest.h" |
| 17 | #include "test/cctest/compiler/codegen-tester.h" |
| 18 | #include "test/cctest/compiler/value-helper.h" |
| 19 | |
| 20 | namespace v8 { |
| 21 | namespace internal { |
| 22 | namespace compiler { |
| 23 | |
| 24 | namespace { |
| 25 | |
| 26 | CallDescriptor* GetCallDescriptor(Zone* zone, int return_count, |
| 27 | int param_count) { |
| 28 | MachineSignature::Builder msig(zone, return_count, param_count); |
| 29 | LocationSignature::Builder locations(zone, return_count, param_count); |
| 30 | const RegisterConfiguration* config = |
| 31 | RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN); |
| 32 | |
| 33 | // Add return location(s). |
| 34 | CHECK(return_count <= config->num_allocatable_general_registers()); |
| 35 | for (int i = 0; i < return_count; i++) { |
| 36 | msig.AddReturn(MachineType::Int32()); |
| 37 | locations.AddReturn( |
| 38 | LinkageLocation::ForRegister(config->allocatable_general_codes()[i])); |
| 39 | } |
| 40 | |
| 41 | // Add register and/or stack parameter(s). |
| 42 | CHECK(param_count <= config->num_allocatable_general_registers()); |
| 43 | for (int i = 0; i < param_count; i++) { |
| 44 | msig.AddParam(MachineType::Int32()); |
| 45 | locations.AddParam( |
| 46 | LinkageLocation::ForRegister(config->allocatable_general_codes()[i])); |
| 47 | } |
| 48 | |
| 49 | const RegList kCalleeSaveRegisters = 0; |
| 50 | const RegList kCalleeSaveFPRegisters = 0; |
| 51 | |
| 52 | // The target for WASM calls is always a code object. |
| 53 | MachineType target_type = MachineType::AnyTagged(); |
| 54 | LinkageLocation target_loc = LinkageLocation::ForAnyRegister(); |
| 55 | return new (zone) CallDescriptor( // -- |
| 56 | CallDescriptor::kCallCodeObject, // kind |
| 57 | target_type, // target MachineType |
| 58 | target_loc, // target location |
| 59 | msig.Build(), // machine_sig |
| 60 | locations.Build(), // location_sig |
| 61 | 0, // js_parameter_count |
| 62 | compiler::Operator::kNoProperties, // properties |
| 63 | kCalleeSaveRegisters, // callee-saved registers |
| 64 | kCalleeSaveFPRegisters, // callee-saved fp regs |
| 65 | CallDescriptor::kNoFlags, // flags |
| 66 | "c-call"); |
| 67 | } |
| 68 | } // namespace |
| 69 | |
| 70 | |
| 71 | TEST(ReturnThreeValues) { |
| 72 | Zone zone; |
| 73 | CallDescriptor* desc = GetCallDescriptor(&zone, 3, 2); |
| 74 | HandleAndZoneScope handles; |
| 75 | RawMachineAssembler m(handles.main_isolate(), |
| 76 | new (handles.main_zone()) Graph(handles.main_zone()), |
| 77 | desc, MachineType::PointerRepresentation(), |
| 78 | InstructionSelector::SupportedMachineOperatorFlags()); |
| 79 | |
| 80 | Node* p0 = m.Parameter(0); |
| 81 | Node* p1 = m.Parameter(1); |
| 82 | Node* add = m.Int32Add(p0, p1); |
| 83 | Node* sub = m.Int32Sub(p0, p1); |
| 84 | Node* mul = m.Int32Mul(p0, p1); |
| 85 | m.Return(add, sub, mul); |
| 86 | |
| 87 | CompilationInfo info("testing", handles.main_isolate(), handles.main_zone()); |
| 88 | Handle<Code> code = |
| 89 | Pipeline::GenerateCodeForTesting(&info, desc, m.graph(), m.Export()); |
| 90 | #ifdef ENABLE_DISASSEMBLER |
| 91 | if (FLAG_print_code) { |
| 92 | OFStream os(stdout); |
| 93 | code->Disassemble("three_value", os); |
| 94 | } |
| 95 | #endif |
| 96 | |
| 97 | RawMachineAssemblerTester<int32_t> mt; |
| 98 | Node* a = mt.Int32Constant(123); |
| 99 | Node* b = mt.Int32Constant(456); |
| 100 | Node* ret3 = mt.AddNode(mt.common()->Call(desc), mt.HeapConstant(code), a, b); |
| 101 | Node* x = mt.AddNode(mt.common()->Projection(0), ret3); |
| 102 | Node* y = mt.AddNode(mt.common()->Projection(1), ret3); |
| 103 | Node* z = mt.AddNode(mt.common()->Projection(2), ret3); |
| 104 | Node* ret = mt.Int32Add(mt.Int32Add(x, y), z); |
| 105 | mt.Return(ret); |
| 106 | #ifdef ENABLE_DISASSEMBLER |
| 107 | Handle<Code> code2 = mt.GetCode(); |
| 108 | if (FLAG_print_code) { |
| 109 | OFStream os(stdout); |
| 110 | code2->Disassemble("three_value_call", os); |
| 111 | } |
| 112 | #endif |
| 113 | CHECK_EQ((123 + 456) + (123 - 456) + (123 * 456), mt.Call()); |
| 114 | } |
| 115 | |
| 116 | } // namespace compiler |
| 117 | } // namespace internal |
| 118 | } // namespace v8 |