WebSVN – HelenOS – Diff – /branches/dynload/uspace/lib/rtld/arch/ppc32/src/bootstrap.c


/*
 * Copyright (c) 2008 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup rtld rtld
 * @brief
 * @{
 */
/**
 * @file
 */
 
#include <elf_dyn.h>
#include <rtld.h>
#include <loader/pcb.h>
 
// for testing printf
#include <stdio.h>
 
void __main(pcb_t *pcb);
//void __io_init(void);
void __exit(void);
 
static void kputint(unsigned i)
{
/*  asm volatile (
        "mr %%r3, %0\n"
        "li %%r9, 31\n"
        "sc\n"
        :
        : "r" (i)
        : "%r3","%r9"
    ) ;*/
}
 
#define __L(ptr) ((uint32_t)(ptr) & 0x0000ffff)
#define __HA(ptr) ((uint32_t)(ptr) >> 16)
 
// ldis r11, .PLTtable@ha
static inline uint32_t _ldis(unsigned rD, uint16_t imm16)
{
    /* Special case of addis: ldis rD,SIMM == addis rD,0,SIMM */
    return 0x3C000000 | (rD << 21) | imm16;
}
 
static inline uint32_t _lwz(unsigned rD, uint16_t disp16, unsigned rA)
{
    return 0x80000000 | (rD << 21) | (rA << 16) | disp16;
}
 
static inline uint32_t _mtctr(unsigned rS)
{
    /* mtctr rD == mtspr 9, rD */
    return 0x7c0003a6 | (rS << 21) | (9/*CTR*/ << 16);
}
 
static inline uint32_t _bctr()
{
    /* bcctr 0x1f, 0 */
    return 0x4c000420 | (0x1f/*always*/ << 21);
}
 
/* branch */
static inline uint32_t _b(uint32_t *addr, uint32_t *location)
{
    uint32_t raddr = ((uint32_t)addr - (uint32_t)location) & 0x03fffffc;
    return 0x48000000 | raddr;
}
 
void test_func(void)
{
    kputint(-1);
    kputint(42);
    kputint(-1);
}
 
int test_var = 0x818283;
 
void __bootstrap(pcb_t *pcb);
 
