← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to src/cmd/5l/span.c

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cmd/5l/span.c
90
90
        int32 c, otxt, out[6];
91
91
        Section *sect;
92
92
        uchar *bp;
 
93
        Sym *sub;
93
94
 
94
95
        if(debug['v'])
95
96
                Bprint(&bso, "%5.2f span\n", cputime());
96
97
        Bflush(&bso);
97
98
 
 
99
        sect = addsection(&segtext, ".text", 05);
 
100
        lookup("text", 0)->sect = sect;
 
101
        lookup("etext", 0)->sect = sect;
 
102
 
98
103
        bflag = 0;
99
104
        c = INITTEXT;
100
105
        otxt = c;
101
106
        for(cursym = textp; cursym != nil; cursym = cursym->next) {
 
107
                cursym->sect = sect;
102
108
                p = cursym->text;
 
109
                if(p == P || p->link == P) { // handle external functions and ELF section symbols
 
110
                        if(cursym->type & SSUB)
 
111
                                continue;
 
112
                        if(cursym->align != 0)
 
113
                                c = rnd(c, cursym->align);
 
114
                        cursym->value = 0;
 
115
                        for(sub = cursym; sub != S; sub = sub->sub) {
 
116
                                sub->value += c;
 
117
                                for(p = sub->text; p != P; p = p->link)
 
118
                                        p->pc += sub->value;
 
119
                        }
 
120
                        c += cursym->size;
 
121
                        continue;
 
122
                }
103
123
                p->pc = c;
104
124
                cursym->value = c;
105
125
 
160
180
                bflag = 0;
161
181
                c = INITTEXT;
162
182
                for(cursym = textp; cursym != nil; cursym = cursym->next) {
 
183
                        if(!cursym->text || !cursym->text->link)
 
184
                                continue;
163
185
                        cursym->value = c;
164
186
                        for(p = cursym->text; p != P; p = p->link) {
165
187
                                curp = p;
217
239
         */
218
240
        for(cursym = textp; cursym != nil; cursym = cursym->next) {
219
241
                p = cursym->text;
 
242
                if(p == P || p->link == P)
 
243
                       continue;
220
244
                autosize = p->to.offset + 4;
221
245
                symgrow(cursym, cursym->size);
222
246
        
235
259
                        }
236
260
                }
237
261
        }
238
 
        sect = addsection(&segtext, ".text", 05);
239
262
        sect->vaddr = INITTEXT;
240
263
        sect->len = c - INITTEXT;
241
264
}
269
292
                        q->to.type = D_BRANCH;
270
293
                        q->cond = p->link;
271
294
                        q->link = blitrl;
 
295
                        q->line = p->line;
272
296
                        blitrl = q;
273
297
                }
274
298
                else if(!force && (p->pc+pool.size-pool.start < 2048))
275
299
                        return 0;
276
300
                elitrl->link = p->link;
277
301
                p->link = blitrl;
 
302
                // BUG(minux): how to correctly handle line number for constant pool entries?
 
303
                // for now, we set line number to the last instruction preceding them at least
 
304
                // this won't bloat the .debug_line tables
 
305
                while(blitrl) {
 
306
                        blitrl->line = p->line;
 
307
                        blitrl = blitrl->link;
 
308
                }
278
309
                blitrl = 0;     /* BUG: should refer back to values until out-of-range */
279
310
                elitrl = 0;
280
311
                pool.size = 0;
299
330
        switch(c) {
300
331
        default:
301
332
                t.to = *a;
 
333
                if(flag_shared && t.to.sym != S)
 
334
                        t.pcrel = p;
302
335
                break;
303
336
 
304
 
        case    C_SROREG:
 
337
        case C_SROREG:
305
338
        case C_LOREG:
306
339
        case C_ROREG:
307
340
        case C_FOREG:
316
349
                break;
317
350
        }
318
351
 
319
 
        for(q = blitrl; q != P; q = q->link)    /* could hash on t.t0.offset */
320
 
                if(memcmp(&q->to, &t.to, sizeof(t.to)) == 0) {
321
 
                        p->cond = q;
322
 
                        return;
323
 
                }
 
