1 / 49

Understanding Object File Formats in High-Level Systems Software

Explore object file formats, memory layout, and run-time stack in computer systems engineering. Learn about COFF, ECOFF, ELF formats, and how compilers translate programs into executable files.

rnishimura
Download Presentation

Understanding Object File Formats in High-Level Systems Software

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Topic 2dHigh-Level languages and Systems Software (Memory Layout) Introduction to Computer Systems Engineering (CPEG 323) \course\cpeg323-08F\Topic2d-323.ppt

  2. Reading List • Slides: Topic2d • Operating System and Compiler Books • Other papers as assigned in class or home works \course\cpeg323-08F\Topic2d-323.ppt

  3. Several Topics • Object File Format • GP register and GP area • Process Memory Image • Run-time Stack • Virtual / Physical memory \course\cpeg323-08F\Topic2d-323.ppt

  4. Object File Format Compiler or assembler translates the program into an object file, which is consequently linked into a executable file. These "object" files and "executable" files have a specific format. Several common formats are: • a.out: assembler and linker output format • COFF: Common Object File Format • ECOFF: Extended Common Object File Format • ELF: Executable and Linking Format \course\cpeg323-08F\Topic2d-323.ppt

  5. Object File Format(Cont.) • a.out: assembler and linker output format A fairly primitive format, lacking some key features to enable easy shared libraries, etc. On UNIX boxes, a.out is the default output format of the system assembler and the linker. The linker makes a.out executable files. A file in a.out format consists of: a header, the program text, program data, text and data relocation information, a symbol table, and a string table (in that order). \course\cpeg323-08F\Topic2d-323.ppt

  6. Object File Format(Cont.) • Common Object File Format (COFF) binary files • COFF is a portable format for binary applications on UNIX System V • Extended Common Object File Format (ECOFF) binary files • Under Windows, Visual C, C++ and every Windows compiler generates ECOFF files. • MIPS \course\cpeg323-08F\Topic2d-323.ppt

  7. Object File Format(Cont.) • ELF: Executable and Linking Format • ELF and COFF formats are very similar but ELF has greater power and flexibility • Become the standard in file format • ELF representation is platform independent \course\cpeg323-08F\Topic2d-323.ppt

  8. Object File Format(Cont.) • Three main types of ELF files • executable file supplies information necessary for the operating system to create a process image. • relocatable file describes how it should be linked with other object files to create an executable file or shared library. • shared object file contains information needed in both static and dynamic linking. \course\cpeg323-08F\Topic2d-323.ppt

  9. ELF Object File Format ELF Format Linking and Execution Views \course\cpeg323-08F\Topic2d-323.ppt

  10. ELF Object File Format(Cont.) The ELF Header • ELF Header is always the first section of the file(The other sections can be in any order) • What does the ELF Header describe? ● the type of the object file ● target architecture ● The location of the Program Header table, Section Header table, and String table ● number and size of entries for each table in the ELF ● the location of the first executable instruction \course\cpeg323-08F\Topic2d-323.ppt

  11. ELF Object File Format(Cont.) The Program Header Table • only important in executable and shared object files • It is an array of entries • each entry is a structure describing a segment in the object file • The OS copies the segment into memory according to the location and size information \course\cpeg323-08F\Topic2d-323.ppt

  12. ELF Object File Format(Cont.) The Section Header Table • Has pointers to all sections in object files • It is similar to the program header • Each entry correlates to a section in the file. • Each entry provides the name, type, memory image starting address, file offset, the section’s size, alignment, and how the information in the section should be interpreted. \course\cpeg323-08F\Topic2d-323.ppt

  13. ELF Object File Format(Cont.) The ELF Sections • Hold code, data, dynamic linking information, debugging data, symbol tables, relocation information, comments, string tables, and notes. • Sections are treated in different ways ● loaded into the process image ● or provide information needed in the building of a process image ● or are used only in linking object files \course\cpeg323-08F\Topic2d-323.ppt

  14. ELF Object File Format(Cont.) The ELF Segments • Group related sections ● text segment groups executable code, ● data segment groups the program data, ● dynamic segment groups information relevant to dynamic loading. • Each segment consists of one or more sections. • A process image is created by loading and interpreting segments. • The OS logically copies a file’s segment to a virtual memory segment according to the information provided in the program header table. \course\cpeg323-08F\Topic2d-323.ppt

  15. Process Memory Image (32-bit Linux) 0x00000000 code Text variables with initial values Data BSS variables without initial values Heap Why separate BSS and DATA? 0x7FFFFFFF Stack OS Reserved 0x80000000 • initialized/uninitialized • Image space 0xFFFFFFFF \course\cpeg323-08F\Topic2d-323.ppt

  16. GP Register and GP Area 0xEFFFFFFF Stack Heap BSS positive offset Global data area 64k GP 0x10008000 negative offset Data Text 0x00000000 \course\cpeg323-08F\Topic2d-323.ppt

  17. GP Register and GP Area(Cont.) Why Global Data Area ? Load variable x to r10 Without GP: 3 instructions Li r9, x -- low 16-bit of x Addiu r9, x -- high 16-bit of x Lw r10, 0(r9) -- load With GP: 1 – instruction LW r10, 24(GP) -- load \course\cpeg323-08F\Topic2d-323.ppt

  18. What should be put into Global Data Area ? GP Register and GP Area(Cont.) Most Frequently Access Data How to Use Global Data Area ? •Global Data Area requires linker support • $gp register must be correctly initialized (by the startup routine) • assembly code must not modify the $gp register \course\cpeg323-08F\Topic2d-323.ppt

  19. Runtime Stack Stack organization High memory argumentn …… argument1 Virtual frame Pointer($fp) Frame offset Local & temporaries framesize Saved registers (including returnreg) Procedure call Argument area stack Pointer($sp) …… low memory \course\cpeg323-08F\Topic2d-323.ppt

  20. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; i1=foo(4, s1); printf(“i1= %d %s\n”, i1, s1); } Q: which variable in which section? \course\cpeg323-08F\Topic2d-323.ppt

  21. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text foo(), main() .rodata s1=“hello world” .data i3 .bss i1, i2, p1 Stack Heap \course\cpeg323-08F\Topic2d-323.ppt

  22. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; i1=foo(4, s1); printf(“i1= %d %s\n”, i1, s1); } Q: where is i4? \course\cpeg323-08F\Topic2d-323.ppt

  23. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text foo(), main() .rodata s1=“hello world” .data i3 .bss i1, i2, i4, p1 Stack Heap \course\cpeg323-08F\Topic2d-323.ppt

  24. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 I4 p1 FP i1.0 SP \course\cpeg323-08F\Topic2d-323.ppt

  25. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 I4 p1 FP i1.0 SP \course\cpeg323-08F\Topic2d-323.ppt

  26. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 FP i1.0 SP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  27. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 FP i1.0 4 copy of p1 SP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  28. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 i1.0 4 copy of p1 FP Return address of main() callee saved registers p2 SP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  29. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 i1.0 4 copy of p1 FP Return address of main() callee saved registers p2 SP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  30. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 i1.0 4 copy of p1 FP Return address of main() callee saved registers p2 Hello world SP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  31. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 FP i1.0 4 copy of p1 SP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  32. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 FP i1.0 =15 4 copy of p1 SP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  33. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2) { static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 SP FP Hello world \course\cpeg323-08F\Topic2d-323.ppt

  34. Runtime Execution Examples int i1, i2[10], i3=2; int *p1; const char *s1=“hello world”; int foo(int a1, char * a2){ static int i4; char * p2; p2=alloc(strlen(a2)); strcpy(p2, a2); return a1+strlen(p2); } main() { int i1; p1=malloc(strlen(s1)+1); strcpy(p1, s1); i1=foo(4, p1); printf(“i1= %d %s\n”, i1, s1); free(p1); } .text s1=“hello world” i3=2 i1 i2 i4 p1 SP FP Memory Leak Hello world \course\cpeg323-08F\Topic2d-323.ppt

  35. Runtime Execution Examples .text s1=“hello world” Why do we need both SP and FP? Can we only use one of them? (Under what kind of situation?) i3=2 i1 i2 i4 p1 FP SP \course\cpeg323-08F\Topic2d-323.ppt

  36. Runtime Execution Examples .text Why do we need both SP and FP? Answer: because of “alloc()” Can we only use one of them? (Under what kind of situation?) Answer: if no dynamically allocated object on stack s1=“hello world” i3=2 i1 i2 i4 p1 FP SP \course\cpeg323-08F\Topic2d-323.ppt

  37. Runtime Execution Examples .text In case both FP and SP are present, which one should be used to access variables on stack? s1=“hello world” i3=2 i1 i2 i4 p1 FP SP \course\cpeg323-08F\Topic2d-323.ppt

  38. Runtime Execution Examples .text Offset is always limited (16-bit). One may not be able to access all the variables from one end, when? LDD R9, OFFSET(FP) s1=“hello world” i3=2 i1 i2 i4 p1 FP SP \course\cpeg323-08F\Topic2d-323.ppt

  39. Runtime Execution Examples .text For 16-bit offset, when frame size >64KB, more instructions are needed ADD R5, SP, OFFSET LDD R9, 0(R5) s1=“hello world” i3=2 i1 i2 i4 p1 FP SP \course\cpeg323-08F\Topic2d-323.ppt

  40. Virtual / Physical memory • User memory space • OS memory space \course\cpeg323-08F\Topic2d-323.ppt

  41. 0x7FFF EFFF Stack Heap BSS Text: instructions Data: variables with initial value BSS: variables without initial value HEAP: for malloc/free STACK: for function call Global Data Data Text 0x0040 0000 Layout of Memory (virtual memory - user) \course\cpeg323-08F\Topic2d-323.ppt

  42. Reserved for kernel 800000016 Stack segment Dynamic data Data segment Static data Text segment 40 000016 Reserved For Interrupt vector Firmware Layout of Memory ( OS memory space) \course\cpeg323-08F\Topic2d-323.ppt

  43. Virtual Memory / Physical Memory • Why Virtual Memory • Limited physical memory size • 64MB to 1GB • Unlimited virtual memory size • Each process may have 2GB • Many processes in the system \course\cpeg323-08F\Topic2d-323.ppt

  44. Virtual Memory/Physical Memory • Physical memory as cache of virtual memory (disk) • Physical memory and virtual memory broke into fixed size pages; • Each physical page holds a virtual page (may come from different processes) • Only the active pages of each process reside in physical memory, physical memory works as cache of virtual memory (disk) • Other pages stay on disk P2: pagen Pn: pagem P1: pagek Physical pagei Page table Physical address Virtual address v rwx Physical page Start address Virtual page Disk address Present bit Protection bits \course\cpeg323-08F\Topic2d-323.ppt

  45. Virtual and Physical Memory Physical Memory Process 1 Process 2 OS U1/P0 U2/P0 Page 0 OS U1/P1 U2/P1 Page 1 U1/P0 U1/P2 U2/P2 Page 2 U2/P3 U1/P3 U2/P3 Page 3 U1/P3 U1/P4 U2/P4 Page 4 U1/P7 U1/P5 U2/P5 Page 5 U1/P6 U1/P6 U2/P6 Page 6 U2/P1 U1/P7 U2/P7 Page 7 On Disk \course\cpeg323-08F\Topic2d-323.ppt

  46. Process Memory Image •what will happen with the following code? int x; int * p = NULL; *p = 12; • why? Invalid pointer – p points to arbitrary address (address 0?) Page protection will assign “readable/executable” to the pages in this section \course\cpeg323-08F\Topic2d-323.ppt

  47. Process Memory Image 0x0 .text Segmentation Fault .rodata .data Different page permissions: .text -> read and execute .rodata -> read .data and .bss -> read and write Stack: read, write and execute Heap: read and write .bss Stack Heap 2GB \course\cpeg323-08F\Topic2d-323.ppt

  48. Process Memory Image #include <malloc.h> main() { int *p; p=(int *)malloc(sizeof(int)); *p=12; } \course\cpeg323-08F\Topic2d-323.ppt

  49. Summary • Object file formats (a.out, COFF, ECOFF, ELF) • Process memory image • Runtime stack • Mapping between Virtual memory and physical memory \course\cpeg323-08F\Topic2d-323.ppt

More Related