spv_result_t spvBinaryToText(const spv_const_context context, const uint32_t* code, const size_t wordCount, const uint32_t options, spv_text* pText, spv_diagnostic* pDiagnostic) { // Invalid arguments return error codes, but don't necessarily generate // diagnostics. These are programmer errors, not user errors. if (!pDiagnostic) return SPV_ERROR_INVALID_DIAGNOSTIC; const libspirv::AssemblyGrammar grammar(context); if (!grammar.isValid()) return SPV_ERROR_INVALID_TABLE; // Generate friendly names for Ids if requested. std::unique_ptr<libspirv::FriendlyNameMapper> friendly_mapper; libspirv::NameMapper name_mapper = libspirv::GetTrivialNameMapper(); if (options & SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES) { friendly_mapper.reset( new libspirv::FriendlyNameMapper(context, code, wordCount)); name_mapper = friendly_mapper->GetNameMapper(); } // Now disassemble! Disassembler disassembler(grammar, options, name_mapper); if (auto error = spvBinaryParse(context, &disassembler, code, wordCount, DisassembleHeader, DisassembleInstruction, pDiagnostic)) { return error; } return disassembler.SaveTextResult(pText); }
int main(){ stack_t stack; struct inf textin;//аша считываемая информация int stack_a[maxsize]; int i, k; FILE *mf, *getin, *disa; stack.size = 0; for (i = 0; i < maxsize; i++) stack_a[i] = 0; i = 0; mf = File1_ctor(mf); getin = File2_ctor(getin); disa = File3_ctor(disa); assembler(getin,stack_a, &stack,&textin); disassembler(disa, stack_a); while ((stack_a[i-1] !=0) && (stack_a[i] != 0)){ printf("%d ", stack_a[i]); i++; } dump(&stack, mf); File_dtor(disa); File_dtor(getin); File_dtor(mf); return 0; }
void Disassembler::Disassemble(InputStream &cboStream, OutputStream &outputStream) { const auto pos = cboStream.GetPosition(); CboValidator validator; CboValidator::Result result = validator.Validate(cboStream); cboStream.SetPosition(pos); DisassemblerCore disassembler(result, mAllocator, cboStream, outputStream); disassembler.Disassemble(); }
/* Initialize disassembler (libopcodes/libbfd) for given file. * * If the the function returns data with data.bfd_file = NULL, * then the function failed. */ static struct disasm_data disasm_init(const char *filename) { asection *section; struct disasm_data data; static bool initialized = false; if (!initialized) { bfd_init(); initialized = true; } data.bfd_file = bfd_openr(filename, NULL); if (data.bfd_file == NULL) { VERB1 log_bfd_error("bfd_openr", filename); return data; } if (!bfd_check_format(data.bfd_file, bfd_object)) { VERB1 log_bfd_error("bfd_check_format", filename); goto ret_fail; } section = bfd_get_section_by_name(data.bfd_file, ".text"); if (section == NULL) { VERB1 log_bfd_error("bfd_get_section_by_name", filename); goto ret_fail; } data.disassemble = disassembler(data.bfd_file); if (data.disassemble == NULL) { VERB1 log("Unable to find disassembler"); goto ret_fail; } init_disassemble_info(&data.info, NULL, buffer_printf); data.info.arch = bfd_get_arch(data.bfd_file); data.info.mach = bfd_get_mach(data.bfd_file); data.info.buffer_vma = section->vma; data.info.buffer_length = section->size; data.info.section = section; /*TODO: memory error func*/ bfd_malloc_and_get_section(data.bfd_file, section, &data.info.buffer); disassemble_init_for_target(&data.info); return data; ret_fail: bfd_close(data.bfd_file); data.bfd_file = NULL; return data; }
int get_instr_length(asm_program_t *prog, bfd_vma addr) { disassembler_ftype disas = disassembler(prog->abfd); fprintf_ftype old_fprintf_func = prog->disasm_info.fprintf_func; prog->disasm_info.fprintf_func = (fprintf_ftype)ignore; assert(disas); int len = disas(addr, &prog->disasm_info); prog->disasm_info.fprintf_func = old_fprintf_func; return len; }
int get_instr_length(bincode_t *bin, bfd_vma addr) { disassembler_ftype disas = disassembler(bin->abfd); fprintf_ftype old_fprintf_func = bin->disasm_info.fprintf_func; bin->disasm_info.fprintf_func = (fprintf_ftype)ignore; assert(disas); int len = disas(addr, &bin->disasm_info); bin->disasm_info.fprintf_func = old_fprintf_func; return len; }
void print_insn (ARMword instr) { int size; disassembler_ftype disassemble_fn; opbuf[0] = 0; info.application_data = & instr; disassemble_fn = disassembler (bfd_arch_arm, 0, 0, NULL); size = disassemble_fn (0, & info); fprintf (stderr, " %*s\n", size, opbuf); }
int get_instr_length( bhp _p, long long addr ) { int len; bh* p = (bh*) _p; struct disassemble_info* di = p->disasp; disassembler_ftype disas = disassembler( p->bfdp ); fprintf_ftype old_fprintf_func = di->fprintf_func; di->fprintf_func = (fprintf_ftype) ignore; len = disas( addr, di ); di->fprintf_func = old_fprintf_func; return len; }
void print_disasm_rawbytes(enum bfd_architecture arch, bfd_vma addr, const char *buf, int size) { asm_program_t *prog = byte_insn_to_asmp(arch, addr, (unsigned char*)buf, size); if (!prog) return; disassembler_ftype disas = disassembler(prog->abfd); disas(addr, &prog->disasm_info); free_asm_program(prog); fflush(stdout); }
void Disassemble(const char *cboFileName) { try { Bond::StdioInputStream cboStream(cboFileName); Bond::DefaultAllocator allocator; Bond::StdOutOutputStream outputStream; Bond::Disassembler disassembler(allocator); disassembler.Disassemble(cboStream, outputStream); } catch (const Bond::Exception &e) { fprintf(stderr, "%s\n", e.GetMessage()); } }
void arch_bfdDisasm(pid_t pid, uint8_t * mem, size_t size, char *instr) { while (pthread_mutex_lock(&arch_bfd_mutex)) ; bfd_init(); char fname[PATH_MAX]; snprintf(fname, sizeof(fname), "/proc/%d/exe", pid); bfd *bfdh = bfd_openr(fname, NULL); if (bfdh == NULL) { LOGMSG(l_WARN, "bfd_openr('/proc/%d/exe') failed", pid); goto out; } if (!bfd_check_format(bfdh, bfd_object)) { LOGMSG(l_WARN, "bfd_check_format() failed"); goto out; } disassembler_ftype disassemble = disassembler(bfdh); if (disassemble == NULL) { LOGMSG(l_WARN, "disassembler() failed"); goto out; } struct disassemble_info info; init_disassemble_info(&info, instr, arch_bfdFPrintF); info.arch = bfd_get_arch(bfdh); info.mach = bfd_get_mach(bfdh); info.buffer = mem; info.buffer_length = size; info.section = NULL; info.endian = bfd_little_endian(bfdh) ? BFD_ENDIAN_LITTLE : BFD_ENDIAN_BIG; disassemble_init_for_target(&info); strcpy(instr, ""); if (disassemble(0, &info) <= 0) { snprintf(instr, _HF_INSTR_SZ, "[DIS-ASM_FAILURE]"); } out: bfdh ? bfd_close_all_done(bfdh) : 0; while (pthread_mutex_unlock(&arch_bfd_mutex)) ; return; }
// returns a string which is valid until the next call to this function char* string_of_insn(asm_program_t *prog, Instruction *inst) { static struct bprintf_buffer bits = {NULL, NULL, 0}; disassembler_ftype disas = disassembler(prog->abfd); fprintf_ftype old_fprintf_func = prog->disasm_info.fprintf_func; void *oldstream = prog->disasm_info.stream; prog->disasm_info.fprintf_func = (fprintf_ftype)bprintf; prog->disasm_info.stream = &bits; bits.end = bits.str; int len = disas(inst->address, &prog->disasm_info); prog->disasm_info.fprintf_func = old_fprintf_func; prog->disasm_info.stream = oldstream; return bits.str; }
void NewCpu::Trace() { Disassembler disassembler(_regs.PC.W, _mem); DisassembledInstruction instruction; disassembler.Disassemble(instruction); printf("%04X %-10s %-12s A:%02x X:%02X Y:%02X P:%02X S:%02X\n", _regs.PC.W, instruction.GetFormattedBytes().c_str(), instruction.GetDisassemblyString().c_str(), _regs.A, _regs.X, _regs.Y, _regs.P, _regs.SP ); }
static void get_asm_insns(uint8_t *image, size_t len, unsigned long base, int opcodes) { int count, i, pc = 0; char tpath[256]; struct disassemble_info info; disassembler_ftype disassemble; bfd *bfdf; memset(tpath, 0, sizeof(tpath)); get_exec_path(tpath, sizeof(tpath)); bfdf = bfd_openr(tpath, NULL); assert(bfdf); assert(bfd_check_format(bfdf, bfd_object)); init_disassemble_info(&info, stdout, (fprintf_ftype) fprintf); info.arch = bfd_get_arch(bfdf); info.mach = bfd_get_mach(bfdf); info.buffer = image; info.buffer_length = len; disassemble_init_for_target(&info); disassemble = disassembler(bfdf); assert(disassemble); do { printf("%4x:\t", pc); count = disassemble(pc, &info); if (opcodes) { printf("\n\t"); for (i = 0; i < count; ++i) printf("%02x ", (uint8_t) image[pc + i]); } printf("\n"); pc += count; } while(count > 0 && pc < len); bfd_close(bfdf); }
spv_result_t spvBinaryToText(const spv_const_context context, const uint32_t* code, const size_t wordCount, const uint32_t options, spv_text* pText, spv_diagnostic* pDiagnostic) { // Invalid arguments return error codes, but don't necessarily generate // diagnostics. These are programmer errors, not user errors. if (!pDiagnostic) return SPV_ERROR_INVALID_DIAGNOSTIC; const libspirv::AssemblyGrammar grammar(context); if (!grammar.isValid()) return SPV_ERROR_INVALID_TABLE; Disassembler disassembler(grammar, options); if (auto error = spvBinaryParse(context, &disassembler, code, wordCount, DisassembleHeader, DisassembleInstruction, pDiagnostic)) { return error; } return disassembler.SaveTextResult(pText); }
// returns a string which is valid until the next call to this function char* asmir_string_of_insn(asm_program_t *prog, bfd_vma inst) { static struct bprintf_buffer bits = {NULL, NULL, 0}; disassembler_ftype disas = disassembler(prog->abfd); fprintf_ftype old_fprintf_func = prog->disasm_info.fprintf_func; void *oldstream = prog->disasm_info.stream; prog->disasm_info.disassembler_options = "intel"; prog->disasm_info.fprintf_func = (fprintf_ftype)bprintf; prog->disasm_info.stream = &bits; bits.end = bits.str; disas(inst, &prog->disasm_info); prog->disasm_info.fprintf_func = old_fprintf_func; prog->disasm_info.stream = oldstream; return bits.str; }
bool Compare(const std::vector<u16> &code1, const std::vector<u16> &code2) { if (code1.size() != code2.size()) printf("Size difference! 1=%i 2=%i\n", (int)code1.size(), (int)code2.size()); u32 count_equal = 0; const int min_size = std::min<int>(code1.size(), code2.size()); AssemblerSettings settings; DSPDisassembler disassembler(settings); for (int i = 0; i < min_size; i++) { if (code1[i] == code2[i]) { count_equal++; } else { std::string line1, line2; u16 pc = i; disassembler.DisassembleOpcode(&code1[0], 0x0000, 2, &pc, line1); pc = i; disassembler.DisassembleOpcode(&code2[0], 0x0000, 2, &pc, line2); printf("!! %04x : %04x vs %04x - %s vs %s\n", i, code1[i], code2[i], line1.c_str(), line2.c_str()); } } if (code2.size() != code1.size()) { printf("Extra code words:\n"); const std::vector<u16> &longest = code1.size() > code2.size() ? code1 : code2; for (int i = min_size; i < (int)longest.size(); i++) { u16 pc = i; std::string line; disassembler.DisassembleOpcode(&longest[0], 0x0000, 2, &pc, line); printf("!! %s\n", line.c_str()); } } printf("Equal instruction words: %i / %i\n", count_equal, min_size); return code1.size() == code2.size() && code1.size() == count_equal; }
char* disasm( bhp _p, unsigned long long addr ) { static struct bprintf_buffer bits = {NULL, NULL, 0}; bh* p = (bh*) _p; struct disassemble_info* di = p->disasp; disassembler_ftype disas = disassembler( p->bfdp ); fprintf_ftype old_fprintf_func = di->fprintf_func; void *oldstream = di->stream; di->fprintf_func = (fprintf_ftype) bprintf; di->stream = &bits; bits.end = bits.str; disas( addr, di ); di->fprintf_func = old_fprintf_func; di->stream = oldstream; return bits.str; }
bool disas_libopcode(FILE *fp_out, const char *machine, bool big_endian, uint64_t addr, void *buf, size_t len) { bfd *abfd = NULL; struct disassemble_info inf; const bfd_arch_info_type *arch_inf = bfd_scan_arch (machine); disassembler_ftype disas_fn; int size, pos; if (!arch_inf) { return false; } abfd = bfd_openr("/dev/null", "binary"); abfd->arch_info = arch_inf; init_disassemble_info (&inf, fp_out, (fprintf_ftype) fprintf); inf.buffer = buf; inf.buffer_vma = addr; inf.buffer_length = len; inf.endian = big_endian ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE; inf.print_address_func = print_address; disassemble_init_for_target(&inf); disas_fn = disassembler (abfd); pos = 0; do { fprintf(fp_out, "%" PRIx64 "\t", addr + pos); size = disas_fn(addr + pos, &inf); pos += size; fputc('\n', fp_out); } while (pos < len); bfd_close(abfd); return true; }
struct sr_disasm_state * sr_disasm_init(const char *file_name, char **error_message) { #if HAVE_LIBOPCODES struct sr_disasm_state *state = sr_malloc(sizeof(struct sr_disasm_state)); state->bfd_file = bfd_openr(file_name, NULL); if (!state->bfd_file) { *error_message = sr_asprintf("Failed to open file %s: %s", file_name, bfd_errmsg(bfd_get_error())); free(state); return NULL; } if (!bfd_check_format(state->bfd_file, bfd_object)) { *error_message = sr_asprintf("Invalid file format of %s: %s", file_name, bfd_errmsg(bfd_get_error())); bfd_close(state->bfd_file); free(state); return NULL; } asection *section = bfd_get_section_by_name(state->bfd_file, ".text"); if (!section) { *error_message = sr_asprintf( "Failed to find .text section in %s: %s", file_name, bfd_errmsg(bfd_get_error())); bfd_close(state->bfd_file); free(state); return NULL; } state->disassembler = disassembler(state->bfd_file); if (!state->disassembler) { *error_message = sr_asprintf( "Unable to find disassembler for %s", file_name); bfd_close(state->bfd_file); free(state); return NULL; } init_disassemble_info(&state->info, NULL, buffer_printf); state->info.arch = bfd_get_arch(state->bfd_file); state->info.mach = bfd_get_mach(state->bfd_file); state->info.buffer_vma = section->vma; state->info.buffer_length = section->size; state->info.section = section; /* TODO: memory error func */ bfd_malloc_and_get_section(state->bfd_file, section, &state->info.buffer); disassemble_init_for_target(&state->info); return state; #else // HAVE_LIBOPCODES *error_message = sr_asprintf("satyr compiled without libopcodes"); return NULL; #endif // HAVE_LIBOPCODES }
disassembler::disassembler() { disassembler(NULL); }
void init_disassemble(){ abfd = malloc(sizeof(bfd)); init_disassemble_info (&disasm_info, stdout, (fprintf_ftype) fprintf); disasm_info.print_address_func = objdump_print_address; disasm_info.symbol_at_address_func = objdump_symbol_at_address; /* * choose arch infor since we will select different disassemble function. */ generic_arch_t* arch_instance = get_arch_instance(""); machine = arch_instance->arch_name; const bfd_arch_info_type *info = bfd_scan_arch (machine); if (info == NULL){ //fatal (_("Can't use supplied machine %s"), machine); printf("Can't use supplied machine %s\n", machine); return; } abfd->arch_info = info; /* * endian selection */ if (endian != BFD_ENDIAN_UNKNOWN) { struct bfd_target *xvec; xvec = xmalloc (sizeof (struct bfd_target)); //memcpy (xvec, abfd->xvec, sizeof (struct bfd_target)); xvec->byteorder = endian; abfd->xvec = xvec; } /* Get a disassemble function according to the arch and endian of abfd */ disassemble_fn = disassembler (abfd); if(!disassemble_fn) { /* non_fatal (_("Can't disassemble for architecture %s\n"), bfd_printable_arch_mach (bfd_get_arch (abfd), 0)); */ printf("Can't disassemble for architecture %s\n", bfd_printable_arch_mach (bfd_get_arch (abfd), 0)); exit_status = 1; return; } disasm_info.flavour = bfd_get_flavour (abfd); disasm_info.arch = bfd_get_arch (abfd); disasm_info.mach = bfd_get_mach (abfd); disasm_info.disassembler_options = disassembler_options; disasm_info.octets_per_byte = bfd_octets_per_byte (abfd); disasm_info.skip_zeroes = DEFAULT_SKIP_ZEROES; disasm_info.skip_zeroes_at_end = DEFAULT_SKIP_ZEROES_AT_END; disasm_info.disassembler_needs_relocs = FALSE; #if 1 if (bfd_big_endian (abfd)) disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_BIG; else if (bfd_little_endian (abfd)) disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE; else /* ??? Aborting here seems too drastic. We could default to big or little instead. */ disasm_info.endian = BFD_ENDIAN_UNKNOWN; #endif /* set the default endianess is BFD_ENDIAN_LITTLE */ disasm_info.display_endian = disasm_info.endian = BFD_ENDIAN_LITTLE; disasm_info.symtab = sorted_syms; disasm_info.symtab_size = sorted_symcount; disasm_info.read_memory_func = disasm_read_memory; free (sorted_syms); }
uv_err_t UVDBfdInstructionIterator::init() { bfd *a_bfd = NULL; uv_assert_ret(m_obj); uv_assert_ret(m_obj->m_bfd); a_bfd = m_obj->m_bfd; //Needs to be an object or an archive if( !bfd_check_format(a_bfd, bfd_object) && !bfd_check_format(a_bfd, bfd_archive) ) { //bfd_close(a_bfd); printf("bad file\n"); return UV_DEBUG(UV_ERR_GENERAL); } printf("BFD open and is object\n"); /* Standard disassemblers. Disassemble one instruction at the given target address. Return number of octets processed. typedef int (*disassembler_ftype) (bfd_vma, disassemble_info *); */ g_disassembler_function = disassembler(a_bfd); if( !g_disassembler_function ) { printf("failed \n"); return UV_DEBUG(UV_ERR_GENERAL); } memset(&m_disasm_info, 0, sizeof(m_disasm_info)); init_disassemble_info(&m_disasm_info, stdout, (fprintf_ftype) fprintf); m_disasm_info.flavour = bfd_get_flavour (a_bfd); m_disasm_info.arch = bfd_get_arch (a_bfd); m_disasm_info.mach = bfd_get_mach (a_bfd); m_disasm_info.disassembler_options = NULL; m_disasm_info.octets_per_byte = bfd_octets_per_byte(a_bfd); m_disasm_info.skip_zeroes = 0; m_disasm_info.skip_zeroes_at_end = 0; m_disasm_info.disassembler_needs_relocs = FALSE; m_disasm_info.display_endian = m_disasm_info.endian = BFD_ENDIAN_BIG; //Don't care m_disasm_info.application_data = NULL; m_disasm_info.print_address_func = objdump_print_address; m_disasm_info.symbol_at_address_func = objdump_symbol_at_address; disassemble_init_for_target(&m_disasm_info); //Wonder if these can be NULL? m_disasm_info.symtab = NULL; m_disasm_info.symtab_size = 0; /* This won't work since we want to step on our own accord bfd_map_over_sections(a_bfd, disassemble_section, &disasm_info); */ #if 0 void bfd_map_over_sections (bfd *abfd, void (*operation) (bfd *, asection *, void *), void *user_storage) { asection *sect; unsigned int i = 0; for (sect = abfd->sections; sect != NULL; i++, sect = sect->next) (*operation) (abfd, sect, user_storage); if (i != abfd->section_count) /* Debugging */ abort (); }
void LLVMState::show_machine_code(void* buffer, size_t size) { #if defined(IS_X86) || defined(IS_X8664) #ifndef RBX_WINDOWS ud_t ud; ud_init(&ud); #ifdef IS_64BIT_ARCH ud_set_mode(&ud, 64); #else ud_set_mode(&ud, 32); #endif ud_set_syntax(&ud, UD_SYN_ATT); ud_set_input_buffer(&ud, reinterpret_cast<uint8_t*>(buffer), size); while(ud_disassemble(&ud)) { void* address = reinterpret_cast<void*>( reinterpret_cast<uintptr_t>(buffer) + ud_insn_off(&ud)); llvm::outs() << format("%10p", address) << " "; llvm::outs() << format("%-24s", ud_insn_asm(&ud)); if(ud.operand[0].type == UD_OP_JIMM) { const void* addr = (const void*)((uintptr_t)buffer + ud.pc + (int)ud.operand[0].lval.udword); llvm::outs() << " ; " << addr; if(ud.mnemonic == UD_Icall) { Dl_info info; if(dladdr((void*)addr, &info)) { int status = 0; char* cpp_name = abi::__cxa_demangle(info.dli_sname, 0, 0, &status); if(status >= 0) { // Chop off the arg info from the signature output char *paren = strstr(cpp_name, "("); *paren = 0; llvm::outs() << " " << cpp_name; free(cpp_name); } else { llvm::outs() << " " << info.dli_sname; } } } } for(uint8_t i = 0; i < 2; i++) { if(ud.operand[i].type == UD_OP_IMM) { Dl_info info; if(dladdr((void*)ud.operand[i].lval.uqword, &info)) { llvm::outs() << " ; " << info.dli_sname; break; // only do one } } } llvm::outs() << "\n"; } #endif // !RBX_WINDOWS #else JITDisassembler disassembler(buffer, size); std::string output = disassembler.print_machine_code(); std::cout << output; #endif // !IS_X86 }
void disNCS(const Common::UString &inFile, const Common::UString &outFile, Aurora::GameID &game, Command &command, bool printStack, bool printControlTypes) { Common::SeekableReadStream *ncs = new Common::ReadFile(inFile); Common::WriteStream *out = 0; try { if (!outFile.empty()) out = new Common::WriteFile(outFile); else out = new Common::StdOutStream; status("Disassembling script..."); NWScript::Disassembler disassembler(*ncs, game); if (game != Aurora::kGameIDUnknown) { try { status("Analyzing script stack..."); disassembler.analyzeStack(); } catch (...) { Common::exceptionDispatcherWarnAndIgnore("Script analysis failed"); } try { status("Analyzing control flow..."); disassembler.analyzeControlFlow(); } catch (...) { Common::exceptionDispatcherWarnAndIgnore("Control flow analysis failed"); } } switch (command) { case kCommandListing: disassembler.createListing(*out, printStack); break; case kCommandAssembly: disassembler.createAssembly(*out, printStack); break; case kCommandDot: disassembler.createDot(*out, printControlTypes); break; default: throw Common::Exception("Invalid command %u", (uint)command); } } catch (...) { delete ncs; delete out; throw; } out->flush(); if (!outFile.empty()) status("Disassembled \"%s\" into \"%s\"", inFile.c_str(), outFile.c_str()); delete ncs; delete out; }
void SourceAssembler::emit(int instr) { stream()->print("\t"); disassembler().disasm(NULL, instr); emit_comment_and_cr(); }
/* * Implementation */ void jit_init_debug(const char *progname) { #if DISASSEMBLER bfd_init(); if (progname) disasm_bfd = bfd_openr(progname, NULL); if (disasm_bfd == NULL) { #if defined(__linux__) disasm_bfd = bfd_openr("/proc/self/exe", NULL); if (disasm_bfd == NULL) #endif return; } bfd_check_format(disasm_bfd, bfd_object); bfd_check_format(disasm_bfd, bfd_archive); disasm_print = disassembler(disasm_bfd); assert(disasm_print); INIT_DISASSEMBLE_INFO(disasm_info, disasm_stream, fprintf); # if defined(__i386__) || defined(__x86_64__) disasm_info.arch = bfd_arch_i386; # if defined(__x86_64__) # if __WORDSIZE == 32 disasm_info.mach = bfd_mach_x64_32; # else disasm_info.mach = bfd_mach_x86_64; # endif # else disasm_info.mach = bfd_mach_i386_i386; # endif # endif # if defined(__powerpc__) disasm_info.arch = bfd_arch_powerpc; disasm_info.mach = bfd_mach_ppc64; # if HAVE_DISASSEMBLE_INIT_FOR_TARGET disassemble_init_for_target(&disasm_info); # elif HAVE_DISASSEMBLE_INIT_POWERPC disassemble_init_powerpc(&disasm_info); # endif # if defined(__powerpc64__) disasm_info.disassembler_options = "64"; # endif # if HAVE_DISASSEMBLE_INIT_FOR_TARGET disassemble_init_for_target(&disasm_info); # elif HAVE_DISASSEMBLE_INIT_POWERPC disassemble_init_powerpc(&disasm_info); # endif # endif # if defined(__sparc__) disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG; # endif # if defined(__s390__) || defined(__s390x__) disasm_info.arch = bfd_arch_s390; # if __WORDSIZE == 32 disasm_info.mach = bfd_mach_s390_31; # else disasm_info.mach = bfd_mach_s390_64; # endif disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG; disasm_info.disassembler_options = "zarch"; # endif # if defined(__alpha__) disasm_info.arch = bfd_arch_alpha; disasm_info.mach = bfd_mach_alpha_ev6; # endif disasm_info.print_address_func = disasm_print_address; if (bfd_get_file_flags(disasm_bfd) & HAS_SYMS) { asymbol **in; asymbol **out; asymbol *symbol; long offset; long sym_count; long dyn_count; long sym_storage; long dyn_storage; if ((sym_storage = bfd_get_symtab_upper_bound(disasm_bfd)) >= 0) { if (bfd_get_file_flags(disasm_bfd) & DYNAMIC) { dyn_storage = bfd_get_dynamic_symtab_upper_bound(disasm_bfd); # if defined(__alpha__) /* XXX */ if (dyn_storage < 0) dyn_storage = 0; # else assert(dyn_storage >= 0); # endif } else dyn_storage = 0; jit_alloc((jit_pointer_t *)&disasm_symbols, (sym_storage + dyn_storage) * sizeof(asymbol *)); sym_count = bfd_canonicalize_symtab(disasm_bfd, disasm_symbols); assert(sym_count >= 0); if (dyn_storage) { dyn_count = bfd_canonicalize_dynamic_symtab(disasm_bfd, disasm_symbols + sym_count); assert(dyn_count >= 0); } else dyn_count = 0; disasm_num_symbols = sym_count + dyn_count; disasm_num_synthetic = bfd_get_synthetic_symtab(disasm_bfd, sym_count, disasm_symbols, dyn_count, disasm_symbols + sym_count, &disasm_synthetic); if (disasm_num_synthetic > 0) { jit_realloc((jit_pointer_t *)&disasm_symbols, (sym_storage + dyn_storage) * sizeof(asymbol *), (sym_storage + dyn_storage + disasm_num_synthetic) * sizeof(asymbol *)); for (offset = 0; offset < disasm_num_synthetic; offset++) disasm_symbols[disasm_num_symbols++] = disasm_synthetic + offset; } /* remove symbols not useful for disassemble */ in = out = disasm_symbols; for (offset = 0; offset < disasm_num_symbols; offset++) { symbol = *in++; if (symbol->name && symbol->name[0] != '\0' && !(symbol->flags & (BSF_DEBUGGING | BSF_SECTION_SYM)) && !bfd_is_und_section(symbol->section) && !bfd_is_com_section(symbol->section)) *out++ = symbol; } disasm_num_symbols = out - disasm_symbols; qsort(disasm_symbols, disasm_num_symbols, sizeof(asymbol *), disasm_compare_symbols); } } #endif }