352
        if(t.pcrel == P) {
 
353
                for(q = blitrl; q != P; q = q->link)    /* could hash on t.t0.offset */
 
354
                        if(q->pcrel == P && memcmp(&q->to, &t.to, sizeof(t.to)) == 0) {
 
355
                                p->cond = q;
 
356
                                return;
 
357
                        }
 
358
        }
324
359
 
325
360
        q = prg();
326
361
        *q = t;
407
442
int32
408
443
symaddr(Sym *s)
409
444
{
410
 
        int32 v;
411
 
 
412
 
        v = s->value;
413
 
        switch(s->type) {
414
 
        default:
415
 
                diag("unexpected type %d in symaddr(%s)", s->type, s->name);
416
 
                return 0;
417
 
        
418
 
        case STEXT:
419
 
        case SELFROSECT:
420
 
        case SRODATA:
421
 
        case SDATA:
422
 
        case SBSS:
423
 
        case SCONST:
424
 
        case SNOPTRDATA:
425
 
        case SNOPTRBSS:
426
 
                break;
427
 
        }
428
 
        return v;
 
445
        if(!s->reachable)
 
446
                diag("unreachable symbol in symaddr - %s", s->name);
 
447
        return s->value;
429
448
}
430
449
 
431
450
int
444
463
        case D_REGREG:
445
464
                return C_REGREG;
446
465
 
 
466
        case D_REGREG2:
 
467
                return C_REGREG2;
 
468
 
447
469
        case D_SHIFT:
448
470
                return C_SHIFT;
449
471
 
552
574
                        if(s == S)
553
575
                                break;
554
576
                        instoffset = 0; // s.b. unused but just in case
555
 
                        return C_LCON;
 
577
                        if(flag_shared)
 
578
                                return C_LCONADDR;
 
579
                        else
 
580
                                return C_LCON;
556
581
 
557
582
                case D_AUTO:
558
583
                        instoffset = autosize + a->offset;
718
743
        for(i=0; i<C_GOK; i++)
719
744
                for(n=0; n<C_GOK; n++)
720
745
                        xcmp[i][n] = cmp(n, i);
721
 
        for(n=0; optab[n].as != AXXX; n++)
722
 
                ;
 
746
        for(n=0; optab[n].as != AXXX; n++) {
 
747
                if((optab[n].flag & LPCREL) != 0) {
 
748
                        if(flag_shared)
 
749
                                optab[n].size += optab[n].pcrelsiz;
 
750
                        else
 
751
                                optab[n].flag &= ~LPCREL;
 
752
                }
 
753
        }
723
754
        qsort(optab, n, sizeof(optab[0]), ocmp);
724
755
        for(i=0; i<n; i++) {
725
756
                r = optab[i].as;
798
829
                case AMOVM:
799
830
                case ARFE:
800
831
                case ATEXT:
 
832
                case AUSEFIELD:
 
833
                case ALOCALS:
801
834
                case ACASE:
802
835
                case ABCASE:
 
836
                case ATYPE:
803
837
                        break;
804
838
                case AADDF:
805
839
                        oprange[AADDD] = oprange[r];
813
847
                        oprange[ASQRTD] = oprange[r];
814
848
                        oprange[AMOVFD] = oprange[r];
815
849
                        oprange[AMOVDF] = oprange[r];
 
850
                        oprange[AABSF] = oprange[r];
 
851
                        oprange[AABSD] = oprange[r];
816
852
                        break;
817
853
 
818
854
                case ACMPF:
832
868
                        break;
833
869
 
834
870
                case AMULL:
835
 
                        oprange[AMULA] = oprange[r];
836
871
                        oprange[AMULAL] = oprange[r];
837
872
                        oprange[AMULLU] = oprange[r];
838
873
                        oprange[AMULALU] = oprange[r];
839
874
                        break;
840
875
 
 
876
                case AMULWT:
 
877
                        oprange[AMULWB] = oprange[r];
 
878
                        break;
 
879
 
 
880
                case AMULAWT:
 
881
                        oprange[AMULAWB] = oprange[r];
 
882
                        break;
 
883
 
 
884
                case AMULA:
841
885
                case ALDREX:
842
886
                case ASTREX:
843
887
                case ALDREXD:
844
888
                case ASTREXD:
845
889
                case ATST:
 
890
                case APLD:
 
891
                case AUNDEF:
 
892
                case ACLZ:
846
893
                        break;
847
894
                }
848
895
        }