/*
* Copyright (C) 2018 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.
*/
#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <unwindstack/DwarfLocation.h>
#include <unwindstack/DwarfMemory.h>
#include <unwindstack/DwarfSection.h>
#include <unwindstack/DwarfStructs.h>
#include <unwindstack/Elf.h>
#include <unwindstack/ElfInterface.h>
#include <unwindstack/Log.h>
#include "DwarfOp.h"
namespace unwindstack {
void PrintSignedValue(int64_t value) {
if (value < 0) {
printf("- %" PRId64, -value);
} else if (value > 0) {
printf("+ %" PRId64, value);
}
}
void PrintExpression(Memory* memory, uint8_t class_type, uint64_t end, uint64_t length) {
std::vector<std::string> lines;
DwarfMemory dwarf_memory(memory);
if (class_type == ELFCLASS32) {
DwarfOp<uint32_t> op(&dwarf_memory, nullptr);
op.GetLogInfo(end - length, end, &lines);
} else {
DwarfOp<uint64_t> op(&dwarf_memory, nullptr);
op.GetLogInfo(end - length, end, &lines);
}
for (auto& line : lines) {
printf(" %s\n", line.c_str());
}
}
void PrintRegInformation(DwarfSection* section, Memory* memory, uint64_t pc, uint8_t class_type) {
const DwarfFde* fde = section->GetFdeFromPc(pc);
if (fde == nullptr) {
printf(" No fde found.\n");
return;
}
dwarf_loc_regs_t regs;
if (!section->GetCfaLocationInfo(pc, fde, ®s)) {
printf(" Cannot get location information.\n");
return;
}
std::vector<std::pair<uint32_t, DwarfLocation>> loc_regs;
for (auto& loc : regs) {
loc_regs.push_back(loc);
}
std::sort(loc_regs.begin(), loc_regs.end(), [](auto a, auto b) {
if (a.first == CFA_REG) {
return true;
} else if (b.first == CFA_REG) {
return false;
}
return a.first < b.first;
});
for (auto& entry : loc_regs) {
const DwarfLocation* loc = &entry.second;
if (entry.first == CFA_REG) {
printf(" cfa = ");
} else {
printf(" r%d = ", entry.first);
}
switch (loc->type) {
case DWARF_LOCATION_OFFSET:
printf("[cfa ");
PrintSignedValue(loc->values[0]);
printf("]\n");
break;
case DWARF_LOCATION_VAL_OFFSET:
printf("cfa ");
PrintSignedValue(loc->values[0]);
printf("\n");
break;
case DWARF_LOCATION_REGISTER:
printf("r%" PRId64 " ", loc->values[0]);
PrintSignedValue(loc->values[1]);
printf("\n");
break;
case DWARF_LOCATION_EXPRESSION: {
printf("EXPRESSION\n");
PrintExpression(memory, class_type, loc->values[1], loc->values[0]);
break;
}
case DWARF_LOCATION_VAL_EXPRESSION: {
printf("VAL EXPRESSION\n");
PrintExpression(memory, class_type, loc->values[1], loc->values[0]);
break;
}
case DWARF_LOCATION_UNDEFINED:
printf("undefine\n");
break;
case DWARF_LOCATION_INVALID:
printf("INVALID\n");
break;
}
}
}
int GetInfo(const char* file, uint64_t pc) {
MemoryFileAtOffset* memory = new MemoryFileAtOffset;
if (!memory->Init(file, 0)) {
// Initializatation failed.
printf("Failed to init\n");
return 1;
}
Elf elf(memory);
if (!elf.Init(true) || !elf.valid()) {
printf("%s is not a valid elf file.\n", file);
return 1;
}
ElfInterface* interface = elf.interface();
uint64_t load_bias = elf.GetLoadBias();
if (pc < load_bias) {
printf("PC is less than load bias.\n");
return 1;
}
std::string soname;
if (elf.GetSoname(&soname)) {
printf("Soname: %s\n\n", soname.c_str());
}
printf("PC 0x%" PRIx64 ":\n", pc);
DwarfSection* section = interface->eh_frame();
if (section != nullptr) {
printf("\neh_frame:\n");
PrintRegInformation(section, memory, pc - load_bias, elf.class_type());
} else {
printf("\nno eh_frame information\n");
}
section = interface->debug_frame();
if (section != nullptr) {
printf("\ndebug_frame:\n");
PrintRegInformation(section, memory, pc - load_bias, elf.class_type());
printf("\n");
} else {
printf("\nno debug_frame information\n");
}
// If there is a gnu_debugdata interface, dump the information for that.
ElfInterface* gnu_debugdata_interface = elf.gnu_debugdata_interface();
if (gnu_debugdata_interface != nullptr) {
section = gnu_debugdata_interface->eh_frame();
if (section != nullptr) {
printf("\ngnu_debugdata (eh_frame):\n");
PrintRegInformation(section, gnu_debugdata_interface->memory(), pc, elf.class_type());
printf("\n");
} else {
printf("\nno gnu_debugdata (eh_frame)\n");
}
section = gnu_debugdata_interface->debug_frame();
if (section != nullptr) {
printf("\ngnu_debugdata (debug_frame):\n");
PrintRegInformation(section, gnu_debugdata_interface->memory(), pc, elf.class_type());
printf("\n");
} else {
printf("\nno gnu_debugdata (debug_frame)\n");
}
} else {
printf("\nno valid gnu_debugdata information\n");
}
return 0;
}
} // namespace unwindstack
int main(int argc, char** argv) {
if (argc != 3) {
printf("Usage: unwind_reg_info ELF_FILE PC\n");
printf(" ELF_FILE\n");
printf(" The path to an elf file.\n");
printf(" PC\n");
printf(" The pc for which the register information should be obtained.\n");
return 1;
}
struct stat st;
if (stat(argv[1], &st) == -1) {
printf("Cannot stat %s: %s\n", argv[1], strerror(errno));
return 1;
}
if (!S_ISREG(st.st_mode)) {
printf("%s is not a regular file.\n", argv[1]);
return 1;
}
uint64_t pc = 0;
char* end;
pc = strtoull(argv[2], &end, 16);
if (*end != '\0') {
printf("Malformed OFFSET value: %s\n", argv[2]);
return 1;
}
return unwindstack::GetInfo(argv[1], pc);
}