Subversion Repositories Kolibri OS

Rev

Rev 6443 | Rev 8154 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
145 halyavin 1
/*
2
 *  TCCMEOS.C - KolibriOS/MenuetOS file output for the TinyC Compiler
6441 siemargl 3
 *
145 halyavin 4
 *  Copyright (c) 2006 Andrey Khalyavin
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
609 andrew_pro 19
 */
20
 
21
typedef struct {
22
	char magic[8];
23
	int version;
24
	int entry_point;
25
	int image_size;
26
	int memory_size;
27
	int stack;
28
	int params;
29
	int argv;
30
} IMAGE_MEOS_FILE_HEADER,*PIMAGE_MEOS_FILE_HEADER;
31
typedef struct _meos_section_info{
32
	int sh_addr;
33
	void* data;
34
	int data_size;
35
	int sec_num;
36
	struct _meos_section_info* next;
37
} meos_section_info;
38
typedef struct {
39
	TCCState* s1;
40
	IMAGE_MEOS_FILE_HEADER header;
41
	meos_section_info* code_sections;
42
	meos_section_info* data_sections;
43
	meos_section_info* bss_sections;
44
} me_info;
45
 
6441 siemargl 46
int tcc_output_dbgme(const char *filename, me_info* me);
47
 
48
 
609 andrew_pro 49
meos_section_info* findsection(me_info* me,int num)
50
{
51
	meos_section_info* si;
52
	for(si=me->code_sections;si;si=si->next)
53
	{
54
		if (si->sec_num==num)
55
			return si;
56
	}
57
	for (si=me->data_sections;si;si=si->next)
58
	{
59
		if (si->sec_num==num)
60
			return si;
61
	}
62
	for (si=me->bss_sections;si;si=si->next)
63
	{
64
		if (si->sec_num==num)
65
			return si;
66
	}
67
	return (meos_section_info*)0;
68
}
69
 
70
void build_reloc(me_info* me)
71
{
72
	int flag;
6441 siemargl 73
	Elf32_Rel *rel = 0, *rel_ = 0, *rel_end = 0;
609 andrew_pro 74
	Section *sr;
75
	meos_section_info* s;
76
	meos_section_info* ss;
77
	s=me->code_sections;
78
	rel=0;
79
	rel_end=0;
80
	flag=0;
81
	for(;;)
82
	{
83
		sr=me->s1->sections[s->sec_num]->reloc;
84
		if (sr)
85
		{
145 halyavin 86
			rel = (Elf32_Rel *) sr->data;
609 andrew_pro 87
			rel_end = (Elf32_Rel *) (sr->data + sr->data_offset);
88
		}
89
		rel_=rel;
90
		while (rel_
91
			rel=rel_;
92
			int type = ELF32_R_TYPE(rel->r_info);
93
			rel_=rel+1;
145 halyavin 94
			if (type != R_386_PC32 && type != R_386_32)
609 andrew_pro 95
				continue;
96
			int sym = ELF32_R_SYM(rel->r_info);
97
			if (sym>symtab_section->data_offset/sizeof(Elf32_Sym))
98
				continue;
99
			Elf32_Sym* esym = ((Elf32_Sym *)symtab_section->data)+sym;
100
			int sect=esym->st_shndx;
101
			ss=findsection(me,sect);
6441 siemargl 102
			if (ss==0)
6429 siemargl 103
			{
104
            	const char *sym_name = strtab_section->data + esym->st_name;
105
    			tcc_error_noabort("undefined symbol '%s'", sym_name);
106
				continue;
107
			}
609 andrew_pro 108
			if (rel->r_offset>s->data_size)
109
				continue;
110
			if (type==R_386_PC32)
111
				*(int*)(rel->r_offset+s->data)+=ss->sh_addr+esym->st_value-rel->r_offset-s->sh_addr;
112
			else if (type==R_386_32)
113
				*(int*)(rel->r_offset+s->data)+=ss->sh_addr+esym->st_value;
114
		}
115
        rel=rel_;
116
		s=s->next;
6441 siemargl 117
		if (s==0) // what about multiple BSS sections ?
609 andrew_pro 118
		{
119
			if (flag) break;
120
			s=me->data_sections;
121
			if (s==0) break;
122
			flag=1;
123
			continue;
124
		}
125
	}
126
}
127
 
