Home | History | Annotate | Download | only in compiler
      1 /*
      2  * Copyright (C) 2015 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 #ifndef ART_COMPILER_CFI_TEST_H_
     18 #define ART_COMPILER_CFI_TEST_H_
     19 
     20 #include <vector>
     21 #include <memory>
     22 #include <sstream>
     23 
     24 #include "arch/instruction_set.h"
     25 #include "base/enums.h"
     26 #include "debug/dwarf/dwarf_constants.h"
     27 #include "debug/dwarf/dwarf_test.h"
     28 #include "debug/dwarf/headers.h"
     29 #include "disassembler/disassembler.h"
     30 #include "gtest/gtest.h"
     31 #include "thread.h"
     32 
     33 namespace art {
     34 
     35 constexpr dwarf::CFIFormat kCFIFormat = dwarf::DW_DEBUG_FRAME_FORMAT;
     36 
     37 class CFITest : public dwarf::DwarfTest {
     38  public:
     39   void GenerateExpected(FILE* f, InstructionSet isa, const char* isa_str,
     40                         const std::vector<uint8_t>& actual_asm,
     41                         const std::vector<uint8_t>& actual_cfi) {
     42     std::vector<std::string> lines;
     43     // Print the raw bytes.
     44     fprintf(f, "static constexpr uint8_t expected_asm_%s[] = {", isa_str);
     45     HexDump(f, actual_asm);
     46     fprintf(f, "\n};\n");
     47     fprintf(f, "static constexpr uint8_t expected_cfi_%s[] = {", isa_str);
     48     HexDump(f, actual_cfi);
     49     fprintf(f, "\n};\n");
     50     // Pretty-print CFI opcodes.
     51     constexpr bool is64bit = false;
     52     dwarf::DebugFrameOpCodeWriter<> initial_opcodes;
     53     dwarf::WriteCIE(is64bit, dwarf::Reg(8),
     54                     initial_opcodes, kCFIFormat, &debug_frame_data_);
     55     std::vector<uintptr_t> debug_frame_patches;
     56     dwarf::WriteFDE(is64bit, 0, 0, 0, actual_asm.size(), ArrayRef<const uint8_t>(actual_cfi),
     57                     kCFIFormat, 0, &debug_frame_data_, &debug_frame_patches);
     58     ReformatCfi(Objdump(false, "-W"), &lines);
     59     // Pretty-print assembly.
     60     const uint8_t* asm_base = actual_asm.data();
     61     const uint8_t* asm_end = asm_base + actual_asm.size();
     62     auto* opts = new DisassemblerOptions(false,
     63                                          asm_base,
     64                                          asm_end,
     65                                          true,
     66                                          is64bit
     67                                              ? &Thread::DumpThreadOffset<PointerSize::k64>
     68                                              : &Thread::DumpThreadOffset<PointerSize::k32>);
     69     std::unique_ptr<Disassembler> disasm(Disassembler::Create(isa, opts));
     70     std::stringstream stream;
     71     const uint8_t* base = actual_asm.data() + (isa == kThumb2 ? 1 : 0);
     72     disasm->Dump(stream, base, base + actual_asm.size());
     73     ReformatAsm(&stream, &lines);
     74     // Print CFI and assembly interleaved.
     75     std::stable_sort(lines.begin(), lines.end(), CompareByAddress);
     76     for (const std::string& line : lines) {
     77       fprintf(f, "// %s\n", line.c_str());
     78     }
     79     fprintf(f, "\n");
     80   }
     81 
     82  private:
     83   // Helper - get offset just past the end of given string.
     84   static size_t FindEndOf(const std::string& str, const char* substr) {
     85     size_t pos = str.find(substr);
     86     CHECK_NE(std::string::npos, pos);
     87     return pos + strlen(substr);
     88   }
     89 
     90   // Spit to lines and remove raw instruction bytes.
     91   static void ReformatAsm(std::stringstream* stream,
     92                           std::vector<std::string>* output) {
     93     std::string line;
     94     while (std::getline(*stream, line)) {
     95       line = line.substr(0, FindEndOf(line, ": ")) +
     96              line.substr(FindEndOf(line, "\t"));
     97       size_t pos;
     98       while ((pos = line.find("  ")) != std::string::npos) {
     99         line = line.replace(pos, 2, " ");
    100       }
    101       while (!line.empty() && line.back() == ' ') {
    102         line.pop_back();
    103       }
    104       output->push_back(line);
    105     }
    106   }
    107 
    108   // Find interesting parts of objdump output and prefix the lines with address.
    109   static void ReformatCfi(const std::vector<std::string>& lines,
    110                           std::vector<std::string>* output) {
    111     std::string address;
    112     for (const std::string& line : lines) {
    113       if (line.find("DW_CFA_nop") != std::string::npos) {
    114         // Ignore.
    115       } else if (line.find("DW_CFA_advance_loc") != std::string::npos) {
    116         // The last 8 characters are the address.
    117         address = "0x" + line.substr(line.size() - 8);
    118       } else if (line.find("DW_CFA_") != std::string::npos) {
    119         std::string new_line(line);
    120         // "bad register" warning is caused by always using host (x86) objdump.
    121         const char* bad_reg = "bad register: ";
    122         size_t pos;
    123         if ((pos = new_line.find(bad_reg)) != std::string::npos) {
    124           new_line = new_line.replace(pos, strlen(bad_reg), "");
    125         }
    126         // Remove register names in parentheses since they have x86 names.
    127         if ((pos = new_line.find(" (")) != std::string::npos) {
    128           new_line = new_line.replace(pos, FindEndOf(new_line, ")") - pos, "");
    129         }
    130         // Use the .cfi_ prefix.
    131         new_line = ".cfi_" + new_line.substr(FindEndOf(new_line, "DW_CFA_"));
    132         output->push_back(address + ": " + new_line);
    133       }
    134     }
    135   }
    136 
    137   // Compare strings by the address prefix.
    138   static bool CompareByAddress(const std::string& lhs, const std::string& rhs) {
    139     EXPECT_EQ(lhs[10], ':');
    140     EXPECT_EQ(rhs[10], ':');
    141     return strncmp(lhs.c_str(), rhs.c_str(), 10) < 0;
    142   }
    143 
    144   // Pretty-print byte array.  12 bytes per line.
    145   static void HexDump(FILE* f, const std::vector<uint8_t>& data) {
    146     for (size_t i = 0; i < data.size(); i++) {
    147       fprintf(f, i % 12 == 0 ? "\n    " : " ");  // Whitespace.
    148       fprintf(f, "0x%02X,", data[i]);
    149     }
    150   }
    151 };
    152 
    153 }  // namespace art
    154 
    155 #endif  // ART_COMPILER_CFI_TEST_H_
    156