LCOV - code coverage report
Current view: top level - lkbce/arch/x86/include/asm - elf.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _ASM_X86_ELF_H
       2             : #define _ASM_X86_ELF_H
       3             : 
       4             : /*
       5             :  * ELF register definitions..
       6             :  */
       7             : 
       8             : #include <asm/ptrace.h>
       9             : #include <asm/user.h>
      10             : #include <asm/auxvec.h>
      11             : 
      12             : typedef unsigned long elf_greg_t;
      13             : 
      14             : #define ELF_NGREG (sizeof(struct user_regs_struct) / sizeof(elf_greg_t))
      15             : typedef elf_greg_t elf_gregset_t[ELF_NGREG];
      16             : 
      17             : typedef struct user_i387_struct elf_fpregset_t;
      18             : 
      19             : #ifdef __i386__
      20             : 
      21             : typedef struct user_fxsr_struct elf_fpxregset_t;
      22             : 
      23             : #define R_386_NONE      0
      24             : #define R_386_32        1
      25             : #define R_386_PC32      2
      26             : #define R_386_GOT32     3
      27             : #define R_386_PLT32     4
      28             : #define R_386_COPY      5
      29             : #define R_386_GLOB_DAT  6
      30             : #define R_386_JMP_SLOT  7
      31             : #define R_386_RELATIVE  8
      32             : #define R_386_GOTOFF    9
      33             : #define R_386_GOTPC     10
      34             : #define R_386_NUM       11
      35             : 
      36             : /*
      37             :  * These are used to set parameters in the core dumps.
      38             :  */
      39             : #define ELF_CLASS       ELFCLASS32
      40             : #define ELF_DATA        ELFDATA2LSB
      41             : #define ELF_ARCH        EM_386
      42             : 
      43             : #else
      44             : 
      45             : /* x86-64 relocation types */
      46             : #define R_X86_64_NONE           0       /* No reloc */
      47             : #define R_X86_64_64             1       /* Direct 64 bit  */
      48             : #define R_X86_64_PC32           2       /* PC relative 32 bit signed */
      49             : #define R_X86_64_GOT32          3       /* 32 bit GOT entry */
      50             : #define R_X86_64_PLT32          4       /* 32 bit PLT address */
      51             : #define R_X86_64_COPY           5       /* Copy symbol at runtime */
      52             : #define R_X86_64_GLOB_DAT       6       /* Create GOT entry */
      53             : #define R_X86_64_JUMP_SLOT      7       /* Create PLT entry */
      54             : #define R_X86_64_RELATIVE       8       /* Adjust by program base */
      55             : #define R_X86_64_GOTPCREL       9       /* 32 bit signed pc relative
      56             :                                            offset to GOT */
      57             : #define R_X86_64_32             10      /* Direct 32 bit zero extended */
      58             : #define R_X86_64_32S            11      /* Direct 32 bit sign extended */
      59             : #define R_X86_64_16             12      /* Direct 16 bit zero extended */
      60             : #define R_X86_64_PC16           13      /* 16 bit sign extended pc relative */
      61             : #define R_X86_64_8              14      /* Direct 8 bit sign extended  */
      62             : #define R_X86_64_PC8            15      /* 8 bit sign extended pc relative */
      63             : 
      64             : #define R_X86_64_NUM            16
      65             : 
      66             : /*
      67             :  * These are used to set parameters in the core dumps.
      68             :  */
      69             : #define ELF_CLASS       ELFCLASS64
      70             : #define ELF_DATA        ELFDATA2LSB
      71             : #define ELF_ARCH        EM_X86_64
      72             : 
      73             : #endif
      74             : 
      75             : #include <asm/vdso.h>
      76             : 
      77             : extern unsigned int vdso_enabled;
      78             : 
      79             : /*
      80             :  * This is used to ensure we don't load something for the wrong architecture.
      81             :  */
      82             : #define elf_check_arch_ia32(x) \
      83             :         (((x)->e_machine == EM_386) || ((x)->e_machine == EM_486))
      84             : 
      85             : #include <asm/processor.h>
      86             : #include <asm/system.h>
      87             : 
      88             : #ifdef CONFIG_X86_32
      89             : #include <asm/desc.h>
      90             : 
      91             : #define elf_check_arch(x)       elf_check_arch_ia32(x)
      92             : 
      93             : /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program starts %edx
      94             :    contains a pointer to a function which might be registered using `atexit'.
      95             :    This provides a mean for the dynamic linker to call DT_FINI functions for
      96             :    shared libraries that have been loaded before the code runs.
      97             : 
      98             :    A value of 0 tells we have no such handler.
      99             : 
     100             :    We might as well make sure everything else is cleared too (except for %esp),
     101             :    just to make things more deterministic.
     102             :  */
     103             : #define ELF_PLAT_INIT(_r, load_addr)            \
     104             :         do {                                    \
     105             :         _r->bx = 0; _r->cx = 0; _r->dx = 0;    \
     106             :         _r->si = 0; _r->di = 0; _r->bp = 0;    \
     107             :         _r->ax = 0;                          \
     108             : } while (0)
     109             : 
     110             : /*
     111             :  * regs is struct pt_regs, pr_reg is elf_gregset_t (which is
     112             :  * now struct_user_regs, they are different)
     113             :  */
     114             : 
     115             : #define ELF_CORE_COPY_REGS_COMMON(pr_reg, regs) \
     116             : do {                                            \
     117             :         pr_reg[0] = regs->bx;                        \
     118             :         pr_reg[1] = regs->cx;                        \
     119             :         pr_reg[2] = regs->dx;                        \
     120             :         pr_reg[3] = regs->si;                        \
     121             :         pr_reg[4] = regs->di;                        \
     122             :         pr_reg[5] = regs->bp;                        \
     123             :         pr_reg[6] = regs->ax;                        \
     124             :         pr_reg[7] = regs->ds & 0xffff;           \
     125             :         pr_reg[8] = regs->es & 0xffff;           \
     126             :         pr_reg[9] = regs->fs & 0xffff;           \
     127             :         pr_reg[11] = regs->orig_ax;          \
     128             :         pr_reg[12] = regs->ip;                       \
     129             :         pr_reg[13] = regs->cs & 0xffff;          \
     130             :         pr_reg[14] = regs->flags;            \
     131             :         pr_reg[15] = regs->sp;                       \
     132             :         pr_reg[16] = regs->ss & 0xffff;          \
     133             : } while (0);
     134             : 
     135             : #define ELF_CORE_COPY_REGS(pr_reg, regs)        \
     136             : do {                                            \
     137             :         ELF_CORE_COPY_REGS_COMMON(pr_reg, regs);\
     138             :         pr_reg[10] = get_user_gs(regs);         \
     139             : } while (0);
     140             : 
     141             : #define ELF_CORE_COPY_KERNEL_REGS(pr_reg, regs) \
     142             : do {                                            \
     143             :         ELF_CORE_COPY_REGS_COMMON(pr_reg, regs);\
     144             :         savesegment(gs, pr_reg[10]);            \
     145             : } while (0);
     146             : 
     147             : #define ELF_PLATFORM    (utsname()->machine)
     148             : #define set_personality_64bit() do { } while (0)
     149             : 
     150             : #else /* CONFIG_X86_32 */
     151             : 
     152             : /*
     153             :  * This is used to ensure we don't load something for the wrong architecture.
     154             :  */
     155             : #define elf_check_arch(x)                       \
     156             :         ((x)->e_machine == EM_X86_64)
     157             : 
     158             : #define compat_elf_check_arch(x)        elf_check_arch_ia32(x)
     159             : 
     160             : static inline void elf_common_init(struct thread_struct *t,
     161             :                                    struct pt_regs *regs, const u16 ds)
     162             : {
     163             :         regs->ax = regs->bx = regs->cx = regs->dx = 0;
     164             :         regs->si = regs->di = regs->bp = 0;
     165             :         regs->r8 = regs->r9 = regs->r10 = regs->r11 = 0;
     166             :         regs->r12 = regs->r13 = regs->r14 = regs->r15 = 0;
     167             :         t->fs = t->gs = 0;
     168             :         t->fsindex = t->gsindex = 0;
     169             :         t->ds = t->es = ds;
     170             : }
     171             : 
     172             : #define ELF_PLAT_INIT(_r, load_addr)                    \
     173             :         elf_common_init(&current->thread, _r, 0)
     174             : 
     175             : #define COMPAT_ELF_PLAT_INIT(regs, load_addr)           \
     176             :         elf_common_init(&current->thread, regs, __USER_DS)
     177             : 
     178             : void start_thread_ia32(struct pt_regs *regs, u32 new_ip, u32 new_sp);
     179             : #define compat_start_thread start_thread_ia32
     180             : 
     181             : void set_personality_ia32(void);
     182             : #define COMPAT_SET_PERSONALITY(ex) set_personality_ia32()
     183             : 
     184             : #define COMPAT_ELF_PLATFORM                     ("i686")
     185             : 
     186             : /*
     187             :  * regs is struct pt_regs, pr_reg is elf_gregset_t (which is
     188             :  * now struct_user_regs, they are different). Assumes current is the process
     189             :  * getting dumped.
     190             :  */
     191             : 
     192             : #define ELF_CORE_COPY_REGS(pr_reg, regs)                        \
     193             : do {                                                            \
     194             :         unsigned v;                                             \
     195             :         (pr_reg)[0] = (regs)->r15;                           \
     196             :         (pr_reg)[1] = (regs)->r14;                           \
     197             :         (pr_reg)[2] = (regs)->r13;                           \
     198             :         (pr_reg)[3] = (regs)->r12;                           \
     199             :         (pr_reg)[4] = (regs)->bp;                            \
     200             :         (pr_reg)[5] = (regs)->bx;                            \
     201             :         (pr_reg)[6] = (regs)->r11;                           \
     202             :         (pr_reg)[7] = (regs)->r10;                           \
     203             :         (pr_reg)[8] = (regs)->r9;                            \
     204             :         (pr_reg)[9] = (regs)->r8;                            \
     205             :         (pr_reg)[10] = (regs)->ax;                           \
     206             :         (pr_reg)[11] = (regs)->cx;                           \
     207             :         (pr_reg)[12] = (regs)->dx;                           \
     208             :         (pr_reg)[13] = (regs)->si;                           \
     209             :         (pr_reg)[14] = (regs)->di;                           \
     210             :         (pr_reg)[15] = (regs)->orig_ax;                              \
     211             :         (pr_reg)[16] = (regs)->ip;                           \
     212             :         (pr_reg)[17] = (regs)->cs;                           \
     213             :         (pr_reg)[18] = (regs)->flags;                                \
     214             :         (pr_reg)[19] = (regs)->sp;                           \
     215             :         (pr_reg)[20] = (regs)->ss;                           \
     216             :         (pr_reg)[21] = current->thread.fs;                   \
     217             :         (pr_reg)[22] = current->thread.gs;                   \
     218             :         asm("movl %%ds,%0" : "=r" (v)); (pr_reg)[23] = v;   \
     219             :         asm("movl %%es,%0" : "=r" (v)); (pr_reg)[24] = v;   \
     220             :         asm("movl %%fs,%0" : "=r" (v)); (pr_reg)[25] = v;   \
     221             :         asm("movl %%gs,%0" : "=r" (v)); (pr_reg)[26] = v;   \
     222             : } while (0);
     223             : 
     224             : /* I'm not sure if we can use '-' here */
     225             : #define ELF_PLATFORM       ("x86_64")
     226             : extern void set_personality_64bit(void);
     227             : extern unsigned int sysctl_vsyscall32;
     228             : extern int force_personality32;
     229           1 : 
     230             : #endif /* !CONFIG_X86_32 */
     231             : 
     232             : #define CORE_DUMP_USE_REGSET
     233             : #define ELF_EXEC_PAGESIZE       4096
     234             : 
     235             : /* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
     236             :    use of this is to invoke "./ld.so someprog" to test out a new version of
     237             :    the loader.  We need to make sure that it is out of the way of the program
     238             :    that it will "exec", and that there is sufficient room for the brk.  */
     239             : 
     240             : #define ELF_ET_DYN_BASE         (TASK_SIZE / 3 * 2)
     241             : 
     242             : /* This yields a mask that user programs can use to figure out what
     243             :    instruction set this CPU supports.  This could be done in user space,
     244             :    but it's not easy, and we've already done it here.  */
     245             : 
     246             : #define ELF_HWCAP               (boot_cpu_data.x86_capability[0])
     247             : 
     248             : /* This yields a string that ld.so will use to load implementation
     249             :    specific libraries for optimization.  This is more specific in
     250             :    intent than poking at uname or /proc/cpuinfo.
     251             : 
     252             :    For the moment, we have only optimizations for the Intel generations,
     253             :    but that could change... */
     254             : 
     255             : #define SET_PERSONALITY(ex) set_personality_64bit()
     256             : 
     257             : /*
     258             :  * An executable for which elf_read_implies_exec() returns TRUE will
     259             :  * have the READ_IMPLIES_EXEC personality flag set automatically.
     260             :  */
     261             : #define elf_read_implies_exec(ex, executable_stack)     \
     262             :         (executable_stack != EXSTACK_DISABLE_X)
     263             : 
     264             : struct task_struct;
     265             : 
     266             : #define ARCH_DLINFO_IA32(vdso_enabled)                                  \
     267             : do {                                                                    \
     268             :         if (vdso_enabled) {                                             \
     269             :                 NEW_AUX_ENT(AT_SYSINFO, VDSO_ENTRY);                    \
     270             :                 NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_CURRENT_BASE);        \
     271             :         }                                                               \
     272             : } while (0)
     273             : 
     274             : #ifdef CONFIG_X86_32
     275             : 
     276             : #define STACK_RND_MASK (0x7ff)
     277             : 
     278             : #define VDSO_HIGH_BASE          (__fix_to_virt(FIX_VDSO))
     279             : 
     280             : #define ARCH_DLINFO             ARCH_DLINFO_IA32(vdso_enabled)
     281             : 
     282             : /* update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT entries changes */
     283             : 
     284             : #else /* CONFIG_X86_32 */
     285             : 
     286             : #define VDSO_HIGH_BASE          0xffffe000U /* CONFIG_COMPAT_VDSO address */
     287             : 
     288             : /* 1GB for 64bit, 8MB for 32bit */
     289             : #define STACK_RND_MASK (test_thread_flag(TIF_IA32) ? 0x7ff : 0x3fffff)
     290             : 
     291             : #define ARCH_DLINFO                                                     \
     292             : do {                                                                    \
     293             :         if (vdso_enabled)                                               \
     294             :                 NEW_AUX_ENT(AT_SYSINFO_EHDR,                            \
     295             :                             (unsigned long)current->mm->context.vdso);    \
     296             : } while (0)
     297             : 
     298             : #define AT_SYSINFO              32
     299             : 
     300             : #define COMPAT_ARCH_DLINFO      ARCH_DLINFO_IA32(sysctl_vsyscall32)
     301             : 
     302             : #define COMPAT_ELF_ET_DYN_BASE  (TASK_UNMAPPED_BASE + 0x1000000)
     303             : 
     304             : #endif /* !CONFIG_X86_32 */
     305             : 
     306             : #define VDSO_CURRENT_BASE       ((unsigned long)current->mm->context.vdso)
     307             : 
     308             : #define VDSO_ENTRY                                                      \
     309             :         ((unsigned long)VDSO32_SYMBOL(VDSO_CURRENT_BASE, vsyscall))
     310             : 
     311             : struct linux_binprm;
     312             : 
     313             : #define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1
     314             : extern int arch_setup_additional_pages(struct linux_binprm *bprm,
     315             :                                        int uses_interp);
     316             : 
     317             : extern int syscall32_setup_pages(struct linux_binprm *, int exstack);
     318             : #define compat_arch_setup_additional_pages      syscall32_setup_pages
     319             : 
     320             : extern unsigned long arch_randomize_brk(struct mm_struct *mm);
     321             : #define arch_randomize_brk arch_randomize_brk
     322             : 
     323             : #endif /* _ASM_X86_ELF_H */

Generated by: LCOV version 1.10