128
void assign_addresses(me_info* me)
129
{
130
	int i;
131
	meos_section_info* si;
132
	for (i=1;is1->nb_sections;i++)
133
	{
134
		Section* s=me->s1->sections[i];
135
		if (strcmp(".text",s->name)==0)
136
		{
137
			si=tcc_malloc(sizeof(meos_section_info));
138
			si->data=s->data;
139
			si->data_size=s->data_offset;
140
			si->next=me->code_sections;
141
			si->sec_num=i;
142
			me->code_sections=si;
143
			continue;
144
		}
145
		if (strcmp(".data",s->name)==0)
146
		{
147
			si=tcc_malloc(sizeof(meos_section_info));
148
			si->data=s->data;
149
			si->data_size=s->data_offset;
150
			si->next=me->data_sections;
151
			si->sec_num=i;
152
			me->data_sections=si;
153
			continue;
154
		}
155
		if (strcmp(".bss",s->name)==0)
156
		{
157
			si=tcc_malloc(sizeof(meos_section_info));
6441 siemargl 158
			si->data=s->data;
609 andrew_pro 159
			si->data_size=s->data_offset;
160
			si->next=me->bss_sections;
161
			si->sec_num=i;
162
			me->bss_sections=si;
163
			continue;
164
		}
165
	}
166
	int addr;
167
	addr=sizeof(IMAGE_MEOS_FILE_HEADER);
168
	for (si=me->code_sections;si;si=si->next)
169
	{
170
		si->sh_addr=addr;
171
		addr+=si->data_size;
172
	}
173
	for (si=me->data_sections;si;si=si->next)
174
	{
175
		si->sh_addr=addr;
176
		addr+=si->data_size;
177
	}
178
	me->header.image_size=addr;
179
	for (si=me->bss_sections;si;si=si->next)
180
	{
181
		si->sh_addr=addr;
182
		addr+=si->data_size;
6441 siemargl 183
	}
184
	if (me->s1->pe_stack_size < 4096)
185
        addr+=4096;
186
    else
187
        addr += me->s1->pe_stack_size;
609 andrew_pro 188
	addr=(addr+4)&(~3);
189
	me->header.stack=addr;
190
	me->header.memory_size=addr;
191
	build_reloc(me);
192
}
6429 siemargl 193
 
194
 
6441 siemargl 195
const char *tcc_get_symbol_name(int st_name)
6429 siemargl 196
// return string by index from stringtable section
197
{
198
	const char *sym_name = strtab_section->data + st_name;
199
	return sym_name;
200
}
201
 
