← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/cmd/8l/obj.c

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-20 14:06:23 UTC
  • mfrom: (14.1.23 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130820140623-b414jfxi3m0qkmrq
Tags: 2:1.1.2-2ubuntu1
https://launchpad.net/bugs/1211749
https://launchpad.net/bugs/1202027
* Merge from Debian unstable (LP: #1211749, #1202027). Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - d/control,control.cross: Update Breaks/Replaces for Ubuntu
    versions to ensure smooth upgrades, regenerate control file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cmd/8l/obj.c
77
77
 */
78
78
 
79
79
void
80
 
usage(void)
81
 
{
82
 
        fprint(2, "usage: 8l [-options] [-E entry] [-H head] [-I interpreter] [-L dir] [-T text] [-R rnd] [-r path] [-o out] main.8\n");
83
 
        exits("usage");
84
 
}
85
 
 
86
 
void
87
80
main(int argc, char *argv[])
88
81
{
89
 
        int c;
90
 
        char *name, *val;
91
 
 
92
82
        Binit(&bso, 1, OWRITE);
93
83
        listinit();
94
84
        memset(debug, 0, sizeof(debug));
99
89
        INITDAT = -1;
100
90
        INITRND = -1;
101
91
        INITENTRY = 0;
 
92
        LIBINITENTRY = 0;
 
93
        linkmode = LinkAuto;
102
94
        nuxiinit();
103
95
 
104
 
        ARGBEGIN {
105
 
        default:
106
 
                c = ARGC();
107
 
                if(c == 'l')
108
 
                        usage();
109
 
                if(c >= 0 && c < sizeof(debug))
110
 
                        debug[c]++;
111
 
                break;
112
 
        case 'o': /* output to (next arg) */
113
 
                outfile = EARGF(usage());
114
 
                break;
115
 
        case 'E':
116
 
                INITENTRY = EARGF(usage());
117
 
                break;
118
 
        case 'H':
119
 
                HEADTYPE = headtype(EARGF(usage()));
120
 
                break;
121
 
        case 'I':
122
 
                interpreter = EARGF(usage());
123
 
                break;
124
 
        case 'L':
125
 
                Lflag(EARGF(usage()));
126
 
                break;
127
 
        case 'T':
128
 
                INITTEXT = atolwhex(EARGF(usage()));
129
 
                break;
130
 
        case 'D':
131
 
                INITDAT = atolwhex(EARGF(usage()));
132
 
                break;
133
 
        case 'R':
134
 
                INITRND = atolwhex(EARGF(usage()));
135
 
                break;
136
 
        case 'r':
137
 
                rpath = EARGF(usage());
138
 
                break;
139
 
        case 'V':
140
 
                print("%cl version %s\n", thechar, getgoversion());
141
 
                errorexit();
142
 
        case 'X':
143
 
                name = EARGF(usage());
144
 
                val = EARGF(usage());
145
 
                addstrdata(name, val);
146
 
                break;
147
 
        } ARGEND
 
96
        flagcount("1", "use alternate profiling code", &debug['1']);
 
97
        flagfn1("B", "info: define ELF NT_GNU_BUILD_ID note", addbuildinfo);
 
98
        flagstr("E", "sym: entry symbol", &INITENTRY);
 
99
        flagint32("D", "addr: data address", &INITDAT);
 
100
        flagfn1("I", "interp: set ELF interp", setinterp);
 
101
        flagfn1("L", "dir: add dir to library path", Lflag);
 
102
        flagfn1("H", "head: header type", setheadtype);
 
103
        flagcount("K", "add stack underflow checks", &debug['K']);
 
104
        flagcount("O", "print pc-line tables", &debug['O']);
 
105
        flagcount("Q", "debug byte-register code gen", &debug['Q']);
 
106
        flagint32("R", "rnd: address rounding", &INITRND);
 
107
        flagcount("S", "check type signatures", &debug['S']);
 
108
        flagint32("T", "addr: text address", &INITTEXT);
 
109
        flagfn0("V", "print version and exit", doversion);
 
110
        flagcount("W", "disassemble input", &debug['W']);
 
111
        flagfn2("X", "name value: define string data", addstrdata);
 
112
        flagcount("Z", "clear stack frame on entry", &debug['Z']);
 
113
        flagcount("a", "disassemble output", &debug['a']);
 
114
        flagcount("c", "dump call graph", &debug['c']);
 
115
        flagcount("d", "disable dynamic executable", &debug['d']);
 
116
        flagstr("extld", "linker to run in external mode", &extld);
 
117
        flagstr("extldflags", "flags for external linker", &extldflags);
 
118
        flagcount("f", "ignore version mismatch", &debug['f']);
 
119
        flagcount("g", "disable go package data checks", &debug['g']);
 
120
        flagfn1("linkmode", "mode: set link mode (internal, external, auto)", setlinkmode);
 
121
        flagstr("k", "sym: set field tracking symbol", &tracksym);
 
122
        flagstr("o", "outfile: set output file", &outfile);
 
123
        flagcount("p", "insert profiling code", &debug['p']);
 
124
        flagstr("r", "dir1:dir2:...: set ELF dynamic linker search path", &rpath);
 
125
        flagcount("race", "enable race detector", &flag_race);
 
126
        flagcount("s", "disable symbol table", &debug['s']);
 
127
        flagcount("n", "dump symbol table", &debug['n']);
 
128
        flagstr("tmpdir", "leave temporary files in this directory", &tmpdir);
 
129
        flagcount("u", "reject unsafe packages", &debug['u']);
 
130
        flagcount("v", "print link trace", &debug['v']);
 
131
        flagcount("w", "disable DWARF generation", &debug['w']);
 
132
        // TODO: link mode flag
 
133
        
 
134
        flagparse(&argc, &argv, usage);
148
135
 
149
136
        if(argc != 1)
150
137
                usage();
154
141
        if(HEADTYPE == -1)
155
142
                HEADTYPE = headtype(goos);
156
143
 
 
144
        // getgoextlinkenabled is based on GO_EXTLINK_ENABLED when
 
145
        // Go was built; see ../../make.bash.
 
146
        if(linkmode == LinkAuto && strcmp(getgoextlinkenabled(), "0") == 0)
 
147
                linkmode = LinkInternal;
 
148
 
 
149
        switch(HEADTYPE) {
 
150
        default:
 
151
                if(linkmode == LinkAuto)
 
152
                        linkmode = LinkInternal;
 
153
                if(linkmode == LinkExternal && strcmp(getgoextlinkenabled(), "1") != 0)
 
154
                        sysfatal("cannot use -linkmode=external with -H %s", headstr(HEADTYPE));
 
155
                break;
 
156
        case Hdarwin:
 
157
        case Hfreebsd:
 
158
        case Hlinux:
 
159
        case Hnetbsd:
 
160
        case Hopenbsd:
 
161
                break;
 
162
        }
 
163
 
157
164
        if(outfile == nil) {
158
165
                if(HEADTYPE == Hwindows)
159
166
                        outfile = "8.out.exe";
300
307
        if(HEADTYPE == Hwindows)
301
308
                dope();
302
309
        dostkoff();
 
310
        dostkcheck();
303
311
        if(debug['p'])
304
312
                if(debug['1'])
305
313
                        doprof1();
316
324
        reloc();
317
325
        asmb();
318
326
        undef();
 
327
        hostlink();
 
328
 
319
329
        if(debug['v']) {
320
330
                Bprint(&bso, "%5.2f cpu time\n", cputime());
321
331
                Bprint(&bso, "%d symbols\n", nsymbol);
332
342
{       
333
343
        int o;
334
344
        
335
 
        o = Bgetc(f);
 
345
        o = BGETC(f);
336
346
        if(o < 0 || o >= NSYM || h[o] == nil)
337
347
                mangle(pn);
338
348
        return h[o];
346
356
        Sym *s;
347
357
        Auto *u;
348
358
 
349
 
        t = Bgetc(f);
 
359
        t = BGETC(f);
350
360
        a->index = D_NONE;
351
361
        a->scale = 0;
352
362
        if(t & T_INDEX) {
353
 
                a->index = Bgetc(f);
354
 
                a->scale = Bgetc(f);
 
363
                a->index = BGETC(f);
 
364
                a->scale = BGETC(f);
355
365
        }
356
366
        a->type = D_NONE;
357
367
        a->offset = 0;
375
385
                a->type = D_SCONST;
376
386
        }
377
387
        if(t & T_TYPE)
378
 
                a->type = Bgetc(f);
 
388
                a->type = BGETC(f);
379
389
        adrgotype = S;
380
390
        if(t & T_GOTYPE)
381
391
                adrgotype = zsym(pn, f, h);
439
449
        ntext = 0;
440
450
        eof = Boffset(f) + len;
441
451
        src[0] = 0;
442
 
 
 
452
        pn = estrdup(pn); // we keep it in Sym* references
443
453
 
444
454
newloop:
445
455
        memset(h, 0, sizeof(h));
451
461
loop:
452
462
        if(f->state == Bracteof || Boffset(f) >= eof)
453
463
                goto eof;
454
 
        o = Bgetc(f);
 
464
        o = BGETC(f);
455
465
        if(o == Beof)
456
466
                goto eof;
457
 
        o |= Bgetc(f) << 8;
 
467
        o |= BGETC(f) << 8;
458
468
        if(o <= AXXX || o >= ALAST) {
459
469
                if(o < 0)
460
470
                        goto eof;
467
477
                sig = 0;
468
478
                if(o == ASIGNAME)
469
479
                        sig = Bget4(f);
470
 
                v = Bgetc(f);   /* type */
471
 
                o = Bgetc(f);   /* sym */
 
480
                v = BGETC(f);   /* type */
 
481
                o = BGETC(f);   /* sym */
472
482
                r = 0;
473
483
                if(v == D_STATIC)
474
484
                        r = version;
523
533
        p->as = o;
524
534
        p->line = Bget4(f);
525
535
        p->back = 2;
526
 
        p->ft = 0;
527
 
        p->tt = 0;
528
536
        zaddr(pn, f, &p->from, h);
529
537
        fromgotype = adrgotype;
530
538
        zaddr(pn, f, &p->to, h);
605
613
                pc++;
606
614
                goto loop;
607
615
 
 
616
        case ALOCALS:
 
617
                if(skip)
 
618
                        goto casdef;
 
619
                cursym->locals = p->to.offset;
 
620
                pc++;
 
621
                goto loop;
 
622
 
 
623
        case ATYPE:
 
624
                if(skip)
 
625
                        goto casdef;
 
626
                pc++;
 
627
                goto loop;
 
628
 
608
629
        case ATEXT:
609
630
                s = p->from.sym;
610
631
                if(s->text != nil) {
643
664
                }
644
665
                s->type = STEXT;
645
666
                s->value = pc;
 
667
                s->args = p->to.offset2;
646
668
                lastp = p;
647
669
                p->pc = pc++;
648
670
                goto loop;
656
678
        case AFDIVRF:
657
679
        case AFCOMF:
658
680
        case AFCOMFP:
 
681
        case AMOVSS:
 
682
        case AADDSS:
 
683
        case ASUBSS:
 
684
        case AMULSS:
 
685
        case ADIVSS:
 
686
        case ACOMISS:
 
687
        case AUCOMISS:
659
688
                if(skip)
660
689
                        goto casdef;
661
690
                if(p->from.type == D_FCONST) {
663
692
                        sprint(literal, "$%ux", ieeedtof(&p->from.ieee));
664
693
                        s = lookup(literal, 0);
665
694
                        if(s->type == 0) {
666
 
                                s->type = SDATA;
 
695
                                s->type = SRODATA;
667
696
                                adduint32(s, ieeedtof(&p->from.ieee));
668
697
                                s->reachable = 0;
669
698
                        }
682
711
        case AFDIVRD:
683
712
        case AFCOMD:
684
713
        case AFCOMDP:
 
714
        case AMOVSD:
 
715
        case AADDSD:
 
716
        case ASUBSD:
 
717
        case AMULSD:
 
718
        case ADIVSD:
 
719
        case ACOMISD:
 
720
        case AUCOMISD:
685
721
                if(skip)
686
722
                        goto casdef;
687
723
                if(p->from.type == D_FCONST) {
690
726
                                p->from.ieee.l, p->from.ieee.h);
691
727
                        s = lookup(literal, 0);
692
728
                        if(s->type == 0) {
693
 
                                s->type = SDATA;
 
729
                                s->type = SRODATA;
694
730
                                adduint32(s, p->from.ieee.l);
695
731
                                adduint32(s, p->from.ieee.h);
696
732
                                s->reachable = 0;