void print_structs(FILE* f, int d) { struct_table *curr = structs; while (curr != NULL) { fprintf(f, "struct: %s\n", curr->name); print_symbols(curr->s, f, 1); curr = curr -> next; } }
int main(int argc, char **argv) { assert(argc > 1); char *filename = argv[1]; if (elf_version(EV_CURRENT) == EV_NONE ) { /* library out of date */ fprintf(stderr, "Elf library out of date!n"); exit(-1); } int fd = open(argv[1], O_RDONLY); if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL){ /*error*/ } check_symbol_table() && print_symbols(elf, symtab_section, &symtab_shdr); }
static int nm(char *filename, t_arg_nm *options, t_bin *binary, size_t count) { t_head headers; get_binary_headers(binary->data, &headers); if (!headers.mach32 && !headers.mach64) { print_file_error(filename, "The file was not recognized as a valid object file."); return (1); } if ((!headers.mach32 && options->arch == A_X32) || (!headers.mach64 && options->arch == A_X64)) print_file_error(filename, "No architecture specified."); else if (((options->arch == A_ALL && (!headers.mach32 || !headers.mach64)) || options->arch == A_DEF || (options->arch == A_X32 && headers.mach32 && !headers.mach64) || (options->arch == A_X64 && headers.mach64 && !headers.mach32)) && count > 1 && !(options->arch == A_DEF && headers.mach32 && headers.mach64)) print_filename_arch(filename, NULL); print_symbols(filename, options, &headers); return (0); }
/* * nm() is the routine that gets called by ofile_process() to process single * object files. */ static void nm( struct ofile *ofile, char *arch_name, void *cookie) { struct cmd_flags *cmd_flags; struct process_flags process_flags; unsigned long i, j, k; struct load_command *lc; struct symtab_command *st; struct dysymtab_command *dyst; struct segment_command *sg; struct section *s; struct nlist *symbols; unsigned long nsymbols; cmd_flags = (struct cmd_flags *)cookie; process_flags.nsect = -1; process_flags.sect_addr = 0; process_flags.sect_size = 0; process_flags.sect_start_symbol = FALSE; process_flags.nsects = 0; process_flags.sections = NULL; process_flags.text_nsect = NO_SECT; process_flags.data_nsect = NO_SECT; process_flags.bss_nsect = NO_SECT; st = NULL; dyst = NULL; lc = ofile->load_commands; for(i = 0; i < ofile->mh->ncmds; i++){ if(st == NULL && lc->cmd == LC_SYMTAB){ st = (struct symtab_command *)lc; } else if(dyst == NULL && lc->cmd == LC_DYSYMTAB){ dyst = (struct dysymtab_command *)lc; } else if(lc->cmd == LC_SEGMENT){ sg = (struct segment_command *)lc; process_flags.nsects += sg->nsects; } lc = (struct load_command *)((char *)lc + lc->cmdsize); } if(st == NULL || st->nsyms == 0){ error("no name list"); return; } if(process_flags.nsects > 0){ process_flags.sections = (struct section **) malloc(sizeof(struct section *) * process_flags.nsects); k = 0; lc = ofile->load_commands; for (i = 0; i < ofile->mh->ncmds; i++){ if(lc->cmd == LC_SEGMENT){ sg = (struct segment_command *)lc; s = (struct section *) ((char *)sg + sizeof(struct segment_command)); for(j = 0; j < sg->nsects; j++){ if(strcmp((s + j)->sectname, SECT_TEXT) == 0 && strcmp((s + j)->segname, SEG_TEXT) == 0) process_flags.text_nsect = k + 1; else if(strcmp((s + j)->sectname, SECT_DATA) == 0 && strcmp((s + j)->segname, SEG_DATA) == 0) process_flags.data_nsect = k + 1; else if(strcmp((s + j)->sectname, SECT_BSS) == 0 && strcmp((s + j)->segname, SEG_DATA) == 0) process_flags.bss_nsect = k + 1; process_flags.sections[k++] = s + j; } } lc = (struct load_command *) ((char *)lc + lc->cmdsize); } } /* select symbols to print */ symbols = select_symbols(ofile, st, dyst, cmd_flags, &process_flags, &nsymbols); /* set names in the symbols to be printed */ strings = ofile->object_addr + st->stroff; strsize = st->strsize; for(i = 0; i < nsymbols; i++){ if(symbols[i].n_un.n_strx == 0) symbols[i].n_un.n_name = ""; else if(symbols[i].n_un.n_strx < 0 || (unsigned long)symbols[i].n_un.n_strx > st->strsize) symbols[i].n_un.n_name = "bad string index"; else symbols[i].n_un.n_name = symbols[i].n_un.n_strx + strings; if((symbols[i].n_type & N_TYPE) == N_INDR){ if(symbols[i].n_value == 0) symbols[i].n_value = (long)""; else if(symbols[i].n_value > st->strsize) symbols[i].n_value = (long)"bad string index"; else symbols[i].n_value = (long)(symbols[i].n_value + strings); } } /* sort the symbols if needed */ qsort(symbols, nsymbols, sizeof(struct nlist), (int (*)(const void *, const void *))compare); if (cmd_flags->c == TRUE) { /* print header */ fprintf(output, "#ifndef _%s.H_\n", cmd_flags->ofile_name); fprintf(output, "#define _%s.H_\n", cmd_flags->ofile_name); } /* now print the symbols as specified by the flags */ print_symbols(ofile, symbols, nsymbols, strings, st->strsize, cmd_flags, &process_flags, arch_name); free(symbols); if(process_flags.sections != NULL) free(process_flags.sections); if (cmd_flags->c == TRUE) { /* print footer */ fprintf(output, "#endif /* _%s.H_ */\n", cmd_flags->ofile_name); } }
/* Main entry point of elf-parser */ int32_t main(int32_t argc, char *argv[]) { int32_t fd; Elf32_Ehdr eh; /* elf-header is fixed size */ if(argc!=2) { printf("Usage: elf-parser <ELF-file>\n"); return 0; } fd = open(argv[1], O_RDONLY|O_SYNC); if(fd<0) { printf("Error %d Unable to open %s\n", fd, argv[1]); return 0; } /* ELF header : at start of file */ read_elf_header(fd, &eh); if(!is_ELF(eh)) { return 0; } if(is64Bit(eh)){ Elf64_Ehdr eh64; /* elf-header is fixed size */ Elf64_Shdr* sh_tbl; /* section-header table is variable size */ read_elf_header64(fd, &eh64); print_elf_header64(eh64); /* Section header table : */ sh_tbl = malloc(eh64.e_shentsize * eh64.e_shnum); if(!sh_tbl) { printf("Failed to allocate %d bytes\n", (eh64.e_shentsize * eh64.e_shnum)); } read_section_header_table64(fd, eh64, sh_tbl); print_section_headers64(fd, eh64, sh_tbl); /* Symbol tables : * sh_tbl[i].sh_type * |`- SHT_SYMTAB * `- SHT_DYNSYM */ print_symbols64(fd, eh64, sh_tbl); /* Save .text section as text.S */ save_text_section64(fd, eh64, sh_tbl); /* Disassemble .text section * Logs asm instructions to stdout * Currently supports ARMv7 */ disassemble64(fd, eh64, sh_tbl); } else{ Elf32_Shdr* sh_tbl; /* section-header table is variable size */ print_elf_header(eh); /* Section header table : */ sh_tbl = malloc(eh.e_shentsize * eh.e_shnum); if(!sh_tbl) { printf("Failed to allocate %d bytes\n", (eh.e_shentsize * eh.e_shnum)); } read_section_header_table(fd, eh, sh_tbl); print_section_headers(fd, eh, sh_tbl); /* Symbol tables : * sh_tbl[i].sh_type * |`- SHT_SYMTAB * `- SHT_DYNSYM */ print_symbols(fd, eh, sh_tbl); /* Save .text section as text.S */ save_text_section(fd, eh, sh_tbl); /* Disassemble .text section * Logs asm instructions to stdout * Currently supports ARMv7 */ disassemble(fd, eh, sh_tbl); } return 0; }
/* * Copy a contents of binary file to the device. */ void write_image(const char *filename, const char *device_name, int verify_only) { char buf[32*1024]; int src, dest, n, progress_len, progress_step; struct stat st; off_t nbytes, count; struct timeval t0; src = open(filename, O_RDONLY); if (src < 0) { perror(filename); quit(0); } dest = open(device_name, O_RDWR); if (dest < 0) { perror(device_name); quit(0); } fstat(src, &st); nbytes = st.st_size; printf(" Source: %s\n", filename); printf("Destination: %s\n", device_name); printf(" Size: %.1f MB\n", nbytes / 1000000.0); /* Compute length of progress indicator. */ for (progress_step=1; ; progress_step<<=1) { progress_len = (nbytes + sizeof(buf) - 1) / sizeof(buf); if (progress_len / progress_step < 64) { progress_len += progress_step - 1; progress_len /= progress_step; break; } } progress_count = 0; gettimeofday(&t0, 0); if (! verify_only) { printf(" Write: "); print_symbols('.', progress_len); print_symbols('\b', progress_len); fflush(stdout); for (count=0; count<nbytes; count+=sizeof(buf)) { /* Flush buffers every 4 Mbytes. */ if (count % (4*1024*1024) == 0) fsync(dest); /* Read data into buffer. */ n = nbytes - count; if (n > sizeof(buf)) n = sizeof(buf); if (read(src, buf, n) != n) { fprintf(stderr, "%s: Read error\n", filename); quit(0); } /* Write data to the disk. */ if (write(dest, buf, n) != n) { fprintf(stderr, "%s: Write error\n", device_name); quit(0); } progress(progress_step); } printf(" done \n"); fsync(dest); } if (verify_only) { char buf2[sizeof(buf)]; printf(" Verify: "); print_symbols('.', progress_len); print_symbols('\b', progress_len); fflush(stdout); for (count=0; count<nbytes; count+=sizeof(buf)) { /* Read source data. */ n = nbytes - count; if (n > sizeof(buf)) n = sizeof(buf); if (read(src, buf, n) != n) { fprintf(stderr, "%s: Read error\n", filename); quit(0); } /* Read destination data. */ if (read(dest, buf2, n) != n) { fprintf(stderr, "%s: Read error\n", device_name); quit(0); } /* Compare. */ if (memcmp(buf, buf2, n) != 0) { fprintf(stderr, "DATA ERROR!\n"); print_mismatch(buf, buf2, n, lseek(src, 0, SEEK_CUR) - n); quit(0); } progress(progress_step); } printf(" done \n"); } close(src); close(dest); printf(" Speed: %.1f MB/sec\n", nbytes / 1000.0 / mseconds_elapsed(&t0)); }
int main(int argc, char *argv[]) { /* process arguments */ handle_opts(argc, argv); /* open files */ vlog("[plpcc] opening files\n"); FILE_INPUT = fopen(S_FILE_INPUT,"r"); if (FILE_INPUT == NULL) { err("[plpcc] cannot open input file: %s\n", S_FILE_INPUT); } FILE_OUTPUT = fopen(S_FILE_OUTPUT,"w"); if (FILE_OUTPUT == NULL) { err("[plpcc] cannot open output file: %s\n", S_FILE_OUTPUT); } yyset_in(FILE_INPUT); if (S_SYMBOL_OUTPUT != NULL) { SYMBOL_OUTPUT = fopen(S_SYMBOL_OUTPUT, "w"); if (SYMBOL_OUTPUT == NULL) { err("[plpcc] cannot open symbol table output file: %s\n", S_SYMBOL_OUTPUT); } } if (S_PARSE_OUTPUT != NULL) { PARSE_OUTPUT = fopen(S_PARSE_OUTPUT, "w"); if (PARSE_OUTPUT == NULL) { err("[plpcc] cannot open parse tree output file: %s\n", S_PARSE_OUTPUT); } } if (S_GRAPH_OUTPUT != NULL) { GRAPH_OUTPUT = fopen(S_GRAPH_OUTPUT, "w"); if (GRAPH_OUTPUT == NULL) { err("[plpcc] cannot open parse tree graph output file: %s\n", S_GRAPH_OUTPUT); } } /* grab the lines from the source for error handling and annotation */ build_lines(S_FILE_INPUT); /* create an empty symbol table */ sym = new_symbol_table(NULL); log("[plpcc] starting frontend\n"); yyparse(); /* print the parse tree */ if (PARSE_OUTPUT != NULL) { vlog("[plpcc] printing parse tree\n"); print_tree(parse_tree_head, PARSE_OUTPUT, 0); } /* print the parse tree graph formatted for Graphviz*/ if (GRAPH_OUTPUT != NULL) { vlog("[plpcc] printing parse tree graph\n"); print_tree_graph(parse_tree_head, GRAPH_OUTPUT, S_FILE_INPUT); /* close output file*/ fclose(GRAPH_OUTPUT); /* Run Graphviz command to generate PNG of parse tree */ S_GRAPH_COMMAND = malloc(sizeof(char) * (strlen(S_FILE_OUTPUT) * 2 + 22)); sprintf(S_GRAPH_COMMAND, "dot -Tpng %s.dot > %s.png", S_FILE_OUTPUT, S_FILE_OUTPUT); system(S_GRAPH_COMMAND); } /* print the symbol table */ if (SYMBOL_OUTPUT != NULL) { vlog("[plpcc] printing symbol table\n"); print_symbols(sym, SYMBOL_OUTPUT, 0); vlog("[plpcc] printing activation records\n"); print_frames(sym, SYMBOL_OUTPUT); } /* call the backend to compile the parse tree, starting from the head */ if (NO_COMPILE == 0) { handle(parse_tree_head); fprintf(FILE_OUTPUT, "%s", program); } vlog("[plpcc] closing files\n"); fclose(FILE_INPUT); fclose(FILE_OUTPUT); log("[plpcc] done\n"); return 0; }
int main(int argc, char *argv[]) { bool need_exit = false; ptrace_context ptrace_ctx; program_params params; struct itimerval itv; struct proc_timer proc_time; calltree_node *root = NULL; g_progname = argv[0]; if (!parse_args(¶ms, argc, argv)) usage(); print_message("Reading symbols (list of function)"); init_fndescr(params.pid); if (params.just_print_symbols) { print_symbols(); free_fndescr(); exit(0); } if (!reset_process_time(&proc_time, params.pid, params.prof_method)) { free_fndescr(); errx(2, "Failed to retrieve process time"); } print_message("Attaching to process: %d", params.pid); memset(&ptrace_ctx, 0, sizeof(ptrace_ctx)); if (!trace_init(params.pid, &ptrace_ctx)) err(1, "Failed to initialize unwind internals"); signal(SIGCHLD, on_sigchld); if (ptrace(PTRACE_ATTACH, params.pid, 0, 0) == -1) { int saved_errno = errno; warn("ptrace(PTRACE_ATTACH) failed"); if (saved_errno == EPERM) { printf("You have to see NOTES section of `man crxprof' for workarounds.\n"); } exit(2); } if (do_wait(&ptrace_ctx, true) != WR_STOPPED) err(1, "Error occured while stopping the process"); if (ptrace(PTRACE_CONT, params.pid, 0, 0) < 0) err(1, "Error occured while stopping the process 2"); /* interval timer for snapshots */ itv.it_interval.tv_sec = 0; itv.it_interval.tv_usec = params.us_sleep; itv.it_value = itv.it_interval; signal(SIGALRM, on_sigalarm); if (setitimer(ITIMER_REAL, &itv, NULL) == -1) err(1, "setitimer failed"); print_message("Starting profile (interval %dms)", params.us_sleep / 1000); print_message("Press ^C once to show profile, twice to quit"); signal(SIGINT, on_sigint); /* drop first meter since it contains our preparations */ (void)get_process_dt(&proc_time); while(!need_exit) { waitres_t wres = WR_NOTHING; sleep(1); if (timer_alarmed) { uint64_t proc_dt = get_process_dt(&proc_time); bool need_prof = (params.prof_method == PROF_REALTIME); if (params.prof_method == PROF_CPUTIME) { char st = get_procstate(&ptrace_ctx); if (st == 'R') need_prof = true; } if (need_prof) { kill(params.pid, SIGSTOP); wres = do_wait(&ptrace_ctx, true); if (wres == WR_STOPPED) { int signo_cont = (ptrace_ctx.stop_signal == SIGSTOP) ? 0 : ptrace_ctx.stop_signal; if (!get_backtrace(&ptrace_ctx)) err(2, "failed to get backtrace of process"); /* continue tracee ASAP */ if (ptrace_verbose(PTRACE_CONT, params.pid, 0, signo_cont) < 0) err(1, "ptrace(PTRACE_CONT) failed"); ptrace_ctx.nsnaps++; if (fill_backtrace(proc_dt, &ptrace_ctx.stk, &root)) ptrace_ctx.nsnaps_accounted++; } } } if (wres != WR_FINISHED && wres != WR_NEED_DETACH) { wres = discard_wait(&ptrace_ctx); } if (sigint_caught_twice) { need_exit = true; } else if (sigint_caught || wres == WR_FINISHED || wres == WR_NEED_DETACH) { if (root) { print_message("%" PRIu64 " snapshot interrputs got (%" PRIu64 " dropped)", ptrace_ctx.nsnaps, ptrace_ctx.nsnaps - ptrace_ctx.nsnaps_accounted); visualize_profile(root, ¶ms.vprops); if (params.dumpfile) dump_profile(root, params.dumpfile); } else print_message("No symbolic snapshot caught yet!"); sigint_caught = false; } if (wres == WR_FINISHED || wres == WR_NEED_DETACH) { if (wres == WR_NEED_DETACH) (void)ptrace_verbose(PTRACE_DETACH, params.pid, 0, ptrace_ctx.stop_signal); need_exit = true; } } free_fndescr(); trace_free(&ptrace_ctx); if (root) calltree_destroy(root); return 0; }
int main(int argc, char **argv){ // perform sanity check on arguments if(argc < 3 || argc > 6){ print_help(argv[0]); return 1; } // process argument options int c = 3; while(c < argc){ if(strcmp(argv[c], WARN_FLAG) == 0) warnings = 1; else if(strcmp(argv[c], SYST_FLAG) == 0) print_tables = 1; else if(strcmp(argv[c], COMP_INFO) == 0) print_comp_i = 1; else if(strcmp(argv[c], HELP_FLAG) == 0) print_help(argv[0]); else if(strcmp(argv[c], FAST_FLAG) == 0) make_fast = 1; else{ print_asterisk(RED_C, stderr); fprintf(stderr, "Unknown flag '%s'.\n\n", argv[c]); print_help(argv[0]); return 1; } c++; } // try to open/create the files the user wants us to use FILE *input_file = fopen(argv[1], "r"); FILE *out_file = 0; if(!input_file){ print_asterisk(RED_C, stderr); fprintf(stderr, "Error: Unable to open '%s' for " "reading, exiting.\n", argv[1]); return 2; } out_file = open_write_file(argv[2]); if(!out_file){ print_asterisk(RED_C, stderr); fprintf(stderr, "Error: Unable to open '%s' for writing, exiting.\n", argv[2]); return 2; } // print banner if(print_comp_i){ printf( "\t\t=== Hartz Translator ===\n" "Machine Constraints\n" "\t%d Bytes of Memory\n" "\t%d Registers\n" "\t%d Bytes of Cache\n\n" "Compiler Constraints\n" "\tMax Line Length of %d Bytes\n" "\tMax One Instruction Per Line\n\n", MAX_MEMORY, MAX_REGS, MAX_CACHE, MAX_LINE_LEN); } // setup our program struct to store some data struct program *program = (struct program*) malloc(sizeof(struct program)); memset(program, 0, sizeof(struct program)); program->out = out_file; program->input = argv[1]; program->in = input_file; if(make_fast){ write_instruc_str(HALT, 0, 0, 0, 0, program); fclose(input_file); fclose(out_file); return 0; } // create the symbol table struct symbol_table *tbl = (struct symbol_table*) malloc( sizeof(struct symbol_table)); memset(tbl, 0, sizeof(struct symbol_table)); program->tbl = tbl; // Create the table for constants struct symbol_table *const_tbl = (struct symbol_table*) malloc( sizeof(struct symbol_table)); memset(const_tbl, 0, sizeof(struct symbol_table)); program->const_tbl = const_tbl; // start processing file process_input_program(program); fclose(input_file); fclose(out_file); if(print_tables){ printf("\n"); print_symbols(program->tbl); print_symbols(program->const_tbl); printf("\n"); } if(program->error_code){ print_asterisk(RED_C, stderr); fprintf(stderr, "Stopped processing because of an error.\n"); } else{ print_asterisk(GRN_C, stdout); printf("Done!\n"); } }
static void print_symbol_action (Widget w, XtPointer client_data, XtPointer call_data) { print_symbols (); }