| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef ART_COMPILER_UTILS_ASSEMBLER_TEST_H_ |
| #define ART_COMPILER_UTILS_ASSEMBLER_TEST_H_ |
| |
| #include "assembler.h" |
| |
| #include "common_runtime_test.h" // For ScratchFile |
| |
| #include <cstdio> |
| #include <cstdlib> |
| #include <fstream> |
| #include <iostream> |
| #include <iterator> |
| #include <sys/stat.h> |
| |
| namespace art { |
| |
| // Use a glocal static variable to keep the same name for all test data. Else we'll just spam the |
| // temp directory. |
| static std::string tmpnam_; |
| |
| template<typename Ass, typename Reg, typename Imm> |
| class AssemblerTest : public testing::Test { |
| public: |
| Ass* GetAssembler() { |
| return assembler_.get(); |
| } |
| |
| typedef std::string (*TestFn)(Ass* assembler); |
| |
| void DriverFn(TestFn f, std::string test_name) { |
| Driver(f(assembler_.get()), test_name); |
| } |
| |
| // This driver assumes the assembler has already been called. |
| void DriverStr(std::string assembly_string, std::string test_name) { |
| Driver(assembly_string, test_name); |
| } |
| |
| std::string RepeatR(void (Ass::*f)(Reg), std::string fmt) { |
| const std::vector<Reg*> registers = GetRegisters(); |
| std::string str; |
| for (auto reg : registers) { |
| (assembler_.get()->*f)(*reg); |
| std::string base = fmt; |
| |
| size_t reg_index = base.find("{reg}"); |
| if (reg_index != std::string::npos) { |
| std::ostringstream sreg; |
| sreg << *reg; |
| std::string reg_string = sreg.str(); |
| base.replace(reg_index, 5, reg_string); |
| } |
| |
| if (str.size() > 0) { |
| str += "\n"; |
| } |
| str += base; |
| } |
| // Add a newline at the end. |
| str += "\n"; |
| return str; |
| } |
| |
| std::string RepeatRR(void (Ass::*f)(Reg, Reg), std::string fmt) { |
| const std::vector<Reg*> registers = GetRegisters(); |
| std::string str; |
| for (auto reg1 : registers) { |
| for (auto reg2 : registers) { |
| (assembler_.get()->*f)(*reg1, *reg2); |
| std::string base = fmt; |
| |
| size_t reg1_index = base.find("{reg1}"); |
| if (reg1_index != std::string::npos) { |
| std::ostringstream sreg; |
| sreg << *reg1; |
| std::string reg_string = sreg.str(); |
| base.replace(reg1_index, 6, reg_string); |
| } |
| |
| size_t reg2_index = base.find("{reg2}"); |
| if (reg2_index != std::string::npos) { |
| std::ostringstream sreg; |
| sreg << *reg2; |
| std::string reg_string = sreg.str(); |
| base.replace(reg2_index, 6, reg_string); |
| } |
| |
| if (str.size() > 0) { |
| str += "\n"; |
| } |
| str += base; |
| } |
| } |
| // Add a newline at the end. |
| str += "\n"; |
| return str; |
| } |
| |
| std::string RepeatRI(void (Ass::*f)(Reg, const Imm&), size_t imm_bytes, std::string fmt) { |
| const std::vector<Reg*> registers = GetRegisters(); |
| std::string str; |
| std::vector<int64_t> imms = CreateImmediateValues(imm_bytes); |
| for (auto reg : registers) { |
| for (int64_t imm : imms) { |
| Imm* new_imm = CreateImmediate(imm); |
| (assembler_.get()->*f)(*reg, *new_imm); |
| delete new_imm; |
| std::string base = fmt; |
| |
| size_t reg_index = base.find("{reg}"); |
| if (reg_index != std::string::npos) { |
| std::ostringstream sreg; |
| sreg << *reg; |
| std::string reg_string = sreg.str(); |
| base.replace(reg_index, 5, reg_string); |
| } |
| |
| size_t imm_index = base.find("{imm}"); |
| if (imm_index != std::string::npos) { |
| std::ostringstream sreg; |
| sreg << imm; |
| std::string imm_string = sreg.str(); |
| base.replace(imm_index, 5, imm_string); |
| } |
| |
| if (str.size() > 0) { |
| str += "\n"; |
| } |
| str += base; |
| } |
| } |
| // Add a newline at the end. |
| str += "\n"; |
| return str; |
| } |
| |
| std::string RepeatI(void (Ass::*f)(const Imm&), size_t imm_bytes, std::string fmt) { |
| std::string str; |
| std::vector<int64_t> imms = CreateImmediateValues(imm_bytes); |
| for (int64_t imm : imms) { |
| Imm* new_imm = CreateImmediate(imm); |
| (assembler_.get()->*f)(*new_imm); |
| delete new_imm; |
| std::string base = fmt; |
| |
| size_t imm_index = base.find("{imm}"); |
| if (imm_index != std::string::npos) { |
| std::ostringstream sreg; |
| sreg << imm; |
| std::string imm_string = sreg.str(); |
| base.replace(imm_index, 5, imm_string); |
| } |
| |
| if (str.size() > 0) { |
| str += "\n"; |
| } |
| str += base; |
| } |
| // Add a newline at the end. |
| str += "\n"; |
| return str; |
| } |
| |
| // This is intended to be run as a test. |
| bool CheckTools() { |
| if (!FileExists(GetAssemblerCommand())) { |
| return false; |
| } |
| LOG(INFO) << "Chosen assembler command: " << GetAssemblerCommand(); |
| |
| if (!FileExists(GetObjdumpCommand())) { |
| return false; |
| } |
| LOG(INFO) << "Chosen objdump command: " << GetObjdumpCommand(); |
| |
| // Disassembly is optional. |
| std::string disassembler = GetDisassembleCommand(); |
| if (disassembler.length() != 0) { |
| if (!FileExists(disassembler)) { |
| return false; |
| } |
| LOG(INFO) << "Chosen disassemble command: " << GetDisassembleCommand(); |
| } else { |
| LOG(INFO) << "No disassembler given."; |
| } |
| |
| return true; |
| } |
| |
| protected: |
| void SetUp() OVERRIDE { |
| assembler_.reset(new Ass()); |
| |
| // Fake a runtime test for ScratchFile |
| std::string android_data; |
| CommonRuntimeTest::SetEnvironmentVariables(android_data); |
| |
| SetUpHelpers(); |
| } |
| |
| // Override this to set up any architecture-specific things, e.g., register vectors. |
| virtual void SetUpHelpers() {} |
| |
| virtual std::vector<Reg*> GetRegisters() = 0; |
| |
| // Get the typically used name for this architecture, e.g., aarch64, x86_64, ... |
| virtual std::string GetArchitectureString() = 0; |
| |
| // Get the name of the assembler, e.g., "as" by default. |
| virtual std::string GetAssemblerCmdName() { |
| return "as"; |
| } |
| |
| // Switches to the assembler command. Default none. |
| virtual std::string GetAssemblerParameters() { |
| return ""; |
| } |
| |
| // Return the host assembler command for this test. |
| virtual std::string GetAssemblerCommand() { |
| // Already resolved it once? |
| if (resolved_assembler_cmd_.length() != 0) { |
| return resolved_assembler_cmd_; |
| } |
| |
| std::string line = FindTool(GetAssemblerCmdName()); |
| if (line.length() == 0) { |
| return line; |
| } |
| |
| resolved_assembler_cmd_ = line + GetAssemblerParameters(); |
| |
| return line; |
| } |
| |
| // Get the name of the objdump, e.g., "objdump" by default. |
| virtual std::string GetObjdumpCmdName() { |
| return "objdump"; |
| } |
| |
| // Switches to the objdump command. Default is " -h". |
| virtual std::string GetObjdumpParameters() { |
| return " -h"; |
| } |
| |
| // Return the host objdump command for this test. |
| virtual std::string GetObjdumpCommand() { |
| // Already resolved it once? |
| if (resolved_objdump_cmd_.length() != 0) { |
| return resolved_objdump_cmd_; |
| } |
| |
| std::string line = FindTool(GetObjdumpCmdName()); |
| if (line.length() == 0) { |
| return line; |
| } |
| |
| resolved_objdump_cmd_ = line + GetObjdumpParameters(); |
| |
| return line; |
| } |
| |
| // Get the name of the objdump, e.g., "objdump" by default. |
| virtual std::string GetDisassembleCmdName() { |
| return "objdump"; |
| } |
| |
| // Switches to the objdump command. As it's a binary, one needs to push the architecture and |
| // such to objdump, so it's architecture-specific and there is no default. |
| virtual std::string GetDisassembleParameters() = 0; |
| |
| // Return the host disassembler command for this test. |
| virtual std::string GetDisassembleCommand() { |
| // Already resolved it once? |
| if (resolved_disassemble_cmd_.length() != 0) { |
| return resolved_disassemble_cmd_; |
| } |
| |
| std::string line = FindTool(GetDisassembleCmdName()); |
| if (line.length() == 0) { |
| return line; |
| } |
| |
| resolved_disassemble_cmd_ = line + GetDisassembleParameters(); |
| |
| return line; |
| } |
| |
| // Create a couple of immediate values up to the number of bytes given. |
| virtual std::vector<int64_t> CreateImmediateValues(size_t imm_bytes) { |
| std::vector<int64_t> res; |
| res.push_back(0); |
| res.push_back(-1); |
| res.push_back(0x12); |
| if (imm_bytes >= 2) { |
| res.push_back(0x1234); |
| res.push_back(-0x1234); |
| if (imm_bytes >= 4) { |
| res.push_back(0x12345678); |
| res.push_back(-0x12345678); |
| if (imm_bytes >= 6) { |
| res.push_back(0x123456789ABC); |
| res.push_back(-0x123456789ABC); |
| if (imm_bytes >= 8) { |
| res.push_back(0x123456789ABCDEF0); |
| res.push_back(-0x123456789ABCDEF0); |
| } |
| } |
| } |
| } |
| return res; |
| } |
| |
| // Create an immediate from the specific value. |
| virtual Imm* CreateImmediate(int64_t imm_value) = 0; |
| |
| private: |
| // Driver() assembles and compares the results. If the results are not equal and we have a |
| // disassembler, disassemble both and check whether they have the same mnemonics (in which case |
| // we just warn). |
| void Driver(std::string assembly_text, std::string test_name) { |
| EXPECT_NE(assembly_text.length(), 0U) << "Empty assembly"; |
| |
| NativeAssemblerResult res; |
| Compile(assembly_text, &res, test_name); |
| |
| EXPECT_TRUE(res.ok) << res.error_msg; |
| if (!res.ok) { |
| // No way of continuing. |
| return; |
| } |
| |
| size_t cs = assembler_->CodeSize(); |
| UniquePtr<std::vector<uint8_t> > data(new std::vector<uint8_t>(cs)); |
| MemoryRegion code(&(*data)[0], data->size()); |
| assembler_->FinalizeInstructions(code); |
| |
| if (*data == *res.code) { |
| Clean(&res); |
| } else { |
| if (DisassembleBinaries(*data, *res.code, test_name)) { |
| if (data->size() > res.code->size()) { |
| LOG(WARNING) << "Assembly code is not identical, but disassembly of machine code is " |
| "equal: this implies sub-optimal encoding! Our code size=" << data->size() << |
| ", gcc size=" << res.code->size(); |
| } else { |
| LOG(INFO) << "GCC chose a different encoding than ours, but the overall length is the " |
| "same."; |
| } |
| } else { |
| // This will output the assembly. |
| EXPECT_EQ(*data, *res.code) << "Outputs (and disassembly) not identical."; |
| } |
| } |
| } |
| |
| // Structure to store intermediates and results. |
| struct NativeAssemblerResult { |
| bool ok; |
| std::string error_msg; |
| std::string base_name; |
| UniquePtr<std::vector<uint8_t>> code; |
| uintptr_t length; |
| }; |
| |
| // Compile the assembly file from_file to a binary file to_file. Returns true on success. |
| bool Assemble(const char* from_file, const char* to_file, std::string* error_msg) { |
| bool have_assembler = FileExists(GetAssemblerCommand()); |
| EXPECT_TRUE(have_assembler) << "Cannot find assembler:" << GetAssemblerCommand(); |
| if (!have_assembler) { |
| return false; |
| } |
| |
| std::vector<std::string> args; |
| |
| args.push_back(GetAssemblerCommand()); |
| args.push_back("-o"); |
| args.push_back(to_file); |
| args.push_back(from_file); |
| |
| return Exec(args, error_msg); |
| } |
| |
| // Runs objdump -h on the binary file and extracts the first line with .text. |
| // Returns "" on failure. |
| std::string Objdump(std::string file) { |
| bool have_objdump = FileExists(GetObjdumpCommand()); |
| EXPECT_TRUE(have_objdump) << "Cannot find objdump: " << GetObjdumpCommand(); |
| if (!have_objdump) { |
| return ""; |
| } |
| |
| std::string error_msg; |
| std::vector<std::string> args; |
| |
| args.push_back(GetObjdumpCommand()); |
| args.push_back(file); |
| args.push_back(">"); |
| args.push_back(file+".dump"); |
| std::string cmd = Join(args, ' '); |
| |
| args.clear(); |
| args.push_back("/bin/sh"); |
| args.push_back("-c"); |
| args.push_back(cmd); |
| |
| if (!Exec(args, &error_msg)) { |
| EXPECT_TRUE(false) << error_msg; |
| } |
| |
| std::ifstream dump(file+".dump"); |
| |
| std::string line; |
| bool found = false; |
| while (std::getline(dump, line)) { |
| if (line.find(".text") != line.npos) { |
| found = true; |
| break; |
| } |
| } |
| |
| dump.close(); |
| |
| if (found) { |
| return line; |
| } else { |
| return ""; |
| } |
| } |
| |
| // Disassemble both binaries and compare the text. |
| bool DisassembleBinaries(std::vector<uint8_t>& data, std::vector<uint8_t>& as, |
| std::string test_name) { |
| std::string disassembler = GetDisassembleCommand(); |
| if (disassembler.length() == 0) { |
| LOG(WARNING) << "No dissassembler command."; |
| return false; |
| } |
| |
| std::string data_name = WriteToFile(data, test_name + ".ass"); |
| std::string error_msg; |
| if (!DisassembleBinary(data_name, &error_msg)) { |
| LOG(INFO) << "Error disassembling: " << error_msg; |
| std::remove(data_name.c_str()); |
| return false; |
| } |
| |
| std::string as_name = WriteToFile(as, test_name + ".gcc"); |
| if (!DisassembleBinary(as_name, &error_msg)) { |
| LOG(INFO) << "Error disassembling: " << error_msg; |
| std::remove(data_name.c_str()); |
| std::remove((data_name + ".dis").c_str()); |
| std::remove(as_name.c_str()); |
| return false; |
| } |
| |
| bool result = CompareFiles(data_name + ".dis", as_name + ".dis"); |
| |
| if (result) { |
| std::remove(data_name.c_str()); |
| std::remove(as_name.c_str()); |
| std::remove((data_name + ".dis").c_str()); |
| std::remove((as_name + ".dis").c_str()); |
| } |
| |
| return result; |
| } |
| |
| bool DisassembleBinary(std::string file, std::string* error_msg) { |
| std::vector<std::string> args; |
| |
| args.push_back(GetDisassembleCommand()); |
| args.push_back(file); |
| args.push_back("| sed -n \'/<.data>/,$p\' | sed -e \'s/.*://\'"); |
| args.push_back(">"); |
| args.push_back(file+".dis"); |
| std::string cmd = Join(args, ' '); |
| |
| args.clear(); |
| args.push_back("/bin/sh"); |
| args.push_back("-c"); |
| args.push_back(cmd); |
| |
| return Exec(args, error_msg); |
| } |
| |
| std::string WriteToFile(std::vector<uint8_t>& buffer, std::string test_name) { |
| std::string file_name = GetTmpnam() + std::string("---") + test_name; |
| const char* data = reinterpret_cast<char*>(buffer.data()); |
| std::ofstream s_out(file_name + ".o"); |
| s_out.write(data, buffer.size()); |
| s_out.close(); |
| return file_name + ".o"; |
| } |
| |
| bool CompareFiles(std::string f1, std::string f2) { |
| std::ifstream f1_in(f1); |
| std::ifstream f2_in(f2); |
| |
| bool result = std::equal(std::istreambuf_iterator<char>(f1_in), |
| std::istreambuf_iterator<char>(), |
| std::istreambuf_iterator<char>(f2_in)); |
| |
| f1_in.close(); |
| f2_in.close(); |
| |
| return result; |
| } |
| |
| // Compile the given assembly code and extract the binary, if possible. Put result into res. |
| bool Compile(std::string assembly_code, NativeAssemblerResult* res, std::string test_name) { |
| res->ok = false; |
| res->code.reset(nullptr); |
| |
| res->base_name = GetTmpnam() + std::string("---") + test_name; |
| |
| // TODO: Lots of error checking. |
| |
| std::ofstream s_out(res->base_name + ".S"); |
| s_out << assembly_code; |
| s_out.close(); |
| |
| if (!Assemble((res->base_name + ".S").c_str(), (res->base_name + ".o").c_str(), |
| &res->error_msg)) { |
| res->error_msg = "Could not compile."; |
| return false; |
| } |
| |
| std::string odump = Objdump(res->base_name + ".o"); |
| if (odump.length() == 0) { |
| res->error_msg = "Objdump failed."; |
| return false; |
| } |
| |
| std::istringstream iss(odump); |
| std::istream_iterator<std::string> start(iss); |
| std::istream_iterator<std::string> end; |
| std::vector<std::string> tokens(start, end); |
| |
| if (tokens.size() < OBJDUMP_SECTION_LINE_MIN_TOKENS) { |
| res->error_msg = "Objdump output not recognized: too few tokens."; |
| return false; |
| } |
| |
| if (tokens[1] != ".text") { |
| res->error_msg = "Objdump output not recognized: .text not second token."; |
| return false; |
| } |
| |
| std::string lengthToken = "0x" + tokens[2]; |
| std::istringstream(lengthToken) >> std::hex >> res->length; |
| |
| std::string offsetToken = "0x" + tokens[5]; |
| uintptr_t offset; |
| std::istringstream(offsetToken) >> std::hex >> offset; |
| |
| std::ifstream obj(res->base_name + ".o"); |
| obj.seekg(offset); |
| res->code.reset(new std::vector<uint8_t>(res->length)); |
| obj.read(reinterpret_cast<char*>(&(*res->code)[0]), res->length); |
| obj.close(); |
| |
| res->ok = true; |
| return true; |
| } |
| |
| // Remove temporary files. |
| void Clean(const NativeAssemblerResult* res) { |
| std::remove((res->base_name + ".S").c_str()); |
| std::remove((res->base_name + ".o").c_str()); |
| std::remove((res->base_name + ".o.dump").c_str()); |
| } |
| |
| // Check whether file exists. Is used for commands, so strips off any parameters: anything after |
| // the first space. We skip to the last slash for this, so it should work with directories with |
| // spaces. |
| static bool FileExists(std::string file) { |
| if (file.length() == 0) { |
| return false; |
| } |
| |
| // Need to strip any options. |
| size_t last_slash = file.find_last_of('/'); |
| if (last_slash == std::string::npos) { |
| // No slash, start looking at the start. |
| last_slash = 0; |
| } |
| size_t space_index = file.find(' ', last_slash); |
| |
| if (space_index == std::string::npos) { |
| std::ifstream infile(file.c_str()); |
| return infile.good(); |
| } else { |
| std::string copy = file.substr(0, space_index - 1); |
| |
| struct stat buf; |
| return stat(copy.c_str(), &buf) == 0; |
| } |
| } |
| |
| static std::string GetGCCRootPath() { |
| return "prebuilts/gcc/linux-x86"; |
| } |
| |
| static std::string GetRootPath() { |
| // 1) Check ANDROID_BUILD_TOP |
| char* build_top = getenv("ANDROID_BUILD_TOP"); |
| if (build_top != nullptr) { |
| return std::string(build_top) + "/"; |
| } |
| |
| // 2) Do cwd |
| char temp[1024]; |
| return getcwd(temp, 1024) ? std::string(temp) + "/" : std::string(""); |
| } |
| |
| std::string FindTool(std::string tool_name) { |
| // Find the current tool. Wild-card pattern is "arch-string*tool-name". |
| std::string gcc_path = GetRootPath() + GetGCCRootPath(); |
| std::vector<std::string> args; |
| args.push_back("find"); |
| args.push_back(gcc_path); |
| args.push_back("-name"); |
| args.push_back(GetArchitectureString() + "*" + tool_name); |
| args.push_back("|"); |
| args.push_back("sort"); |
| args.push_back("|"); |
| args.push_back("tail"); |
| args.push_back("-n"); |
| args.push_back("1"); |
| std::string tmp_file = GetTmpnam(); |
| args.push_back(">"); |
| args.push_back(tmp_file); |
| std::string sh_args = Join(args, ' '); |
| |
| args.clear(); |
| args.push_back("/bin/sh"); |
| args.push_back("-c"); |
| args.push_back(sh_args); |
| |
| std::string error_msg; |
| if (!Exec(args, &error_msg)) { |
| EXPECT_TRUE(false) << error_msg; |
| return ""; |
| } |
| |
| std::ifstream in(tmp_file.c_str()); |
| std::string line; |
| if (!std::getline(in, line)) { |
| in.close(); |
| std::remove(tmp_file.c_str()); |
| return ""; |
| } |
| in.close(); |
| std::remove(tmp_file.c_str()); |
| return line; |
| } |
| |
| // Use a consistent tmpnam, so store it. |
| std::string GetTmpnam() { |
| if (tmpnam_.length() == 0) { |
| ScratchFile tmp; |
| tmpnam_ = tmp.GetFilename() + "asm"; |
| } |
| return tmpnam_; |
| } |
| |
| UniquePtr<Ass> assembler_; |
| |
| std::string resolved_assembler_cmd_; |
| std::string resolved_objdump_cmd_; |
| std::string resolved_disassemble_cmd_; |
| |
| static constexpr size_t OBJDUMP_SECTION_LINE_MIN_TOKENS = 6; |
| }; |
| |
| } // namespace art |
| |
| #endif // ART_COMPILER_UTILS_ASSEMBLER_TEST_H_ |