void __bootstrap(pcb_t *pcb)
{
    unsigned bias;
    uint32_t *plt;
    elf_dyn_t *dynamic;
    void *dptr;
    unsigned dval;
    int i;
 
    size_t rel_entries;
    size_t r_offset;
    elf_word r_info;
    unsigned rel_type;
    elf_word sym_idx;
    uintptr_t sym_addr;
   
    elf_symbol_t *sym_table;
    elf_rela_t *rel_table;
    elf_rela_t *jmp_rel_table;
    size_t jmp_rel_entries;
    uint32_t a, res;
    uint32_t *r_ptr;
    uint32_t *_plt_ent;
 
    kputint(42);
 
    /* The program loader (iloader) kindly provided us with these */
    dynamic = pcb->rtld_dynamic;
    bias = pcb->rtld_bias;
 
    kputint(bias);
    kputint((unsigned)dynamic);
 
    /* parse DYNAMIC */
    plt = 0;
    sym_table = 0;
    rel_table = 0;
    rel_entries = 0;
    jmp_rel_table = 0;
    jmp_rel_entries = 0;
/*
    i = 0;
    while (dynamic[i].d_tag != 0) {
//      kputint((uintptr_t)&dynamic[i]);
//      kputint((uintptr_t)&(dynamic[i].d_tag));
//      kputint(dynamic[i].d_tag);
 
        dptr = (void *)(dynamic[i].d_un.d_val + bias);
        dval = dynamic[i].d_un.d_val;
 
//      kputint(0x10);
        register unsigned tag = dynamic[i].d_tag;
*/
        /*
         * Note that switches only work because we are using
         * -fno-jump-tables.
         */
/*      switch (tag) {
        case DT_PLTRELSZ: jmp_rel_entries = dval/sizeof(elf_rela_t); break;
        case DT_JMPREL: jmp_rel_table = dptr; break;
        case DT_PLTGOT:*/
            /* PLT address */
/*          plt = dptr; break;
        case DT_SYMTAB: sym_table = dptr; break;
        case DT_RELA: rel_table = dptr; break;
        case DT_RELASZ: rel_entries = dval / sizeof(elf_rela_t); break;
        default: break;
        }
*/
//      kputint(0x20);
/*
        ++i;
    }
   
    kputint(1);
    kputint((unsigned)sym_table);
    kputint((unsigned)rel_table);
    kputint((unsigned)rel_entries);
 
*/  /* Now relocate all our dynsyms */
    kputint(-1);
 
    // PLT entries start here. However, each occupies 2 words
//  _plt_ent = plt + 18;
 
    // By definition of the ppc ABI, there's 1:1 correspondence
    // between JMPREL entries and PLT entries
//  unsigned plt_n = jmp_rel_entries;
/*
    uint32_t *_plt_table;
    uint32_t *_plt_call;
    uint32_t *_plt_resolve;
 
    _plt_resolve = plt;
    _plt_call = plt + 6;
    _plt_table = plt + 18 + plt_n;
   
    for (i=0; i<rel_entries; i++) {
//      kputint(i);
        r_offset = rel_table[i].r_offset;
        r_info = rel_table[i].r_info;
        r_ptr = (uint32_t *)(r_offset + bias);
        a = rel_table[i].r_addend;
//      kputint(-2);
//      kputint(a);
//      kputint(ELF32_R_TYPE(r_info));
//      kputint(ELF32_R_SYM(r_info));
       
        rel_type = ELF32_R_TYPE(r_info);
 
//      kputint(rel_type);
//      kputint(r_offset);
 
        switch (rel_type) {
        case R_PPC_JMP_SLOT:
//          kputint(0xa);
            sym_idx = ELF32_R_SYM(r_info);
 
            sym_addr = sym_table[sym_idx].st_value + bias;
//          kputint(sym_idx);
//          kputint(sym_addr);
 
            // r_ptr should point to a plt entry...
            uint32_t pidx = (r_ptr - _plt_ent) / 2;
            if (pidx >= plt_n) {
                kputint(0xee00ee00);
                while(1);
            }
//          _plt_table[pidx] = sym_addr;
//          kputint(pidx);
            plt[18+2*pidx] = _b((void *)sym_addr, &plt[18+2*pidx]);
//          kputint(&plt[18]);
//          kputint(plt[18]);
//          while(1);
//          while(1);
            // *r_ptr = sym_addr;
 
            break;
 
        case R_PPC_ADDR32:
            kputint(0xb);
            sym_idx = ELF32_R_SYM(r_info);
 
            sym_addr = sym_table[sym_idx].st_value + bias;
            kputint(sym_idx);
            kputint(sym_addr);
 
            *r_ptr = a + sym_addr;
            break;
           
        case R_PPC_RELATIVE:
            kputint(0xc);
            *r_ptr = a + bias;
            break;
 
        case R_PPC_REL24:
            kputint(0xd);
            sym_idx = ELF32_R_SYM(r_info);
            sym_addr = sym_table[sym_idx].st_value + bias;
            kputint(sym_addr);
            res = (sym_addr - (uint32_t)r_ptr + a) >> 2;
            kputint(res);
            if (res & 0xff000000) {*/
                /* out of range?? */
/*              kputint(0xeeeeeeee);
                //while(1);
            }
            *r_ptr = (*r_ptr & ~0x00ffffff) | (res & 0x00ffffff);
            kputint(0x1d);
            break;
        }
    }
*/
    kputint(-3);
//  if (plt != 0) {
 
/* .PLTcall: */
//  plt[6] = _ldis(11, __HA(_plt_table));   // ldis r11, .PLTtable@ha
//  plt[7] = _lwz(11, __L(_plt_table), 11); // lwz r11, .PLTtable@l(r11)
//  plt[8] = _mtctr(11);            // mtctr r11
//  plt[9] = _bctr();
 
/* .PLTi, i = 0..N-1 */
/*  kputint(-4);
    for (i = 0; i < plt_n; ++i) {
        //_plt_table[i] == function address;
        plt[18+i] = _b(_plt_call, &plt[18+i]);  // b .PLTcall
    }
*/
//  kputint(-5);
//  kputint(_plt_table[0]);
//  }
 
//  kputint(-6);
    /* This will come in handy */
//  runtime_env.rtld_dynamic = dynamic;
//  runtime_env.rtld.bias = bias;
 
//  volatile int ff=1;
//  while(ff);
    kputint(-7);
    test_func();
    kputint(0x42);
    kputint(test_var);
//  while(1);
//  while(1);
    /* Init libc and run rtld main */
    kputint(0x22);
    __main(pcb);
 
//  kputint(33);
//  __io_init();
    kputint(-1);
    kputint(0x52);
//  printf("Hello, world! (from ppc rtld)\n");
    kputint(0x62);
//  while(1);
    kputint(34);
    _rtld_main();
    kputint(35);
    __exit();
 
    kputint(36);
}
 