609 andrew_pro 202
int tcc_find_symbol_me(me_info* me, const char *sym_name)
203
{
204
	int i;
205
	int symtab;
206
	int strtab;
207
	symtab=0;
208
	strtab=0;
209
	for (i=1;is1->nb_sections;i++)
210
	{
211
		Section* s;
212
		s=me->s1->sections[i];
213
		if (strcmp(s->name,".symtab")==0)
214
		{
215
			symtab=i;
216
		}
217
		if (strcmp(s->name,".strtab")==0)
218
		{
219
			strtab=i;
220
		}
221
	}
222
	if (symtab==0 || strtab==0)
6429 siemargl 223
	{
224
        tcc_error_noabort("undefined sections .symtab or .strtab on linking '%s'", sym_name);
609 andrew_pro 225
		return 0;
6429 siemargl 226
	}
609 andrew_pro 227
	Elf32_Sym* s,*se;
228
	char* name;
229
	s=(Elf32_Sym*)me->s1->sections[symtab]->data;
230
	se=(Elf32_Sym*)(((void*)s)+me->s1->sections[symtab]->data_offset);
231
	name=(char*)me->s1->sections[strtab]->data;
232
	while (s
233
	{
234
		if (strcmp(name+s->st_name,sym_name)==0)
235
		{
236
			return s->st_value+findsection(me,s->st_shndx)->sh_addr;
237
		}
238
		s++;
239
	}
6429 siemargl 240
    tcc_error_noabort("undefined symbol '%s'", sym_name);
609 andrew_pro 241
	return 0;
242
}
6429 siemargl 243
 
609 andrew_pro 244
const char* me_magic="MENUET01";
245
int tcc_output_me(TCCState* s1,const char *filename)
246
{
247
	me_info me;
248
    int i;
249
    FILE* f;
250
    //printf("%d\n",s1->nb_sections);
251
	memset(&me,0,sizeof(me));
252
	me.s1=s1;
253
	relocate_common_syms();
254
	assign_addresses(&me);
6441 siemargl 255
 
256
	if (s1->do_debug)
257
		tcc_output_dbgme(filename, &me);
258
 
609 andrew_pro 259
	me.header.entry_point=tcc_find_symbol_me(&me,"start");
260
	me.header.params= tcc_find_symbol_me(&me,"__argv"); // <--
261
	me.header.argv= tcc_find_symbol_me(&me,"__path"); // <--
6441 siemargl 262
 
609 andrew_pro 263
	f=fopen(filename,"wb");
264
    for (i=0;i<8;i++)
265
        me.header.magic[i]=me_magic[i];
266
	/*me.header.magic[0]='M';me.header.magic[1]='E';
267
	me.header.magic[2]='N';me.header.magic[3]='U';
268
	me.header.magic[4]='E';me.header.magic[5]='T';
269
	me.header.magic[6]='0';me.header.magic[7]='1';*/
270
	fwrite(&me.header,1,sizeof(IMAGE_MEOS_FILE_HEADER),f);
271
	meos_section_info* si;
272
	for(si=me.code_sections;si;si=si->next)
273
		fwrite(si->data,1,si->data_size,f);
274
	for (si=me.data_sections;si;si=si->next)
6441 siemargl 275
		fwrite(si->data,1,si->data_size,f);
276
	for (si=me.bss_sections;si;si=si->next)
6858 siemargl 277
	{
278
    	if (si->data == NULL)
279
		{
280
//         	printf("\nError! BSS data is NULL! size:%i",(int)si->data_size);
281
         	si->data = calloc(si->data_size, 1);
282
      	}
283
		fwrite(si->data, 1, si->data_size, f);
284
	}
6441 siemargl 285
/*
286
    if (me.bss_sections) // Siemargl testin, what we lose
287
    {
288
        tcc_error_noabort("We lose .BSS section when linking KOS32 executable");
289
    }
290
*/
609 andrew_pro 291
	fclose(f);
292
	return 0;
293
}
6429 siemargl 294
 
295
#ifndef _WIN32
296
 
297
static inline int get_current_folder(char* buf, int bufsize){
298
    register int val;
299
    asm volatile ("int $0x40":"=a"(val):"a"(30), "b"(2), "c"(buf), "d"(bufsize));
300
    return val;
301
}
302
 
303
 
304
char *getcwd(char *buf, size_t size)
305
{
306
	int rc = get_current_folder(buf, size);
307
	if (rc > size)
308
	{
309
		errno = ERANGE;
310
		return 0;
311
	}
312
	else
313
		return buf;
314
}
315
 
316
#endif
6441 siemargl 317
 
318
 
319
static FILE *src_file;
320
static int next_src_line;
321
 
322
void close_source_file()
323
{
324
    if (src_file)
325
        fclose(src_file);
326
    src_file = NULL;
327
}
328
 
329
void load_source_file(char *fname)
330
{
331
    close_source_file();
332
    src_file = fopen(fname,"rt");
333
	if (!src_file) return;
334
	next_src_line = 1;
335
}
336
 
337
int get_src_lines(char *buf, int sz, int start, int end)
338
// 1 if read
339
{
340
    char line[255], *ch;
341
    strcpy(buf, "");
342
	if (!src_file) return 0;
343
    while (next_src_line < start) // skip
344
    {
345
        ch = fgets(line, sizeof line, src_file);
346
        if (!ch) return 0;
347
        next_src_line++;
348
    }
349
    while (next_src_line <= end)
350
    {
351
        ch = fgets(line, sizeof line, src_file);
352
        if (!ch) return 0;
353
        next_src_line++;
354
        strncat(buf, line, sz - strlen(buf) - 1);
355
    }
356
    // remove newlines
357
    for (ch = buf; *ch; ch++)
358
        if (strchr("\t\n\r", *ch)) *ch = ' ';
359
 
360
    return 1;
361
}
362
 
363
int tcc_output_dbgme(const char *filename, me_info* me)
364
// by Siemargl. Writes filename.dbg file for source code level debuggin with MTDBG
365
// return 1 on error
366
{
367
	FILE 	*fdbg;
6443 siemargl 368
	char	fname[400],
369
            buf[80]; // no more fits in mtdbg string
6441 siemargl 370
 
371
	strcpy(fname, filename);
372
	strcat(fname, ".dbg");
373
	fdbg = fopen(fname,"wt");
374
	if (!fdbg) return 1;
375
 
376
	meos_section_info *si, *ss;
377
    fputs(".text\n", fdbg); // just for mtbg
378
 
379
    // print symbol table with resolved addresses
380
    Elf32_Sym* esym;
381
    for (esym = (Elf32_Sym*)symtab_section->data; esym <= (Elf32_Sym*)(symtab_section->data + symtab_section->data_offset); esym++)
382
    {
383
        if (esym->st_info == 0 || esym->st_info == 4) continue;
384
        int sect = esym->st_shndx;
385
        ss = findsection(me, sect);
386
        const char *sym_name = strtab_section->data + esym->st_name;
387
        if (ss == 0)
388
        {
389
            fprintf(fdbg, "undefined symbol '%s' type(%d)\n", sym_name, esym->st_info);
390
            continue;
391
        }
392
        fprintf(fdbg, "0x%X %s\n", ss->sh_addr + esym->st_value, sym_name); // removed type(%d)   esym->st_info
393
    }
394
 
395
    fputs(".text source code links\n", fdbg); // just for mtbg
396
    // print symbol table with resolved addresses
397
    Stab_Sym *stab;
398
    char    *str = "", *cur_file = "???", cur_fun[255];
399
    int cur_line = 0, cur_fun_addr = 0, fun_flag = 0;
400
    strcpy(cur_fun, "fn???");
401
    for (stab = (Stab_Sym*)stab_section->data; stab <= (Stab_Sym*)(stab_section->data + stab_section->data_offset); stab++)
402
    {
403
        str = "";
404
        switch(stab->n_type)
405
        {
406
        case 100:   // source file, or path
407
            if (stab->n_strx)
408
            {
409
                cur_file = stabstr_section->data + stab->n_strx;
410
                load_source_file(cur_file);
411
            }
412
            else
413
                cur_file = "???";
414
            strcpy(cur_fun, "fn???");
415
            cur_line = 0;
416
            cur_fun_addr = 0;
417
            fun_flag = 0;
418
            break;
419
        case 36:    // func
420
            cur_fun_addr = 0;
421
            if (stab->n_strx)
422
            {
423
                strcpy(cur_fun, stabstr_section->data + stab->n_strx);
424
                str = strchr(cur_fun, ':');
425
                if (str) *str = '\0';
426
                cur_fun_addr = tcc_find_symbol_me(me, cur_fun);
427
                cur_line = stab->n_desc;
428
                fun_flag = 1;
429
                //fprintf(fdbg, "0x%X %s() line(%d)\n", cur_fun_addr, cur_fun, cur_line); // commented as conflicted with direct address
430
            }
431
            else
432
                strcpy(cur_fun, "fn???");
433
            break;
434
        case 68:    // N_SLINE
435
            if (stab->n_value == 0 ) continue;  // skip zero offset line
436
            if (fun_flag) // skip string {, as duplicates address
437
            {
438
                fun_flag = 0;
439
                continue;
440
            }
441
 
442
            int line;
443
            if (stab->n_desc > cur_line)
444
                line = cur_line + 1;
445
            else
446
                line = cur_line;
447
            //fprintf(fdbg, "0x%X LINES %d-%d \n", cur_fun_addr + stab->n_value, line,  stab->n_desc);
448
            if (get_src_lines(buf, sizeof buf, line, stab->n_desc))
449
                fprintf(fdbg, "0x%X %s\n", cur_fun_addr + stab->n_value, buf);
450
 
451
            cur_line = stab->n_desc;
452
            break;
453
        default:
454
            continue;
455
        }
456
/*
457
        if (stab->n_strx)
458
            str = stabstr_section->data + stab->n_strx;
459
        fprintf(fdbg, "0x%X type(%d) str(%s) desc(%d)\n", stab->n_value, stab->n_type, str, stab->n_desc);
460
*/
461
    }
462
 
463
/*        for(; si; si = si->next)
464
        {
465
            Section *sr;
466
            Elf32_Rel *rel, *rel_end;
467
            for(sr = me->s1->sections[si->sec_num]->reloc; sr; )
468
            {
469
                for (rel = (Elf32_Rel *) sr->data, rel_end = (Elf32_Rel *) (sr->data + sr->data_offset); rel < rel_end; rel++)
470
                {
471
                    int type = ELF32_R_TYPE(rel->r_info);
472
                    if (type != R_386_PC32 && type != R_386_32)
473
                        continue;
474
                    int sym = ELF32_R_SYM(rel->r_info);
475
                    if (sym > symtab_section->data_offset / sizeof(Elf32_Sym))
476
                        continue;
477
                    Elf32_Sym* esym = ((Elf32_Sym*)symtab_section->data) + sym;
478
                    int sect = esym->st_shndx;
479
                    ss = findsection(me, sect);
480
                    const char *sym_name = strtab_section->data + esym->st_name;
481
                    if (ss == 0)
482
                    {
483
                        fprintf(fdbg, "undefined symbol '%s'\n", sym_name);
484
                        continue;
485
                    }
486
                    if (rel->r_offset > si->data_size) continue;
487
                    fprintf(fdbg, "\t0x%X %s\n", ss->sh_addr + esym->st_value, sym_name);
488
                }
489
            }
490
        }
491
*/
492
    close_source_file();
493
	fclose(fdbg);
494
	return 0;
495
}