mirror of
https://github.com/golang/go
synced 2024-11-19 20:34:42 -07:00
7a7c0ffb47
The VARDEF placement must be before the initialization but after any final use. If you have something like s = ... using s ... the rhs must be evaluated, then the VARDEF, then the lhs assigned. There is a large comment in pgen.c on gvardef explaining this in more detail. This CL also includes Ian's suggestions from earlier CLs, namely commenting the use of mode in link.h and fixing the precedence of the ~r check in dcl.c. This CL enables the check that if liveness analysis decides a variable is live on entry to the function, that variable must be a function parameter (not a result, and not a local variable). If this check fails, it indicates a bug in the liveness analysis or in the generated code being analyzed. The race detector generates invalid code for append(x, y...). The code declares a temporary t and then uses cap(t) before initializing t. The new liveness check catches this bug and stops the compiler from writing out the buggy code. Consequently, this CL disables the race detector tests in run.bash until the race detector bug can be fixed (golang.org/issue/7334). Except for the race detector bug, the liveness analysis check does not detect any problems (this CL and the previous CLs fixed all the detected problems). The net test still fails with GOGC=0 but the rest of the tests now pass or time out (because GOGC=0 is so slow). TBR=iant CC=golang-codereviews https://golang.org/cl/64170043
577 lines
12 KiB
C
577 lines
12 KiB
C
// Derived from Inferno utils/6l/l.h and related files.
|
|
// http://code.google.com/p/inferno-os/source/browse/utils/6l/l.h
|
|
//
|
|
// Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
|
|
// Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
|
|
// Portions Copyright © 1997-1999 Vita Nuova Limited
|
|
// Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
|
|
// Portions Copyright © 2004,2006 Bruce Ellis
|
|
// Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
|
|
// Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
|
|
// Portions Copyright © 2009 The Go Authors. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
typedef struct Addr Addr;
|
|
typedef struct Prog Prog;
|
|
typedef struct LSym LSym;
|
|
typedef struct Reloc Reloc;
|
|
typedef struct Auto Auto;
|
|
typedef struct Hist Hist;
|
|
typedef struct Link Link;
|
|
typedef struct Plist Plist;
|
|
typedef struct LinkArch LinkArch;
|
|
typedef struct Library Library;
|
|
|
|
typedef struct Pcln Pcln;
|
|
typedef struct Pcdata Pcdata;
|
|
typedef struct Pciter Pciter;
|
|
|
|
// prevent incompatible type signatures between liblink and 8l on Plan 9
|
|
#pragma incomplete struct Node
|
|
|
|
struct Addr
|
|
{
|
|
vlong offset;
|
|
|
|
union
|
|
{
|
|
char sval[8];
|
|
float64 dval;
|
|
Prog* branch; // for 5g, 6g, 8g
|
|
} u;
|
|
|
|
LSym* sym;
|
|
LSym* gotype;
|
|
short type;
|
|
uint8 index;
|
|
int8 scale;
|
|
int8 reg; // for 5l
|
|
int8 name; // for 5l
|
|
int8 class; // for 5l
|
|
uint8 etype; // for 5g, 6g, 8g
|
|
int32 offset2; // for 5l, 8l
|
|
struct Node* node; // for 5g, 6g, 8g
|
|
int64 width; // for 5g, 6g, 8g
|
|
};
|
|
|
|
struct Reloc
|
|
{
|
|
int32 off;
|
|
uchar siz;
|
|
uchar done;
|
|
int32 type;
|
|
int64 add;
|
|
int64 xadd;
|
|
LSym* sym;
|
|
LSym* xsym;
|
|
};
|
|
|
|
struct Prog
|
|
{
|
|
vlong pc;
|
|
int32 lineno;
|
|
Prog* link;
|
|
short as;
|
|
uchar reg; // arm only
|
|
uchar scond; // arm only
|
|
Addr from;
|
|
Addr to;
|
|
|
|
// for 5g, 6g, 8g internal use
|
|
void* opt;
|
|
|
|
// for 5l, 6l, 8l internal use
|
|
Prog* forwd;
|
|
Prog* pcond;
|
|
Prog* comefrom; // 6l, 8l
|
|
Prog* pcrel; // 5l
|
|
int32 spadj;
|
|
uchar mark;
|
|
uchar back; // 6l, 8l
|
|
char ft; /* 6l, 8l oclass cache */
|
|
char tt; // 6l, 8l
|
|
uchar optab; // 5l
|
|
|
|
char width; /* fake for DATA */
|
|
char mode; /* 16, 32, or 64 in 8l, 8l; internal use in 5g, 6g, 8g */
|
|
};
|
|
|
|
// prevent incompatible type signatures between liblink and 8l on Plan 9
|
|
#pragma incomplete struct Section
|
|
|
|
struct LSym
|
|
{
|
|
char* name;
|
|
char* extname; // name used in external object files
|
|
short type;
|
|
short version;
|
|
uchar dupok;
|
|
uchar reachable;
|
|
uchar cgoexport;
|
|
uchar special;
|
|
uchar stkcheck;
|
|
uchar hide;
|
|
uchar leaf; // arm only
|
|
uchar fnptr; // arm only
|
|
uchar seenglobl;
|
|
int16 symid; // for writing .5/.6/.8 files
|
|
int32 dynid;
|
|
int32 sig;
|
|
int32 plt;
|
|
int32 got;
|
|
int32 align; // if non-zero, required alignment in bytes
|
|
int32 elfsym;
|
|
int32 args; // size of stack frame incoming arguments area
|
|
int32 locals; // size of stack frame locals area (arm only?)
|
|
vlong value;
|
|
vlong size;
|
|
LSym* hash; // in hash table
|
|
LSym* allsym; // in all symbol list
|
|
LSym* next; // in text or data list
|
|
LSym* sub; // in SSUB list
|
|
LSym* outer; // container of sub
|
|
LSym* gotype;
|
|
LSym* reachparent;
|
|
LSym* queue;
|
|
char* file;
|
|
char* dynimplib;
|
|
char* dynimpvers;
|
|
struct Section* sect;
|
|
|
|
// STEXT
|
|
Auto* autom;
|
|
Prog* text;
|
|
Prog* etext;
|
|
Pcln* pcln;
|
|
|
|
// SDATA, SBSS
|
|
uchar* p;
|
|
int32 np;
|
|
int32 maxp;
|
|
Reloc* r;
|
|
int32 nr;
|
|
int32 maxr;
|
|
};
|
|
|
|
// LSym.type
|
|
enum
|
|
{
|
|
Sxxx,
|
|
|
|
/* order here is order in output file */
|
|
/* readonly, executable */
|
|
STEXT,
|
|
SELFRXSECT,
|
|
|
|
/* readonly, non-executable */
|
|
STYPE,
|
|
SSTRING,
|
|
SGOSTRING,
|
|
SGOFUNC,
|
|
SRODATA,
|
|
SFUNCTAB,
|
|
STYPELINK,
|
|
SSYMTAB, // TODO: move to unmapped section
|
|
SPCLNTAB,
|
|
SELFROSECT,
|
|
|
|
/* writable, non-executable */
|
|
SMACHOPLT,
|
|
SELFSECT,
|
|
SMACHO, /* Mach-O __nl_symbol_ptr */
|
|
SMACHOGOT,
|
|
SNOPTRDATA,
|
|
SINITARR,
|
|
SDATA,
|
|
SWINDOWS,
|
|
SBSS,
|
|
SNOPTRBSS,
|
|
STLSBSS,
|
|
|
|
/* not mapped */
|
|
SXREF,
|
|
SMACHOSYMSTR,
|
|
SMACHOSYMTAB,
|
|
SMACHOINDIRECTPLT,
|
|
SMACHOINDIRECTGOT,
|
|
SFILE,
|
|
SFILEPATH,
|
|
SCONST,
|
|
SDYNIMPORT,
|
|
SHOSTOBJ,
|
|
|
|
SSUB = 1<<8, /* sub-symbol, linked from parent via ->sub list */
|
|
SMASK = SSUB - 1,
|
|
SHIDDEN = 1<<9, // hidden or local symbol
|
|
};
|
|
|
|
struct Auto
|
|
{
|
|
LSym* asym;
|
|
Auto* link;
|
|
int32 aoffset;
|
|
int16 type;
|
|
LSym* gotype;
|
|
};
|
|
|
|
enum
|
|
{
|
|
LINKHASH = 100003,
|
|
};
|
|
|
|
struct Hist
|
|
{
|
|
Hist* link;
|
|
char* name;
|
|
int32 line;
|
|
int32 offset;
|
|
};
|
|
|
|
struct Plist
|
|
{
|
|
LSym* name;
|
|
Prog* firstpc;
|
|
int recur;
|
|
Plist* link;
|
|
};
|
|
|
|
struct Library
|
|
{
|
|
char *objref; // object where we found the reference
|
|
char *srcref; // src file where we found the reference
|
|
char *file; // object file
|
|
char *pkg; // import path
|
|
};
|
|
|
|
struct Pcdata
|
|
{
|
|
uchar *p;
|
|
int n;
|
|
int m;
|
|
};
|
|
|
|
struct Pcln
|
|
{
|
|
Pcdata pcsp;
|
|
Pcdata pcfile;
|
|
Pcdata pcline;
|
|
Pcdata *pcdata;
|
|
int npcdata;
|
|
LSym **funcdata;
|
|
int64 *funcdataoff;
|
|
int nfuncdata;
|
|
|
|
LSym **file;
|
|
int nfile;
|
|
int mfile;
|
|
|
|
LSym *lastfile;
|
|
int lastindex;
|
|
};
|
|
|
|
// Pcdata iterator.
|
|
// for(pciterinit(&it, &pcd); !it.done; pciternext(&it)) { it.value holds in [it.pc, it.nextpc) }
|
|
struct Pciter
|
|
{
|
|
Pcdata d;
|
|
uchar *p;
|
|
uint32 pc;
|
|
uint32 nextpc;
|
|
int32 value;
|
|
int start;
|
|
int done;
|
|
};
|
|
|
|
void pciterinit(Pciter*, Pcdata*);
|
|
void pciternext(Pciter*);
|
|
|
|
// symbol version, incremented each time a file is loaded.
|
|
// version==1 is reserved for savehist.
|
|
enum
|
|
{
|
|
HistVersion = 1,
|
|
};
|
|
|
|
// Link holds the context for writing object code from a compiler
|
|
// to be linker input or for reading that input into the linker.
|
|
struct Link
|
|
{
|
|
int32 thechar; // '5' (arm), '6' (amd64), etc.
|
|
char* thestring; // full name of architecture ("arm", "amd64", ..)
|
|
int32 goarm; // for arm only, GOARM setting
|
|
int headtype;
|
|
int linkmode;
|
|
|
|
LinkArch* arch;
|
|
int32 (*ignore)(char*); // do not emit names satisfying this function
|
|
int32 debugasm; // -S flag in compiler
|
|
int32 debugline; // -L flag in compiler
|
|
int32 debughist; // -O flag in linker
|
|
int32 debugread; // -W flag in linker
|
|
int32 debugvlog; // -v flag in linker
|
|
int32 debugstack; // -K flag in linker
|
|
int32 debugzerostack; // -Z flag in linker
|
|
int32 debugdivmod; // -M flag in 5l
|
|
int32 debugfloat; // -F flag in 5l
|
|
int32 debugpcln; // -O flag in linker
|
|
int32 flag_shared; // -shared flag in linker
|
|
int32 iself;
|
|
Biobuf* bso; // for -v flag
|
|
char* pathname;
|
|
int32 windows;
|
|
|
|
// hash table of all symbols
|
|
LSym* hash[LINKHASH];
|
|
LSym* allsym;
|
|
int32 nsymbol;
|
|
|
|
// file-line history
|
|
Hist* hist;
|
|
Hist* ehist;
|
|
|
|
// all programs
|
|
Plist* plist;
|
|
Plist* plast;
|
|
|
|
// code generation
|
|
LSym* sym_div;
|
|
LSym* sym_divu;
|
|
LSym* sym_mod;
|
|
LSym* sym_modu;
|
|
LSym* symmorestack[10];
|
|
LSym* gmsym;
|
|
LSym* plan9tos;
|
|
Prog* curp;
|
|
Prog* printp;
|
|
Prog* blitrl;
|
|
Prog* elitrl;
|
|
int rexflag;
|
|
int asmode;
|
|
uchar* andptr;
|
|
uchar and[100];
|
|
int32 instoffset;
|
|
int32 autosize;
|
|
int32 armsize;
|
|
|
|
// for reading input files (during linker)
|
|
vlong pc;
|
|
char** libdir;
|
|
int32 nlibdir;
|
|
int32 maxlibdir;
|
|
Library* library;
|
|
int libraryp;
|
|
int nlibrary;
|
|
int tlsoffset;
|
|
void (*diag)(char*, ...);
|
|
int mode;
|
|
Auto* curauto;
|
|
Auto* curhist;
|
|
LSym* cursym;
|
|
int version;
|
|
LSym* textp;
|
|
LSym* etextp;
|
|
int32 histdepth;
|
|
int32 nhistfile;
|
|
LSym* filesyms;
|
|
};
|
|
|
|
// LinkArch is the definition of a single architecture.
|
|
struct LinkArch
|
|
{
|
|
char* name; // "arm", "amd64", and so on
|
|
int thechar; // '5', '6', and so on
|
|
|
|
void (*addstacksplit)(Link*, LSym*);
|
|
void (*assemble)(Link*, LSym*);
|
|
int (*datasize)(Prog*);
|
|
void (*follow)(Link*, LSym*);
|
|
int (*iscall)(Prog*);
|
|
int (*isdata)(Prog*);
|
|
Prog* (*prg)(void);
|
|
void (*progedit)(Link*, Prog*);
|
|
void (*settextflag)(Prog*, int);
|
|
int (*symtype)(Addr*);
|
|
int (*textflag)(Prog*);
|
|
|
|
int minlc;
|
|
int ptrsize;
|
|
|
|
// TODO: Give these the same values on all systems.
|
|
int D_ADDR;
|
|
int D_BRANCH;
|
|
int D_CONST;
|
|
int D_EXTERN;
|
|
int D_FCONST;
|
|
int D_NONE;
|
|
int D_PCREL;
|
|
int D_SCONST;
|
|
int D_SIZE;
|
|
int D_STATIC;
|
|
|
|
int ACALL;
|
|
int ADATA;
|
|
int AEND;
|
|
int AFUNCDATA;
|
|
int AGLOBL;
|
|
int AJMP;
|
|
int ANOP;
|
|
int APCDATA;
|
|
int ARET;
|
|
int ATEXT;
|
|
int ATYPE;
|
|
int AUSEFIELD;
|
|
};
|
|
|
|
/* executable header types */
|
|
enum {
|
|
Hunknown = 0,
|
|
Hdarwin,
|
|
Hdragonfly,
|
|
Helf,
|
|
Hfreebsd,
|
|
Hlinux,
|
|
Hnetbsd,
|
|
Hopenbsd,
|
|
Hplan9,
|
|
Hsolaris,
|
|
Hwindows,
|
|
};
|
|
|
|
enum
|
|
{
|
|
LinkAuto = 0,
|
|
LinkInternal,
|
|
LinkExternal,
|
|
};
|
|
|
|
extern uchar fnuxi8[8];
|
|
extern uchar fnuxi4[4];
|
|
extern uchar inuxi1[1];
|
|
extern uchar inuxi2[2];
|
|
extern uchar inuxi4[4];
|
|
extern uchar inuxi8[8];
|
|
|
|
// asm5.c
|
|
void span5(Link *ctxt, LSym *s);
|
|
int chipfloat5(Link *ctxt, float64 e);
|
|
int chipzero5(Link *ctxt, float64 e);
|
|
|
|
// asm6.c
|
|
void span6(Link *ctxt, LSym *s);
|
|
|
|
// asm8.c
|
|
void span8(Link *ctxt, LSym *s);
|
|
|
|
// data.c
|
|
vlong addaddr(Link *ctxt, LSym *s, LSym *t);
|
|
vlong addaddrplus(Link *ctxt, LSym *s, LSym *t, vlong add);
|
|
vlong addaddrplus4(Link *ctxt, LSym *s, LSym *t, vlong add);
|
|
vlong addpcrelplus(Link *ctxt, LSym *s, LSym *t, vlong add);
|
|
Reloc* addrel(LSym *s);
|
|
vlong addsize(Link *ctxt, LSym *s, LSym *t);
|
|
vlong adduint16(Link *ctxt, LSym *s, uint16 v);
|
|
vlong adduint32(Link *ctxt, LSym *s, uint32 v);
|
|
vlong adduint64(Link *ctxt, LSym *s, uint64 v);
|
|
vlong adduint8(Link *ctxt, LSym *s, uint8 v);
|
|
vlong adduintxx(Link *ctxt, LSym *s, uint64 v, int wid);
|
|
void mangle(char *file);
|
|
void savedata(Link *ctxt, LSym *s, Prog *p, char *pn);
|
|
vlong setaddr(Link *ctxt, LSym *s, vlong off, LSym *t);
|
|
vlong setaddrplus(Link *ctxt, LSym *s, vlong off, LSym *t, vlong add);
|
|
vlong setuint16(Link *ctxt, LSym *s, vlong r, uint16 v);
|
|
vlong setuint32(Link *ctxt, LSym *s, vlong r, uint32 v);
|
|
vlong setuint64(Link *ctxt, LSym *s, vlong r, uint64 v);
|
|
vlong setuint8(Link *ctxt, LSym *s, vlong r, uint8 v);
|
|
vlong setuintxx(Link *ctxt, LSym *s, vlong off, uint64 v, vlong wid);
|
|
void symgrow(Link *ctxt, LSym *s, vlong siz);
|
|
|
|
// go.c
|
|
void double2ieee(uint64 *ieee, double native);
|
|
void* emallocz(long n);
|
|
void* erealloc(void *p, long n);
|
|
char* estrdup(char *p);
|
|
char* expandpkg(char *t0, char *pkg);
|
|
|
|
// ld.c
|
|
void addhist(Link *ctxt, int32 line, int type);
|
|
void addlib(Link *ctxt, char *src, char *obj, char *path);
|
|
void addlibpath(Link *ctxt, char *srcref, char *objref, char *file, char *pkg);
|
|
void collapsefrog(Link *ctxt, LSym *s);
|
|
void copyhistfrog(Link *ctxt, char *buf, int nbuf);
|
|
int find1(int32 l, int c);
|
|
void linkgetline(Link *ctxt, int32 line, LSym **f, int32 *l);
|
|
void histtoauto(Link *ctxt);
|
|
void mkfwd(LSym*);
|
|
void nuxiinit(void);
|
|
void savehist(Link *ctxt, int32 line, int32 off);
|
|
Prog* copyp(Link*, Prog*);
|
|
Prog* appendp(Link*, Prog*);
|
|
vlong atolwhex(char*);
|
|
|
|
// list[568].c
|
|
void listinit5(void);
|
|
void listinit6(void);
|
|
void listinit8(void);
|
|
|
|
// obj.c
|
|
int linklinefmt(Link *ctxt, Fmt *fp);
|
|
void linklinehist(Link *ctxt, int lineno, char *f, int offset);
|
|
Plist* linknewplist(Link *ctxt);
|
|
void linkprfile(Link *ctxt, int32 l);
|
|
|
|
// objfile.c
|
|
void ldobjfile(Link *ctxt, Biobuf *b, char *pkg, int64 len, char *path);
|
|
void linkwriteobj(Link *ctxt, Biobuf *b);
|
|
|
|
// pass.c
|
|
Prog* brchain(Link *ctxt, Prog *p);
|
|
Prog* brloop(Link *ctxt, Prog *p);
|
|
void linkpatch(Link *ctxt, LSym *sym);
|
|
|
|
// pcln.c
|
|
void linkpcln(Link*, LSym*);
|
|
|
|
// sym.c
|
|
LSym* linklookup(Link *ctxt, char *name, int v);
|
|
Link* linknew(LinkArch*);
|
|
LSym* linknewsym(Link *ctxt, char *symb, int v);
|
|
LSym* linkrlookup(Link *ctxt, char *name, int v);
|
|
int linksymfmt(Fmt *f);
|
|
int headtype(char*);
|
|
char* headstr(int);
|
|
|
|
extern char* anames5[];
|
|
extern char* anames6[];
|
|
extern char* anames8[];
|
|
|
|
extern LinkArch link386;
|
|
extern LinkArch linkamd64;
|
|
extern LinkArch linkarm;
|
|
|
|
#pragma varargck type "A" int
|
|
#pragma varargck type "D" Addr*
|
|
#pragma varargck type "lD" Addr*
|
|
#pragma varargck type "P" Prog*
|
|
#pragma varargck type "R" int
|
|
|
|
// TODO(ality): remove this workaround.
|
|
// It's here because Pconv in liblink/list?.c references %L.
|
|
#pragma varargck type "L" int32
|