/** @}
 */
 

Rev 3401	Rev 3554
1	/*	1	/*
2	* Copyright (c) 2008 Jiri Svoboda	2	* Copyright (c) 2008 Jiri Svoboda
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup rtld rtld	29	/** @addtogroup rtld rtld
30	* @brief	30	* @brief
31	* @{	31	* @{
32	*/	32	*/
33	/**	33	/**
34	* @file	34	* @file
35	*/	35	*/
36		36
37	#include <elf_dyn.h>	37	#include <elf_dyn.h>
38	#include <rtld.h>	38	#include <rtld.h>
39	#include <loader/pcb.h>	39	#include <loader/pcb.h>
40		40
41	// for testing printf	41	// for testing printf
42	#include <stdio.h>	42	#include <stdio.h>
43		43
44	void __main(pcb_t *pcb);	44	void __main(pcb_t *pcb);
45	//void __io_init(void);	45	//void __io_init(void);
46	void __exit(void);	46	void __exit(void);
47		47
48	static void kputint(unsigned i)	48	static void kputint(unsigned i)
49	{	49	{
50	asm volatile (	50	/* asm volatile (
51	"mr %%r3, %0\n"	51	"mr %%r3, %0\n"
52	"li %%r9, 31\n"	52	"li %%r9, 31\n"
53	"sc\n"	53	"sc\n"
54	:	54	:
55	: "r" (i)	55	: "r" (i)
56	: "%r3","%r9"	56	: "%r3","%r9"
57	) ;	57	) ;*/
58	}	58	}
59		59
60	#define __L(ptr) ((uint32_t)(ptr) & 0x0000ffff)	60	#define __L(ptr) ((uint32_t)(ptr) & 0x0000ffff)
61	#define __HA(ptr) ((uint32_t)(ptr) >> 16)	61	#define __HA(ptr) ((uint32_t)(ptr) >> 16)
62		62
63	// ldis r11, .PLTtable@ha	63	// ldis r11, .PLTtable@ha
64	static inline uint32_t _ldis(unsigned rD, uint16_t imm16)	64	static inline uint32_t _ldis(unsigned rD, uint16_t imm16)
65	{	65	{
66	/* Special case of addis: ldis rD,SIMM == addis rD,0,SIMM */	66	/* Special case of addis: ldis rD,SIMM == addis rD,0,SIMM */
67	return 0x3C000000 \| (rD << 21) \| imm16;	67	return 0x3C000000 \| (rD << 21) \| imm16;
68	}	68	}
69		69
70	static inline uint32_t _lwz(unsigned rD, uint16_t disp16, unsigned rA)	70	static inline uint32_t _lwz(unsigned rD, uint16_t disp16, unsigned rA)
71	{	71	{
72	return 0x80000000 \| (rD << 21) \| (rA << 16) \| disp16;	72	return 0x80000000 \| (rD << 21) \| (rA << 16) \| disp16;
73	}	73	}
74		74
75	static inline uint32_t _mtctr(unsigned rS)	75	static inline uint32_t _mtctr(unsigned rS)
76	{	76	{
77	/* mtctr rD == mtspr 9, rD */	77	/* mtctr rD == mtspr 9, rD */
78	return 0x7c0003a6 \| (rS << 21) \| (9/CTR/ << 16);	78	return 0x7c0003a6 \| (rS << 21) \| (9/CTR/ << 16);
79	}	79	}
80		80
81	static inline uint32_t _bctr()	81	static inline uint32_t _bctr()
82	{	82	{
83	/* bcctr 0x1f, 0 */	83	/* bcctr 0x1f, 0 */
84	return 0x4c000420 \| (0x1f/always/ << 21);	84	return 0x4c000420 \| (0x1f/always/ << 21);
85	}	85	}
86		86
87	/* branch */	87	/* branch */
88	static inline uint32_t _b(uint32_t addr, uint32_t location)	88	static inline uint32_t _b(uint32_t addr, uint32_t location)
89	{	89	{
90	uint32_t raddr = ((uint32_t)addr - (uint32_t)location) & 0x03fffffc;	90	uint32_t raddr = ((uint32_t)addr - (uint32_t)location) & 0x03fffffc;
91	return 0x48000000 \| raddr;	91	return 0x48000000 \| raddr;
92	}	92	}
93		93
94	void test_func(void)	94	void test_func(void)
95	{	95	{
96	kputint(-1);	96	kputint(-1);
97	kputint(42);	97	kputint(42);
98	kputint(-1);	98	kputint(-1);
99	}	99	}
100		100
101	int test_var = 0x818283;	101	int test_var = 0x818283;
102		102
103	void __bootstrap(pcb_t *pcb);	103	void __bootstrap(pcb_t *pcb);
104		104
105	void __bootstrap(pcb_t *pcb)	105	void __bootstrap(pcb_t *pcb)
106	{	106	{
107	unsigned bias;	107	unsigned bias;
108	uint32_t *plt;	108	uint32_t *plt;
109	elf_dyn_t *dynamic;	109	elf_dyn_t *dynamic;
110	void *dptr;	110	void *dptr;
111	unsigned dval;	111	unsigned dval;
112	int i;	112	int i;
113		113
114	size_t rel_entries;	114	size_t rel_entries;
115	size_t r_offset;	115	size_t r_offset;
116	elf_word r_info;	116	elf_word r_info;
117	unsigned rel_type;	117	unsigned rel_type;
118	elf_word sym_idx;	118	elf_word sym_idx;
119	uintptr_t sym_addr;	119	uintptr_t sym_addr;
120		120
121	elf_symbol_t *sym_table;	121	elf_symbol_t *sym_table;
122	elf_rela_t *rel_table;	122	elf_rela_t *rel_table;
123	elf_rela_t *jmp_rel_table;	123	elf_rela_t *jmp_rel_table;
124	size_t jmp_rel_entries;	124	size_t jmp_rel_entries;
125	uint32_t a, res;	125	uint32_t a, res;
126	uint32_t *r_ptr;	126	uint32_t *r_ptr;
127	uint32_t *_plt_ent;	127	uint32_t *_plt_ent;
128		128
129	kputint(42);	129	kputint(42);
130		130
131	/* The program loader (iloader) kindly provided us with these */	131	/* The program loader (iloader) kindly provided us with these */
132	dynamic = pcb->rtld_dynamic;	132	dynamic = pcb->rtld_dynamic;
133	bias = pcb->rtld_bias;	133	bias = pcb->rtld_bias;
134		134
135	kputint(bias);	135	kputint(bias);
136	kputint((unsigned)dynamic);	136	kputint((unsigned)dynamic);
137		137
138	/* parse DYNAMIC */	138	/* parse DYNAMIC */
139	plt = 0;	139	plt = 0;
140	sym_table = 0;	140	sym_table = 0;
141	rel_table = 0;	141	rel_table = 0;
142	rel_entries = 0;	142	rel_entries = 0;
143	jmp_rel_table = 0;	143	jmp_rel_table = 0;
144	jmp_rel_entries = 0;	144	jmp_rel_entries = 0;
145		145	/*
146	i = 0;	146	i = 0;
147	while (dynamic[i].d_tag != 0) {	147	while (dynamic[i].d_tag != 0) {
148	// kputint((uintptr_t)&dynamic[i]);	148	// kputint((uintptr_t)&dynamic[i]);
149	// kputint((uintptr_t)&(dynamic[i].d_tag));	149	// kputint((uintptr_t)&(dynamic[i].d_tag));
150	// kputint(dynamic[i].d_tag);	150	// kputint(dynamic[i].d_tag);
151		151
152	dptr = (void *)(dynamic[i].d_un.d_val + bias);	152	dptr = (void *)(dynamic[i].d_un.d_val + bias);
153	dval = dynamic[i].d_un.d_val;	153	dval = dynamic[i].d_un.d_val;
154		154
155	// kputint(0x10);	155	// kputint(0x10);
156	register unsigned tag = dynamic[i].d_tag;	156	register unsigned tag = dynamic[i].d_tag;
157		157	*/
158	/*	158	/*
159	* Note that switches only work because we are using	159	* Note that switches only work because we are using
160	* -fno-jump-tables.	160	* -fno-jump-tables.
161	*/	161	*/
162	switch (tag) {	162	/* switch (tag) {
163	case DT_PLTRELSZ: jmp_rel_entries = dval/sizeof(elf_rela_t); break;	163	case DT_PLTRELSZ: jmp_rel_entries = dval/sizeof(elf_rela_t); break;
164	case DT_JMPREL: jmp_rel_table = dptr; break;	164	case DT_JMPREL: jmp_rel_table = dptr; break;
165	case DT_PLTGOT:	165	case DT_PLTGOT:*/
166	/* PLT address */	166	/* PLT address */
167	plt = dptr; break;	167	/* plt = dptr; break;
168	case DT_SYMTAB: sym_table = dptr; break;	168	case DT_SYMTAB: sym_table = dptr; break;
169	case DT_RELA: rel_table = dptr; break;	169	case DT_RELA: rel_table = dptr; break;
170	case DT_RELASZ: rel_entries = dval / sizeof(elf_rela_t); break;	170	case DT_RELASZ: rel_entries = dval / sizeof(elf_rela_t); break;
171	default: break;	171	default: break;
172	}	172	}
173		173	*/
174	// kputint(0x20);	174	// kputint(0x20);
175		175	/*
176	++i;	176	++i;
177	}	177	}
178		178
179	kputint(1);	179	kputint(1);
180	kputint((unsigned)sym_table);	180	kputint((unsigned)sym_table);
181	kputint((unsigned)rel_table);	181	kputint((unsigned)rel_table);
182	kputint((unsigned)rel_entries);	182	kputint((unsigned)rel_entries);
183		183
184	/* Now relocate all our dynsyms */	184	/ / Now relocate all our dynsyms */
185	kputint(-1);	185	kputint(-1);
186		186
187	// PLT entries start here. However, each occupies 2 words	187	// PLT entries start here. However, each occupies 2 words
188	_plt_ent = plt + 18;	188	// _plt_ent = plt + 18;
189		189
190	// By definition of the ppc ABI, there's 1:1 correspondence	190	// By definition of the ppc ABI, there's 1:1 correspondence
191	// between JMPREL entries and PLT entries	191	// between JMPREL entries and PLT entries
192	unsigned plt_n = jmp_rel_entries;	192	// unsigned plt_n = jmp_rel_entries;
193		193	/*
194	uint32_t *_plt_table;	194	uint32_t *_plt_table;
195	uint32_t *_plt_call;	195	uint32_t *_plt_call;
196	uint32_t *_plt_resolve;	196	uint32_t *_plt_resolve;
197		197
198	_plt_resolve = plt;	198	_plt_resolve = plt;
199	_plt_call = plt + 6;	199	_plt_call = plt + 6;
200	_plt_table = plt + 18 + plt_n;	200	_plt_table = plt + 18 + plt_n;
201		201
202	for (i=0; i<rel_entries; i++) {	202	for (i=0; i<rel_entries; i++) {
203	// kputint(i);	203	// kputint(i);
204	r_offset = rel_table[i].r_offset;	204	r_offset = rel_table[i].r_offset;
205	r_info = rel_table[i].r_info;	205	r_info = rel_table[i].r_info;
206	r_ptr = (uint32_t *)(r_offset + bias);	206	r_ptr = (uint32_t *)(r_offset + bias);
207	a = rel_table[i].r_addend;	207	a = rel_table[i].r_addend;
208	// kputint(-2);	208	// kputint(-2);
209	// kputint(a);	209	// kputint(a);
210	// kputint(ELF32_R_TYPE(r_info));	210	// kputint(ELF32_R_TYPE(r_info));
211	// kputint(ELF32_R_SYM(r_info));	211	// kputint(ELF32_R_SYM(r_info));
212		212
213	rel_type = ELF32_R_TYPE(r_info);	213	rel_type = ELF32_R_TYPE(r_info);
214		214
215	// kputint(rel_type);	215	// kputint(rel_type);
216	// kputint(r_offset);	216	// kputint(r_offset);
217		217
218	switch (rel_type) {	218	switch (rel_type) {
219	case R_PPC_JMP_SLOT:	219	case R_PPC_JMP_SLOT:
220	// kputint(0xa);	220	// kputint(0xa);
221	sym_idx = ELF32_R_SYM(r_info);	221	sym_idx = ELF32_R_SYM(r_info);
222		222
223	sym_addr = sym_table[sym_idx].st_value + bias;	223	sym_addr = sym_table[sym_idx].st_value + bias;
224	// kputint(sym_idx);	224	// kputint(sym_idx);
225	// kputint(sym_addr);	225	// kputint(sym_addr);
226		226
227	// r_ptr should point to a plt entry...	227	// r_ptr should point to a plt entry...
228	uint32_t pidx = (r_ptr - _plt_ent) / 2;	228	uint32_t pidx = (r_ptr - _plt_ent) / 2;
229	if (pidx >= plt_n) {	229	if (pidx >= plt_n) {
230	kputint(0xee00ee00);	230	kputint(0xee00ee00);
231	while(1);	231	while(1);
232	}	232	}
233	// _plt_table[pidx] = sym_addr;	233	// _plt_table[pidx] = sym_addr;
234	// kputint(pidx);	234	// kputint(pidx);
235	plt[18+2pidx] = _b((void )sym_addr, &plt[18+2*pidx]);	235	plt[18+2pidx] = _b((void )sym_addr, &plt[18+2*pidx]);
236	// kputint(&plt[18]);	236	// kputint(&plt[18]);
237	// kputint(plt[18]);	237	// kputint(plt[18]);
238	// while(1);	238	// while(1);
239	// while(1);	239	// while(1);
240	//*r_ptr = sym_addr;	240	// *r_ptr = sym_addr;
241		241
242	break;	242	break;
243		243
244	case R_PPC_ADDR32:	244	case R_PPC_ADDR32:
245	kputint(0xb);	245	kputint(0xb);
246	sym_idx = ELF32_R_SYM(r_info);	246	sym_idx = ELF32_R_SYM(r_info);
247		247
248	sym_addr = sym_table[sym_idx].st_value + bias;	248	sym_addr = sym_table[sym_idx].st_value + bias;
249	kputint(sym_idx);	249	kputint(sym_idx);
250	kputint(sym_addr);	250	kputint(sym_addr);
251		251
252	*r_ptr = a + sym_addr;	252	*r_ptr = a + sym_addr;
253	break;	253	break;
254		254
255	case R_PPC_RELATIVE:	255	case R_PPC_RELATIVE:
256	kputint(0xc);	256	kputint(0xc);
257	*r_ptr = a + bias;	257	*r_ptr = a + bias;
258	break;	258	break;
259		259
260	case R_PPC_REL24:	260	case R_PPC_REL24:
261	kputint(0xd);	261	kputint(0xd);
262	sym_idx = ELF32_R_SYM(r_info);	262	sym_idx = ELF32_R_SYM(r_info);
263	sym_addr = sym_table[sym_idx].st_value + bias;	263	sym_addr = sym_table[sym_idx].st_value + bias;
264	kputint(sym_addr);	264	kputint(sym_addr);
265	res = (sym_addr - (uint32_t)r_ptr + a) >> 2;	265	res = (sym_addr - (uint32_t)r_ptr + a) >> 2;
266	kputint(res);	266	kputint(res);
267	if (res & 0xff000000) {	267	if (res & 0xff000000) {*/
268	/* out of range?? */	268	/* out of range?? */
269	kputint(0xeeeeeeee);	269	/* kputint(0xeeeeeeee);
270	//while(1);	270	//while(1);
271	}	271	}
272	r_ptr = (r_ptr & ~0x00ffffff) \| (res & 0x00ffffff);	272	r_ptr = (r_ptr & ~0x00ffffff) \| (res & 0x00ffffff);
273	kputint(0x1d);	273	kputint(0x1d);
274	break;	274	break;
275	}	275	}
276	}	276	}
277		277	*/
278	kputint(-3);	278	kputint(-3);
279	if (plt != 0) {	279	// if (plt != 0) {
280		280
281	/* .PLTcall: */	281	/* .PLTcall: */
282	plt[6] = _ldis(11, __HA(_plt_table)); // ldis r11, .PLTtable@ha	282	// plt[6] = _ldis(11, __HA(_plt_table)); // ldis r11, .PLTtable@ha
283	plt[7] = _lwz(11, __L(_plt_table), 11); // lwz r11, .PLTtable@l(r11)	283	// plt[7] = _lwz(11, __L(_plt_table), 11); // lwz r11, .PLTtable@l(r11)
284	plt[8] = _mtctr(11); // mtctr r11	284	// plt[8] = _mtctr(11); // mtctr r11
285	plt[9] = _bctr();	285	// plt[9] = _bctr();
286		286
287	/* .PLTi, i = 0..N-1 */	287	/* .PLTi, i = 0..N-1 */
288	/* kputint(-4);	288	/* kputint(-4);
289	for (i = 0; i < plt_n; ++i) {	289	for (i = 0; i < plt_n; ++i) {
290	//_plt_table[i] == function address;	290	//_plt_table[i] == function address;
291	plt[18+i] = _b(_plt_call, &plt[18+i]); // b .PLTcall	291	plt[18+i] = _b(_plt_call, &plt[18+i]); // b .PLTcall
292	}	292	}
293	*/	293	*/
294	kputint(-5);	294	// kputint(-5);
295	kputint(_plt_table[0]);	295	// kputint(_plt_table[0]);
296	}	296	// }
297		297
298	kputint(-6);	298	// kputint(-6);
299	/* This will come in handy */	299	/* This will come in handy */
300	runtime_env.rtld_dynamic = dynamic;	300	// runtime_env.rtld_dynamic = dynamic;
301	runtime_env.rtld.bias = bias;	301	// runtime_env.rtld.bias = bias;
302		302
303	// volatile int ff=1;	303	// volatile int ff=1;
304	// while(ff);	304	// while(ff);
305	kputint(-7);	305	kputint(-7);
306	test_func();	306	test_func();
307	kputint(0x42);	307	kputint(0x42);
308	kputint(test_var);	308	kputint(test_var);
309	// while(1);	309	// while(1);
310	// while(1);	310	// while(1);
311	/* Init libc and run rtld main */	311	/* Init libc and run rtld main */
312	kputint(0x22);	312	kputint(0x22);
313	__main(pcb);	313	__main(pcb);
314		314
315	// kputint(33);	315	// kputint(33);
316	// __io_init();	316	// __io_init();
317	kputint(-1);	317	kputint(-1);
318	kputint(0x52);	318	kputint(0x52);
319	// printf("Hello, world! (from ppc rtld)\n");	319	// printf("Hello, world! (from ppc rtld)\n");
320	kputint(0x62);	320	kputint(0x62);
321	// while(1);	321	// while(1);
322	kputint(34);	322	kputint(34);
323	_rtld_main();	323	_rtld_main();
324	kputint(35);	324	kputint(35);
325	__exit();	325	__exit();
326		326
327	kputint(36);	327	kputint(36);
328	}	328	}
329		329
330	/** @}	330	/** @}
331	*/	331	*/
332		332

Subversion Repositories HelenOS

(root)/branches/dynload/uspace/lib/rtld/arch/ppc32/src/bootstrap.c – Rev 3401 → 3554