codegen_test.cc revision f61b5377068f22c0be7b2f6e62961e620408beb2
1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "builder.h" 18#include "code_generator.h" 19#include "common_compiler_test.h" 20#include "dex_file.h" 21#include "dex_instruction.h" 22#include "instruction_set.h" 23#include "nodes.h" 24#include "optimizing_unit_test.h" 25 26#include "gtest/gtest.h" 27 28namespace art { 29 30class InternalCodeAllocator : public CodeAllocator { 31 public: 32 InternalCodeAllocator() { } 33 34 virtual uint8_t* Allocate(size_t size) { 35 size_ = size; 36 memory_.reset(new uint8_t[size]); 37 return memory_.get(); 38 } 39 40 size_t GetSize() const { return size_; } 41 uint8_t* GetMemory() const { return memory_.get(); } 42 43 private: 44 size_t size_; 45 std::unique_ptr<uint8_t[]> memory_; 46 47 DISALLOW_COPY_AND_ASSIGN(InternalCodeAllocator); 48}; 49 50#if defined(__i386__) || defined(__arm__) || defined(__x86_64__) 51static void Run(const InternalCodeAllocator& allocator, bool has_result, int32_t expected) { 52 typedef int32_t (*fptr)(); 53 CommonCompilerTest::MakeExecutable(allocator.GetMemory(), allocator.GetSize()); 54 fptr f = reinterpret_cast<fptr>(allocator.GetMemory()); 55 int32_t result = f(); 56 if (has_result) { 57 CHECK_EQ(result, expected); 58 } 59} 60#endif 61 62static void TestCode(const uint16_t* data, bool has_result = false, int32_t expected = 0) { 63 ArenaPool pool; 64 ArenaAllocator arena(&pool); 65 HGraphBuilder builder(&arena); 66 const DexFile::CodeItem* item = reinterpret_cast<const DexFile::CodeItem*>(data); 67 HGraph* graph = builder.BuildGraph(*item); 68 ASSERT_NE(graph, nullptr); 69 InternalCodeAllocator allocator; 70 71 CodeGenerator* codegen = CodeGenerator::Create(&arena, graph, kX86); 72 codegen->CompileBaseline(&allocator); 73#if defined(__i386__) 74 Run(allocator, has_result, expected); 75#endif 76 77 codegen = CodeGenerator::Create(&arena, graph, kArm); 78 codegen->CompileBaseline(&allocator); 79#if defined(__arm__) 80 Run(allocator, has_result, expected); 81#endif 82 83 codegen = CodeGenerator::Create(&arena, graph, kX86_64); 84 codegen->CompileBaseline(&allocator); 85#if defined(__x86_64__) 86 Run(allocator, has_result, expected); 87#endif 88} 89 90TEST(CodegenTest, ReturnVoid) { 91 const uint16_t data[] = ZERO_REGISTER_CODE_ITEM(Instruction::RETURN_VOID); 92 TestCode(data); 93} 94 95TEST(CodegenTest, CFG1) { 96 const uint16_t data[] = ZERO_REGISTER_CODE_ITEM( 97 Instruction::GOTO | 0x100, 98 Instruction::RETURN_VOID); 99 100 TestCode(data); 101} 102 103TEST(CodegenTest, CFG2) { 104 const uint16_t data[] = ZERO_REGISTER_CODE_ITEM( 105 Instruction::GOTO | 0x100, 106 Instruction::GOTO | 0x100, 107 Instruction::RETURN_VOID); 108 109 TestCode(data); 110} 111 112TEST(CodegenTest, CFG3) { 113 const uint16_t data1[] = ZERO_REGISTER_CODE_ITEM( 114 Instruction::GOTO | 0x200, 115 Instruction::RETURN_VOID, 116 Instruction::GOTO | 0xFF00); 117 118 TestCode(data1); 119 120 const uint16_t data2[] = ZERO_REGISTER_CODE_ITEM( 121 Instruction::GOTO_16, 3, 122 Instruction::RETURN_VOID, 123 Instruction::GOTO_16, 0xFFFF); 124 125 TestCode(data2); 126 127 const uint16_t data3[] = ZERO_REGISTER_CODE_ITEM( 128 Instruction::GOTO_32, 4, 0, 129 Instruction::RETURN_VOID, 130 Instruction::GOTO_32, 0xFFFF, 0xFFFF); 131 132 TestCode(data3); 133} 134 135TEST(CodegenTest, CFG4) { 136 const uint16_t data[] = ZERO_REGISTER_CODE_ITEM( 137 Instruction::RETURN_VOID, 138 Instruction::GOTO | 0x100, 139 Instruction::GOTO | 0xFE00); 140 141 TestCode(data); 142} 143 144TEST(CodegenTest, CFG5) { 145 const uint16_t data[] = ONE_REGISTER_CODE_ITEM( 146 Instruction::CONST_4 | 0 | 0, 147 Instruction::IF_EQ, 3, 148 Instruction::GOTO | 0x100, 149 Instruction::RETURN_VOID); 150 151 TestCode(data); 152} 153 154TEST(CodegenTest, IntConstant) { 155 const uint16_t data[] = ONE_REGISTER_CODE_ITEM( 156 Instruction::CONST_4 | 0 | 0, 157 Instruction::RETURN_VOID); 158 159 TestCode(data); 160} 161 162TEST(CodegenTest, Return1) { 163 const uint16_t data[] = ONE_REGISTER_CODE_ITEM( 164 Instruction::CONST_4 | 0 | 0, 165 Instruction::RETURN | 0); 166 167 TestCode(data, true, 0); 168} 169 170TEST(CodegenTest, Return2) { 171 const uint16_t data[] = TWO_REGISTERS_CODE_ITEM( 172 Instruction::CONST_4 | 0 | 0, 173 Instruction::CONST_4 | 0 | 1 << 8, 174 Instruction::RETURN | 1 << 8); 175 176 TestCode(data, true, 0); 177} 178 179TEST(CodegenTest, Return3) { 180 const uint16_t data[] = TWO_REGISTERS_CODE_ITEM( 181 Instruction::CONST_4 | 0 | 0, 182 Instruction::CONST_4 | 1 << 8 | 1 << 12, 183 Instruction::RETURN | 1 << 8); 184 185 TestCode(data, true, 1); 186} 187 188TEST(CodegenTest, ReturnIf1) { 189 const uint16_t data[] = TWO_REGISTERS_CODE_ITEM( 190 Instruction::CONST_4 | 0 | 0, 191 Instruction::CONST_4 | 1 << 8 | 1 << 12, 192 Instruction::IF_EQ, 3, 193 Instruction::RETURN | 0 << 8, 194 Instruction::RETURN | 1 << 8); 195 196 TestCode(data, true, 1); 197} 198 199TEST(CodegenTest, ReturnIf2) { 200 const uint16_t data[] = TWO_REGISTERS_CODE_ITEM( 201 Instruction::CONST_4 | 0 | 0, 202 Instruction::CONST_4 | 1 << 8 | 1 << 12, 203 Instruction::IF_EQ | 0 << 4 | 1 << 8, 3, 204 Instruction::RETURN | 0 << 8, 205 Instruction::RETURN | 1 << 8); 206 207 TestCode(data, true, 0); 208} 209 210TEST(CodegenTest, ReturnAdd1) { 211 const uint16_t data[] = TWO_REGISTERS_CODE_ITEM( 212 Instruction::CONST_4 | 3 << 12 | 0, 213 Instruction::CONST_4 | 4 << 12 | 1 << 8, 214 Instruction::ADD_INT, 1 << 8 | 0, 215 Instruction::RETURN); 216 217 TestCode(data, true, 7); 218} 219 220TEST(CodegenTest, ReturnAdd2) { 221 const uint16_t data[] = TWO_REGISTERS_CODE_ITEM( 222 Instruction::CONST_4 | 3 << 12 | 0, 223 Instruction::CONST_4 | 4 << 12 | 1 << 8, 224 Instruction::ADD_INT_2ADDR | 1 << 12, 225 Instruction::RETURN); 226 227 TestCode(data, true, 7); 228} 229 230TEST(CodegenTest, ReturnAdd3) { 231 const uint16_t data[] = ONE_REGISTER_CODE_ITEM( 232 Instruction::CONST_4 | 4 << 12 | 0 << 8, 233 Instruction::ADD_INT_LIT8, 3 << 8 | 0, 234 Instruction::RETURN); 235 236 TestCode(data, true, 7); 237} 238 239TEST(CodegenTest, ReturnAdd4) { 240 const uint16_t data[] = ONE_REGISTER_CODE_ITEM( 241 Instruction::CONST_4 | 4 << 12 | 0 << 8, 242 Instruction::ADD_INT_LIT16, 3, 243 Instruction::RETURN); 244 245 TestCode(data, true, 7); 246} 247 248} // namespace art 249