blob: 373cf5523736b8831dfa10538178d4c139d55b76 [file] [log] [blame]
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// TODO/NICETOHAVE:
// - eliminate DW_CLS_ if not used
// - package info in compilation units
// - assign global variables and types to their packages
// - gdb uses c syntax, meaning clumsy quoting is needed for go identifiers. eg
// ptype struct '[]uint8' and qualifiers need to be quoted away
// - lexical scoping is lost, so gdb gets confused as to which 'main.i' you mean.
// - file:line info for variables
// - make strings a typedef so prettyprinters can see the underlying string type
//
#include "l.h"
#include "lib.h"
#include "../ld/dwarf.h"
#include "../ld/dwarf_defs.h"
#include "../ld/elf.h"
#include "../ld/macho.h"
#include "../ld/pe.h"
/*
* Offsets and sizes of the debug_* sections in the cout file.
*/
static vlong abbrevo;
static vlong abbrevsize;
static vlong lineo;
static vlong linesize;
static vlong infoo; // also the base for DWDie->offs and reference attributes.
static vlong infosize;
static vlong frameo;
static vlong framesize;
static vlong pubnameso;
static vlong pubnamessize;
static vlong pubtypeso;
static vlong pubtypessize;
static vlong arangeso;
static vlong arangessize;
static vlong gdbscripto;
static vlong gdbscriptsize;
static char gdbscript[1024];
/*
* Basic I/O
*/
static void
addrput(vlong addr)
{
switch(PtrSize) {
case 4:
LPUT(addr);
break;
case 8:
VPUT(addr);
break;
}
}
static int
uleb128enc(uvlong v, char* dst)
{
uint8 c, len;
len = 0;
do {
c = v & 0x7f;
v >>= 7;
if (v)
c |= 0x80;
if (dst)
*dst++ = c;
len++;
} while (c & 0x80);
return len;
};
static int
sleb128enc(vlong v, char *dst)
{
uint8 c, s, len;
len = 0;
do {
c = v & 0x7f;
s = v & 0x40;
v >>= 7;
if ((v != -1 || !s) && (v != 0 || s))
c |= 0x80;
if (dst)
*dst++ = c;
len++;
} while(c & 0x80);
return len;
}
static void
uleb128put(vlong v)
{
char buf[10];
strnput(buf, uleb128enc(v, buf));
}
static void
sleb128put(vlong v)
{
char buf[10];
strnput(buf, sleb128enc(v, buf));
}
/*
* Defining Abbrevs. This is hardcoded, and there will be
* only a handful of them. The DWARF spec places no restriction on
* the ordering of atributes in the Abbrevs and DIEs, and we will
* always write them out in the order of declaration in the abbrev.
* This implementation relies on tag, attr < 127, so they serialize as
* a char. Higher numbered user-defined tags or attributes can be used
* for storing internal data but won't be serialized.
*/
typedef struct DWAttrForm DWAttrForm;
struct DWAttrForm {
uint8 attr;
uint8 form;
};
// Index into the abbrevs table below.
// Keep in sync with ispubname() and ispubtype() below.
// ispubtype considers >= NULLTYPE public
enum
{
DW_ABRV_NULL,
DW_ABRV_COMPUNIT,
DW_ABRV_FUNCTION,
DW_ABRV_VARIABLE,
DW_ABRV_AUTO,
DW_ABRV_PARAM,
DW_ABRV_STRUCTFIELD,
DW_ABRV_FUNCTYPEPARAM,
DW_ABRV_DOTDOTDOT,
DW_ABRV_ARRAYRANGE,
DW_ABRV_NULLTYPE,
DW_ABRV_BASETYPE,
DW_ABRV_ARRAYTYPE,
DW_ABRV_CHANTYPE,
DW_ABRV_FUNCTYPE,
DW_ABRV_IFACETYPE,
DW_ABRV_MAPTYPE,
DW_ABRV_PTRTYPE,
DW_ABRV_SLICETYPE,
DW_ABRV_STRINGTYPE,
DW_ABRV_STRUCTTYPE,
DW_ABRV_TYPEDECL,
DW_NABRV
};
typedef struct DWAbbrev DWAbbrev;
static struct DWAbbrev {
uint8 tag;
uint8 children;
DWAttrForm attr[30];
} abbrevs[DW_NABRV] = {
/* The mandatory DW_ABRV_NULL entry. */
{ 0 },
/* COMPUNIT */
{
DW_TAG_compile_unit, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
DW_AT_language, DW_FORM_data1,
DW_AT_low_pc, DW_FORM_addr,
DW_AT_high_pc, DW_FORM_addr,
DW_AT_stmt_list, DW_FORM_data4,
0, 0
},
/* FUNCTION */
{
DW_TAG_subprogram, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
DW_AT_low_pc, DW_FORM_addr,
DW_AT_high_pc, DW_FORM_addr,
DW_AT_external, DW_FORM_flag,
0, 0
},
/* VARIABLE */
{
DW_TAG_variable, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_location, DW_FORM_block1,
DW_AT_type, DW_FORM_ref_addr,
DW_AT_external, DW_FORM_flag,
0, 0
},
/* AUTO */
{
DW_TAG_variable, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_location, DW_FORM_block1,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* PARAM */
{
DW_TAG_formal_parameter, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_location, DW_FORM_block1,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* STRUCTFIELD */
{
DW_TAG_member, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_data_member_location, DW_FORM_block1,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* FUNCTYPEPARAM */
{
DW_TAG_formal_parameter, DW_CHILDREN_no,
// No name!
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* DOTDOTDOT */
{
DW_TAG_unspecified_parameters, DW_CHILDREN_no,
0, 0
},
/* ARRAYRANGE */
{
DW_TAG_subrange_type, DW_CHILDREN_no,
// No name!
DW_AT_type, DW_FORM_ref_addr,
DW_AT_upper_bound, DW_FORM_data1,
0, 0
},
// Below here are the types considered public by ispubtype
/* NULLTYPE */
{
DW_TAG_unspecified_type, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
0, 0
},
/* BASETYPE */
{
DW_TAG_base_type, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_encoding, DW_FORM_data1,
DW_AT_byte_size, DW_FORM_data1,
0, 0
},
/* ARRAYTYPE */
// child is subrange with upper bound
{
DW_TAG_array_type, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
DW_AT_type, DW_FORM_ref_addr,
DW_AT_byte_size, DW_FORM_udata,
0, 0
},
/* CHANTYPE */
{
DW_TAG_typedef, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* FUNCTYPE */
{
DW_TAG_subroutine_type, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
// DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* IFACETYPE */
{
DW_TAG_typedef, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* MAPTYPE */
{
DW_TAG_typedef, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* PTRTYPE */
{
DW_TAG_pointer_type, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
/* SLICETYPE */
{
DW_TAG_structure_type, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
DW_AT_byte_size, DW_FORM_udata,
0, 0
},
/* STRINGTYPE */
{
DW_TAG_structure_type, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
DW_AT_byte_size, DW_FORM_udata,
0, 0
},
/* STRUCTTYPE */
{
DW_TAG_structure_type, DW_CHILDREN_yes,
DW_AT_name, DW_FORM_string,
DW_AT_byte_size, DW_FORM_udata,
0, 0
},
/* TYPEDECL */
{
DW_TAG_typedef, DW_CHILDREN_no,
DW_AT_name, DW_FORM_string,
DW_AT_type, DW_FORM_ref_addr,
0, 0
},
};
static void
writeabbrev(void)
{
int i, n;
abbrevo = cpos();
for (i = 1; i < DW_NABRV; i++) {
// See section 7.5.3
uleb128put(i);
uleb128put(abbrevs[i].tag);
cput(abbrevs[i].children);
// 0 is not a valid attr or form, and DWAbbrev.attr is
// 0-terminated, so we can treat it as a string
n = strlen((char*)abbrevs[i].attr) / 2;
strnput((char*)abbrevs[i].attr,
(n+1) * sizeof(DWAttrForm));
}
cput(0);
abbrevsize = cpos() - abbrevo;
}
/*
* Debugging Information Entries and their attributes.
*/
enum
{
HASHSIZE = 107
};
static uint32
hashstr(char* s)
{
uint32 h;
h = 0;
while (*s)
h = h+h+h + *s++;
return h % HASHSIZE;
}
// For DW_CLS_string and _block, value should contain the length, and
// data the data, for _reference, value is 0 and data is a DWDie* to
// the referenced instance, for all others, value is the whole thing
// and data is null.
typedef struct DWAttr DWAttr;
struct DWAttr {
DWAttr *link;
uint8 atr; // DW_AT_
uint8 cls; // DW_CLS_
vlong value;
char *data;
};
typedef struct DWDie DWDie;
struct DWDie {
int abbrev;
DWDie *link;
DWDie *child;
DWAttr *attr;
// offset into .debug_info section, i.e relative to
// infoo. only valid after call to putdie()
vlong offs;
DWDie **hash; // optional index of children by name, enabled by mkindex()
DWDie *hlink; // bucket chain in parent's index
};
/*
* Root DIEs for compilation units, types and global variables.
*/
static DWDie dwroot;
static DWDie dwtypes;
static DWDie dwglobals;
static DWAttr*
newattr(DWDie *die, uint8 attr, int cls, vlong value, char *data)
{
DWAttr *a;
a = mal(sizeof *a);
a->link = die->attr;
die->attr = a;
a->atr = attr;
a->cls = cls;
a->value = value;
a->data = data;
return a;
}
// Each DIE (except the root ones) has at least 1 attribute: its
// name. getattr moves the desired one to the front so
// frequently searched ones are found faster.
static DWAttr*
getattr(DWDie *die, uint8 attr)
{
DWAttr *a, *b;
if (die->attr->atr == attr)
return die->attr;
a = die->attr;
b = a->link;
while (b != nil) {
if (b->atr == attr) {
a->link = b->link;
b->link = die->attr;
die->attr = b;
return b;
}
a = b;
b = b->link;
}
return nil;
}
// Every DIE has at least a DW_AT_name attribute (but it will only be
// written out if it is listed in the abbrev). If its parent is
// keeping an index, the new DIE will be inserted there.
static DWDie*
newdie(DWDie *parent, int abbrev, char *name)
{
DWDie *die;
int h;
die = mal(sizeof *die);
die->abbrev = abbrev;
die->link = parent->child;
parent->child = die;
newattr(die, DW_AT_name, DW_CLS_STRING, strlen(name), name);
if (parent->hash) {
h = hashstr(name);
die->hlink = parent->hash[h];
parent->hash[h] = die;
}
return die;
}
static void
mkindex(DWDie *die)
{
die->hash = mal(HASHSIZE * sizeof(DWDie*));
}
// Find child by AT_name using hashtable if available or linear scan
// if not.
static DWDie*
find(DWDie *die, char* name)
{
DWDie *a, *b;
int h;
if (die->hash == nil) {
for (a = die->child; a != nil; a = a->link)
if (strcmp(name, getattr(a, DW_AT_name)->data) == 0)
return a;
return nil;
}
h = hashstr(name);
a = die->hash[h];
if (a == nil)
return nil;
if (strcmp(name, getattr(a, DW_AT_name)->data) == 0)
return a;
// Move found ones to head of the list.
b = a->hlink;
while (b != nil) {
if (strcmp(name, getattr(b, DW_AT_name)->data) == 0) {
a->hlink = b->hlink;
b->hlink = die->hash[h];
die->hash[h] = b;
return b;
}
a = b;
b = b->hlink;
}
return nil;
}
static DWDie*
find_or_diag(DWDie *die, char* name)
{
DWDie *r;
r = find(die, name);
if (r == nil) {
diag("dwarf find: %s has no %s", getattr(die, DW_AT_name)->data, name);
errorexit();
}
return r;
}
static DWAttr*
newrefattr(DWDie *die, uint8 attr, DWDie* ref)
{
if (ref == nil)
return nil;
return newattr(die, attr, DW_CLS_REFERENCE, 0, (char*)ref);
}
static int fwdcount;
static void
putattr(int form, int cls, vlong value, char *data)
{
switch(form) {
case DW_FORM_addr: // address
addrput(value);
break;
case DW_FORM_block1: // block
value &= 0xff;
cput(value);
while(value--)
cput(*data++);
break;
case DW_FORM_block2: // block
value &= 0xffff;
WPUT(value);
while(value--)
cput(*data++);
break;
case DW_FORM_block4: // block
value &= 0xffffffff;
LPUT(value);
while(value--)
cput(*data++);
break;
case DW_FORM_block: // block
uleb128put(value);
while(value--)
cput(*data++);
break;
case DW_FORM_data1: // constant
cput(value);
break;
case DW_FORM_data2: // constant
WPUT(value);
break;
case DW_FORM_data4: // constant, {line,loclist,mac,rangelist}ptr
LPUT(value);
break;
case DW_FORM_data8: // constant, {line,loclist,mac,rangelist}ptr
VPUT(value);
break;
case DW_FORM_sdata: // constant
sleb128put(value);
break;
case DW_FORM_udata: // constant
uleb128put(value);
break;
case DW_FORM_string: // string
strnput(data, value+1);
break;
case DW_FORM_flag: // flag
cput(value?1:0);
break;
case DW_FORM_ref_addr: // reference to a DIE in the .info section
if (data == nil) {
diag("dwarf: null reference");
LPUT(0); // invalid dwarf, gdb will complain.
} else {
if (((DWDie*)data)->offs == 0)
fwdcount++;
LPUT(((DWDie*)data)->offs);
}
break;
case DW_FORM_ref1: // reference within the compilation unit
case DW_FORM_ref2: // reference
case DW_FORM_ref4: // reference
case DW_FORM_ref8: // reference
case DW_FORM_ref_udata: // reference
case DW_FORM_strp: // string
case DW_FORM_indirect: // (see Section 7.5.3)
default:
diag("dwarf: unsupported attribute form %d / class %d", form, cls);
errorexit();
}
}
// Note that we can (and do) add arbitrary attributes to a DIE, but
// only the ones actually listed in the Abbrev will be written out.
static void
putattrs(int abbrev, DWAttr* attr)
{
DWAttr *attrs[DW_AT_recursive + 1];
DWAttrForm* af;
memset(attrs, 0, sizeof attrs);
for( ; attr; attr = attr->link)
if (attr->atr < nelem(attrs))
attrs[attr->atr] = attr;
for(af = abbrevs[abbrev].attr; af->attr; af++)
if (attrs[af->attr])
putattr(af->form,
attrs[af->attr]->cls,
attrs[af->attr]->value,
attrs[af->attr]->data);
else
putattr(af->form, 0, 0, 0);
}
static void putdie(DWDie* die);
static void
putdies(DWDie* die)
{
for(; die; die = die->link)
putdie(die);
}
static void
putdie(DWDie* die)
{
die->offs = cpos() - infoo;
uleb128put(die->abbrev);
putattrs(die->abbrev, die->attr);
if (abbrevs[die->abbrev].children) {
putdies(die->child);
cput(0);
}
}
static void
reverselist(DWDie** list)
{
DWDie *curr, *prev;
curr = *list;
prev = nil;
while(curr != nil) {
DWDie* next = curr->link;
curr->link = prev;
prev = curr;
curr = next;
}
*list = prev;
}
static void
reversetree(DWDie** list)
{
DWDie *die;
reverselist(list);
for (die = *list; die != nil; die = die->link)
if (abbrevs[die->abbrev].children)
reversetree(&die->child);
}
static void
newmemberoffsetattr(DWDie *die, int32 offs)
{
char block[10];
int i;
i = 0;
if (offs != 0) {
block[i++] = DW_OP_consts;
i += sleb128enc(offs, block+i);
block[i++] = DW_OP_plus;
}
newattr(die, DW_AT_data_member_location, DW_CLS_BLOCK, i, mal(i));
memmove(die->attr->data, block, i);
}
// GDB doesn't like DW_FORM_addr for DW_AT_location, so emit a
// location expression that evals to a const.
static void
newabslocexprattr(DWDie *die, vlong addr)
{
char block[10];
int i;
i = 0;
block[i++] = DW_OP_constu;
i += uleb128enc(addr, block+i);
newattr(die, DW_AT_location, DW_CLS_BLOCK, i, mal(i));
memmove(die->attr->data, block, i);
}
// Decoding the type.* symbols. This has to be in sync with
// ../../pkg/runtime/type.go, or more specificaly, with what
// ../gc/reflect.c stuffs in these.
enum {
KindBool = 1,
KindInt,
KindInt8,
KindInt16,
KindInt32,
KindInt64,
KindUint,
KindUint8,
KindUint16,
KindUint32,
KindUint64,
KindUintptr,
KindFloat32,
KindFloat64,
KindComplex64,
KindComplex128,
KindArray,
KindChan,
KindFunc,
KindInterface,
KindMap,
KindPtr,
KindSlice,
KindString,
KindStruct,
KindUnsafePointer,
KindNoPointers = 1<<7,
// size of Type interface header + CommonType structure.
CommonSize = 2*PtrSize+ 4*PtrSize + 8,
};
static Reloc*
decode_reloc(Sym *s, int32 off)
{
int i;
for (i = 0; i < s->nr; i++)
if (s->r[i].off == off)
return s->r + i;
return nil;
}
static Sym*
decode_reloc_sym(Sym *s, int32 off)
{
Reloc *r;
r = decode_reloc(s,off);
if (r == nil)
return nil;
return r->sym;
}
static uvlong
decode_inuxi(uchar* p, int sz)
{
uint64 v;
uint32 l;
uchar *cast, *inuxi;
int i;
v = l = 0;
cast = nil;
inuxi = nil;
switch (sz) {
case 2:
cast = (uchar*)&l;
inuxi = inuxi2;
break;
case 4:
cast = (uchar*)&l;
inuxi = inuxi4;
break;
case 8:
cast = (uchar*)&v;
inuxi = inuxi8;
break;
default:
diag("dwarf: decode inuxi %d", sz);
errorexit();
}
for (i = 0; i < sz; i++)
cast[inuxi[i]] = p[i];
if (sz == 8)
return v;
return l;
}
// Type.commonType.kind
static uint8
decodetype_kind(Sym *s)
{
return s->p[3*PtrSize + 7] & ~KindNoPointers; // 0x13 / 0x1f
}
// Type.commonType.size
static vlong
decodetype_size(Sym *s)
{
return decode_inuxi(s->p + 2*PtrSize, PtrSize); // 0x8 / 0x10
}
// Type.ArrayType.elem and Type.SliceType.Elem
static Sym*
decodetype_arrayelem(Sym *s)
{
return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30
}
static vlong
decodetype_arraylen(Sym *s)
{
return decode_inuxi(s->p + CommonSize+PtrSize, PtrSize);
}
// Type.PtrType.elem
static Sym*
decodetype_ptrelem(Sym *s)
{
return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30
}
// Type.MapType.key, elem
static Sym*
decodetype_mapkey(Sym *s)
{
return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30
}
static Sym*
decodetype_mapvalue(Sym *s)
{
return decode_reloc_sym(s, CommonSize+PtrSize); // 0x20 / 0x38
}
// Type.ChanType.elem
static Sym*
decodetype_chanelem(Sym *s)
{
return decode_reloc_sym(s, CommonSize); // 0x1c / 0x30
}
// Type.FuncType.dotdotdot
static int
decodetype_funcdotdotdot(Sym *s)
{
return s->p[CommonSize];
}
// Type.FuncType.in.len
static int
decodetype_funcincount(Sym *s)
{
return decode_inuxi(s->p + CommonSize+2*PtrSize, 4);
}
static int
decodetype_funcoutcount(Sym *s)
{
return decode_inuxi(s->p + CommonSize+3*PtrSize + 2*4, 4);
}
static Sym*
decodetype_funcintype(Sym *s, int i)
{
Reloc *r;
r = decode_reloc(s, CommonSize + PtrSize);
if (r == nil)
return nil;
return decode_reloc_sym(r->sym, r->add + i * PtrSize);
}
static Sym*
decodetype_funcouttype(Sym *s, int i)
{
Reloc *r;
r = decode_reloc(s, CommonSize + 2*PtrSize + 2*4);
if (r == nil)
return nil;
return decode_reloc_sym(r->sym, r->add + i * PtrSize);
}
// Type.StructType.fields.Slice::len
static int
decodetype_structfieldcount(Sym *s)
{
return decode_inuxi(s->p + CommonSize + PtrSize, 4);
}
enum {
StructFieldSize = 5*PtrSize
};
// Type.StructType.fields[]-> name, typ and offset.
static char*
decodetype_structfieldname(Sym *s, int i)
{
Reloc *r;
// go.string."foo" 0x28 / 0x40
s = decode_reloc_sym(s, CommonSize + PtrSize + 2*4 + i*StructFieldSize);
if (s == nil) // embedded structs have a nil name.
return nil;
r = decode_reloc(s, 0); // s has a pointer to the string data at offset 0
if (r == nil) // shouldn't happen.
return nil;
return (char*) r->sym->p + r->add; // the c-string
}
static Sym*
decodetype_structfieldtype(Sym *s, int i)
{
return decode_reloc_sym(s, CommonSize + PtrSize + 2*4 + i*StructFieldSize + 2*PtrSize);
}
static vlong
decodetype_structfieldoffs(Sym *s, int i)
{
return decode_inuxi(s->p + CommonSize + PtrSize + 2*4 + i*StructFieldSize + 4*PtrSize, 4);
}
// InterfaceTYpe.methods.len
static vlong
decodetype_ifacemethodcount(Sym *s)
{
return decode_inuxi(s->p + CommonSize + PtrSize, 4);
}
// Fake attributes for slices, maps and channel
enum {
DW_AT_internal_elem_type = 250, // channels and slices
DW_AT_internal_key_type = 251, // maps
DW_AT_internal_val_type = 252, // maps
DW_AT_internal_location = 253, // params and locals
};
static DWDie* defptrto(DWDie *dwtype); // below
// Lookup predefined types
static Sym*
lookup_or_diag(char *n)
{
Sym *s;
s = rlookup(n, 0);
if (s == nil || s->size == 0) {
diag("dwarf: missing type: %s", n);
errorexit();
}
return s;
}
// Define gotype, for composite ones recurse into constituents.
static DWDie*
defgotype(Sym *gotype)
{
DWDie *die, *fld;
Sym *s;
char *name, *f;
uint8 kind;
vlong bytesize;
int i, nfields;
if (gotype == nil)
return find_or_diag(&dwtypes, "<unspecified>");
if (strncmp("type.", gotype->name, 5) != 0) {
diag("dwarf: type name doesn't start with \".type\": %s", gotype->name);
return find_or_diag(&dwtypes, "<unspecified>");
}
name = gotype->name + 5; // could also decode from Type.string
die = find(&dwtypes, name);
if (die != nil)
return die;
if (0 && debug['v'] > 2)
print("new type: %Y\n", gotype);
kind = decodetype_kind(gotype);
bytesize = decodetype_size(gotype);
switch (kind) {
case KindBool:
die = newdie(&dwtypes, DW_ABRV_BASETYPE, name);
newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_boolean, 0);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
break;
case KindInt:
case KindInt8:
case KindInt16:
case KindInt32:
case KindInt64:
die = newdie(&dwtypes, DW_ABRV_BASETYPE, name);
newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_signed, 0);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
break;
case KindUint:
case KindUint8:
case KindUint16:
case KindUint32:
case KindUint64:
case KindUintptr:
die = newdie(&dwtypes, DW_ABRV_BASETYPE, name);
newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_unsigned, 0);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
break;
case KindFloat32:
case KindFloat64:
die = newdie(&dwtypes, DW_ABRV_BASETYPE, name);
newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_float, 0);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
break;
case KindComplex64:
case KindComplex128:
die = newdie(&dwtypes, DW_ABRV_BASETYPE, name);
newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_complex_float, 0);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
break;
case KindArray:
die = newdie(&dwtypes, DW_ABRV_ARRAYTYPE, name);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
s = decodetype_arrayelem(gotype);
newrefattr(die, DW_AT_type, defgotype(s));
fld = newdie(die, DW_ABRV_ARRAYRANGE, "range");
newattr(fld, DW_AT_upper_bound, DW_CLS_CONSTANT, decodetype_arraylen(gotype), 0);
newrefattr(fld, DW_AT_type, find_or_diag(&dwtypes, "uintptr"));
break;
case KindChan:
die = newdie(&dwtypes, DW_ABRV_CHANTYPE, name);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
s = decodetype_chanelem(gotype);
newrefattr(die, DW_AT_internal_elem_type, defgotype(s));
break;
case KindFunc:
die = newdie(&dwtypes, DW_ABRV_FUNCTYPE, name);
newrefattr(die, DW_AT_type, find_or_diag(&dwtypes, "void"));
nfields = decodetype_funcincount(gotype);
for (i = 0; i < nfields; i++) {
s = decodetype_funcintype(gotype, i);
fld = newdie(die, DW_ABRV_FUNCTYPEPARAM, s->name+5);
newrefattr(fld, DW_AT_type, defgotype(s));
}
if (decodetype_funcdotdotdot(gotype))
newdie(die, DW_ABRV_DOTDOTDOT, "...");
nfields = decodetype_funcoutcount(gotype);
for (i = 0; i < nfields; i++) {
s = decodetype_funcouttype(gotype, i);
fld = newdie(die, DW_ABRV_FUNCTYPEPARAM, s->name+5);
newrefattr(fld, DW_AT_type, defptrto(defgotype(s)));
}
break;
case KindInterface:
die = newdie(&dwtypes, DW_ABRV_IFACETYPE, name);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
nfields = decodetype_ifacemethodcount(gotype);
if (nfields == 0)
s = lookup_or_diag("type.runtime.eface");
else
s = lookup_or_diag("type.runtime.iface");
newrefattr(die, DW_AT_type, defgotype(s));
break;
case KindMap:
die = newdie(&dwtypes, DW_ABRV_MAPTYPE, name);
s = decodetype_mapkey(gotype);
newrefattr(die, DW_AT_internal_key_type, defgotype(s));
s = decodetype_mapvalue(gotype);
newrefattr(die, DW_AT_internal_val_type, defgotype(s));
break;
case KindPtr:
die = newdie(&dwtypes, DW_ABRV_PTRTYPE, name);
s = decodetype_ptrelem(gotype);
newrefattr(die, DW_AT_type, defgotype(s));
break;
case KindSlice:
die = newdie(&dwtypes, DW_ABRV_SLICETYPE, name);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
s = decodetype_arrayelem(gotype);
newrefattr(die, DW_AT_internal_elem_type, defgotype(s));
break;
case KindString:
die = newdie(&dwtypes, DW_ABRV_STRINGTYPE, name);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
break;
case KindStruct:
die = newdie(&dwtypes, DW_ABRV_STRUCTTYPE, name);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, bytesize, 0);
nfields = decodetype_structfieldcount(gotype);
for (i = 0; i < nfields; i++) {
f = decodetype_structfieldname(gotype, i);
s = decodetype_structfieldtype(gotype, i);
if (f == nil)
f = s->name + 5; // skip "type."
fld = newdie(die, DW_ABRV_STRUCTFIELD, f);
newrefattr(fld, DW_AT_type, defgotype(s));
newmemberoffsetattr(fld, decodetype_structfieldoffs(gotype, i));
}
break;
case KindUnsafePointer:
die = newdie(&dwtypes, DW_ABRV_PTRTYPE, name);
newrefattr(die, DW_AT_type, find(&dwtypes, "void"));
break;
default:
diag("dwarf: definition of unknown kind %d: %s", kind, gotype->name);
die = newdie(&dwtypes, DW_ABRV_TYPEDECL, name);
newrefattr(die, DW_AT_type, find_or_diag(&dwtypes, "<unspecified>"));
}
return die;
}
// Find or construct *T given T.
static DWDie*
defptrto(DWDie *dwtype)
{
char ptrname[1024];
DWDie *die;
snprint(ptrname, sizeof ptrname, "*%s", getattr(dwtype, DW_AT_name)->data);
die = find(&dwtypes, ptrname);
if (die == nil) {
die = newdie(&dwtypes, DW_ABRV_PTRTYPE,
strcpy(mal(strlen(ptrname)+1), ptrname));
newrefattr(die, DW_AT_type, dwtype);
}
return die;
}
// Copies src's children into dst. Copies attributes by value.
// DWAttr.data is copied as pointer only.
static void
copychildren(DWDie *dst, DWDie *src)
{
DWDie *c;
DWAttr *a;
for (src = src->child; src != nil; src = src->link) {
c = newdie(dst, src->abbrev, getattr(src, DW_AT_name)->data);
for (a = src->attr; a != nil; a = a->link)
newattr(c, a->atr, a->cls, a->value, a->data);
copychildren(c, src);
}
reverselist(&dst->child);
}
// Search children (assumed to have DW_TAG_member) for the one named
// field and set its DW_AT_type to dwtype
static void
substitutetype(DWDie *structdie, char *field, DWDie* dwtype)
{
DWDie *child;
DWAttr *a;
child = find_or_diag(structdie, field);
if (child == nil)
return;
a = getattr(child, DW_AT_type);
if (a != nil)
a->data = (char*) dwtype;
else
newrefattr(child, DW_AT_type, dwtype);
}
static void
synthesizestringtypes(DWDie* die)
{
DWDie *prototype;
prototype = defgotype(lookup_or_diag("type.runtime._string"));
if (prototype == nil)
return;
for (; die != nil; die = die->link) {
if (die->abbrev != DW_ABRV_STRINGTYPE)
continue;
copychildren(die, prototype);
}
}
static void
synthesizeslicetypes(DWDie *die)
{
DWDie *prototype, *elem;
prototype = defgotype(lookup_or_diag("type.runtime.slice"));
if (prototype == nil)
return;
for (; die != nil; die = die->link) {
if (die->abbrev != DW_ABRV_SLICETYPE)
continue;
copychildren(die, prototype);
elem = (DWDie*) getattr(die, DW_AT_internal_elem_type)->data;
substitutetype(die, "array", defptrto(elem));
}
}
static char*
mkinternaltypename(char *base, char *arg1, char *arg2)
{
char buf[1024];
char *n;
if (arg2 == nil)
snprint(buf, sizeof buf, "%s<%s>", base, arg1);
else
snprint(buf, sizeof buf, "%s<%s,%s>", base, arg1, arg2);
n = mal(strlen(buf) + 1);
memmove(n, buf, strlen(buf));
return n;
}
// synthesizemaptypes is way too closely married to runtime/hashmap.c
enum {
MaxValsize = 256 - 64
};
static void
synthesizemaptypes(DWDie *die)
{
DWDie *hash, *hash_subtable, *hash_entry,
*dwh, *dwhs, *dwhe, *dwhash, *keytype, *valtype, *fld;
int hashsize, keysize, valsize, datsize, valsize_in_hash, datavo;
DWAttr *a;
hash = defgotype(lookup_or_diag("type.runtime.hmap"));
hash_subtable = defgotype(lookup_or_diag("type.runtime.hash_subtable"));
hash_entry = defgotype(lookup_or_diag("type.runtime.hash_entry"));
if (hash == nil || hash_subtable == nil || hash_entry == nil)
return;
dwhash = (DWDie*)getattr(find_or_diag(hash_entry, "hash"), DW_AT_type)->data;
if (dwhash == nil)
return;
hashsize = getattr(dwhash, DW_AT_byte_size)->value;
for (; die != nil; die = die->link) {
if (die->abbrev != DW_ABRV_MAPTYPE)
continue;
keytype = (DWDie*) getattr(die, DW_AT_internal_key_type)->data;
valtype = (DWDie*) getattr(die, DW_AT_internal_val_type)->data;
a = getattr(keytype, DW_AT_byte_size);
keysize = a ? a->value : PtrSize; // We don't store size with Pointers
a = getattr(valtype, DW_AT_byte_size);
valsize = a ? a->value : PtrSize;
// This is what happens in hash_init and makemap_c
valsize_in_hash = valsize;
if (valsize > MaxValsize)
valsize_in_hash = PtrSize;
datavo = keysize;
if (valsize_in_hash >= PtrSize)
datavo = rnd(keysize, PtrSize);
datsize = datavo + valsize_in_hash;
if (datsize < PtrSize)
datsize = PtrSize;
datsize = rnd(datsize, PtrSize);
// Construct struct hash_entry<K,V>
dwhe = newdie(&dwtypes, DW_ABRV_STRUCTTYPE,
mkinternaltypename("hash_entry",
getattr(keytype, DW_AT_name)->data,
getattr(valtype, DW_AT_name)->data));
fld = newdie(dwhe, DW_ABRV_STRUCTFIELD, "hash");
newrefattr(fld, DW_AT_type, dwhash);
newmemberoffsetattr(fld, 0);
fld = newdie(dwhe, DW_ABRV_STRUCTFIELD, "key");
newrefattr(fld, DW_AT_type, keytype);
newmemberoffsetattr(fld, hashsize);
fld = newdie(dwhe, DW_ABRV_STRUCTFIELD, "val");
if (valsize > MaxValsize)
valtype = defptrto(valtype);
newrefattr(fld, DW_AT_type, valtype);
newmemberoffsetattr(fld, hashsize + datavo);
newattr(dwhe, DW_AT_byte_size, DW_CLS_CONSTANT, hashsize + datsize, nil);
// Construct hash_subtable<hash_entry<K,V>>
dwhs = newdie(&dwtypes, DW_ABRV_STRUCTTYPE,
mkinternaltypename("hash_subtable",
getattr(keytype, DW_AT_name)->data,
getattr(valtype, DW_AT_name)->data));
copychildren(dwhs, hash_subtable);
substitutetype(dwhs, "last", defptrto(dwhe));
substitutetype(dwhs, "entry", dwhe); // todo: []hash_entry with dynamic size
newattr(dwhs, DW_AT_byte_size, DW_CLS_CONSTANT,
getattr(hash_subtable, DW_AT_byte_size)->value, nil);
// Construct hash<K,V>
dwh = newdie(&dwtypes, DW_ABRV_STRUCTTYPE,
mkinternaltypename("hash",
getattr(keytype, DW_AT_name)->data,
getattr(valtype, DW_AT_name)->data));
copychildren(dwh, hash);
substitutetype(dwh, "st", defptrto(dwhs));
newattr(dwh, DW_AT_byte_size, DW_CLS_CONSTANT,
getattr(hash, DW_AT_byte_size)->value, nil);
newrefattr(die, DW_AT_type, defptrto(dwh));
}
}
static void
synthesizechantypes(DWDie *die)
{
DWDie *sudog, *waitq, *hchan,
*dws, *dww, *dwh, *elemtype;
DWAttr *a;
int elemsize, sudogsize;
sudog = defgotype(lookup_or_diag("type.runtime.sudog"));
waitq = defgotype(lookup_or_diag("type.runtime.waitq"));
hchan = defgotype(lookup_or_diag("type.runtime.hchan"));
if (sudog == nil || waitq == nil || hchan == nil)
return;
sudogsize = getattr(sudog, DW_AT_byte_size)->value;
for (; die != nil; die = die->link) {
if (die->abbrev != DW_ABRV_CHANTYPE)
continue;
elemtype = (DWDie*) getattr(die, DW_AT_internal_elem_type)->data;
a = getattr(elemtype, DW_AT_byte_size);
elemsize = a ? a->value : PtrSize;
// sudog<T>
dws = newdie(&dwtypes, DW_ABRV_STRUCTTYPE,
mkinternaltypename("sudog",
getattr(elemtype, DW_AT_name)->data, nil));
copychildren(dws, sudog);
substitutetype(dws, "elem", elemtype);
newattr(dws, DW_AT_byte_size, DW_CLS_CONSTANT,
sudogsize + (elemsize > 8 ? elemsize - 8 : 0), nil);
// waitq<T>
dww = newdie(&dwtypes, DW_ABRV_STRUCTTYPE,
mkinternaltypename("waitq", getattr(elemtype, DW_AT_name)->data, nil));
copychildren(dww, waitq);
substitutetype(dww, "first", defptrto(dws));
substitutetype(dww, "last", defptrto(dws));
newattr(dww, DW_AT_byte_size, DW_CLS_CONSTANT,
getattr(waitq, DW_AT_byte_size)->value, nil);
// hchan<T>
dwh = newdie(&dwtypes, DW_ABRV_STRUCTTYPE,
mkinternaltypename("hchan", getattr(elemtype, DW_AT_name)->data, nil));
copychildren(dwh, hchan);
substitutetype(dwh, "recvq", dww);
substitutetype(dwh, "sendq", dww);
newattr(dwh, DW_AT_byte_size, DW_CLS_CONSTANT,
getattr(hchan, DW_AT_byte_size)->value, nil);
newrefattr(die, DW_AT_type, defptrto(dwh));
}
}
// For use with pass.c::genasmsym
static void
defdwsymb(Sym* sym, char *s, int t, vlong v, vlong size, int ver, Sym *gotype)
{
DWDie *dv, *dt;
USED(size);
if (strncmp(s, "go.string.", 10) == 0)
return;
if (strncmp(s, "type.", 5) == 0 && strcmp(s, "type.*") != 0) {
defgotype(sym);
return;
}
dv = nil;
switch (t) {
default:
return;
case 'd':
case 'b':
case 'D':
case 'B':
dv = newdie(&dwglobals, DW_ABRV_VARIABLE, s);
newabslocexprattr(dv, v);
if (ver == 0)
newattr(dv, DW_AT_external, DW_CLS_FLAG, 1, 0);
// fallthrough
case 'a':
case 'p':
dt = defgotype(gotype);
}
if (dv != nil)
newrefattr(dv, DW_AT_type, dt);
}
// TODO(lvd) For now, just append them all to the first compilation
// unit (that should be main), in the future distribute them to the
// appropriate compilation units.
static void
movetomodule(DWDie *parent)
{
DWDie *die;
for (die = dwroot.child->child; die->link != nil; die = die->link) /* nix */;
die->link = parent->child;
}
/*
* Filename fragments for the line history stack.
*/
static char **ftab;
static int ftabsize;
void
dwarfaddfrag(int n, char *frag)
{
int s;
if (n >= ftabsize) {
s = ftabsize;
ftabsize = 1 + n + (n >> 2);
ftab = realloc(ftab, ftabsize * sizeof(ftab[0]));
memset(ftab + s, 0, (ftabsize - s) * sizeof(ftab[0]));
}
if (*frag == '<')
frag++;
ftab[n] = frag;
}
// Returns a malloc'ed string, piecewise copied from the ftab.
static char *
decodez(char *s)
{
int len, o;
char *ss, *f;
char *r, *rb, *re;
len = 0;
ss = s + 1; // first is 0
while((o = ((uint8)ss[0] << 8) | (uint8)ss[1]) != 0) {
if (o < 0 || o >= ftabsize) {
diag("dwarf: corrupt z entry");
return 0;
}
f = ftab[o];
if (f == nil) {
diag("dwarf: corrupt z entry");
return 0;
}
len += strlen(f) + 1; // for the '/'
ss += 2;
}
if (len == 0)
return 0;
r = malloc(len + 1);
rb = r;
re = rb + len + 1;
s++;
while((o = ((uint8)s[0] << 8) | (uint8)s[1]) != 0) {
f = ftab[o];
if (rb == r || rb[-1] == '/')
rb = seprint(rb, re, "%s", f);
else
rb = seprint(rb, re, "/%s", f);
s += 2;
}
return r;
}
/*
* The line history itself
*/
static char **histfile; // [0] holds "<eof>", DW_LNS_set_file arguments must be > 0.
static int histfilesize;
static int histfilecap;
static void
clearhistfile(void)
{
int i;
// [0] holds "<eof>"
for (i = 1; i < histfilesize; i++)
free(histfile[i]);
histfilesize = 0;
}
static int
addhistfile(char *zentry)
{
char *fname;
if (histfilesize == histfilecap) {
histfilecap = 2 * histfilecap + 2;
histfile = realloc(histfile, histfilecap * sizeof(char*));
}
if (histfilesize == 0)
histfile[histfilesize++] = "<eof>";
fname = decodez(zentry);
// print("addhistfile %d: %s\n", histfilesize, fname);
if (fname == 0)
return -1;
// Don't fill with duplicates (check only top one).
if (strcmp(fname, histfile[histfilesize-1]) == 0) {
free(fname);
return histfilesize - 1;
}
histfile[histfilesize++] = fname;
return histfilesize - 1;
}
// if the histfile stack contains ..../runtime/runtime_defs.go
// use that to set gdbscript
static void
finddebugruntimepath(void)
{
int i, l;
char *c;
for (i = 1; i < histfilesize; i++) {
if ((c = strstr(histfile[i], "runtime/runtime_defs.go")) != nil) {
l = c - histfile[i];
memmove(gdbscript, histfile[i], l);
memmove(gdbscript + l, "runtime/runtime-gdb.py", strlen("runtime/runtime-gdb.py") + 1);
break;
}
}
}
// Go's runtime C sources are sane, and Go sources nest only 1 level,
// so a handful would be plenty, if it weren't for the fact that line
// directives can push an unlimited number of them.
static struct {
int file;
vlong line;
} *includestack;
static int includestacksize;
static int includetop;
static vlong absline;
typedef struct Linehist Linehist;
struct Linehist {
Linehist *link;
vlong absline;
vlong line;
int file;
};
static Linehist *linehist;
static void
checknesting(void)
{
if (includetop < 0) {
diag("dwarf: corrupt z stack");
errorexit();
}
if (includetop >= includestacksize) {
includestacksize += 1;
includestacksize <<= 2;
// print("checknesting: growing to %d\n", includestacksize);
includestack = realloc(includestack, includestacksize * sizeof *includestack);
}
}
/*
* Return false if the a->link chain contains no history, otherwise
* returns true and finds z and Z entries in the Auto list (of a
* Prog), and resets the history stack
*/
static int
inithist(Auto *a)
{
Linehist *lh;
for (; a; a = a->link)
if (a->type == D_FILE)
break;
if (a==nil)
return 0;
// We have a new history. They are guaranteed to come completely
// at the beginning of the compilation unit.
if (a->aoffset != 1) {
diag("dwarf: stray 'z' with offset %d", a->aoffset);
return 0;
}
// Clear the history.
clearhistfile();
includetop = 0;
checknesting();
includestack[includetop].file = 0;
includestack[includetop].line = -1;
absline = 0;
while (linehist != nil) {
lh = linehist->link;
free(linehist);
linehist = lh;
}
// Construct the new one.
for (; a; a = a->link) {
if (a->type == D_FILE) { // 'z'
int f = addhistfile(a->asym->name);
if (f < 0) { // pop file
includetop--;
checknesting();
} else { // pushed a file (potentially same)
includestack[includetop].line += a->aoffset - absline;
includetop++;
checknesting();
includestack[includetop].file = f;
includestack[includetop].line = 1;
}
absline = a->aoffset;
} else if (a->type == D_FILE1) { // 'Z'
// We could just fixup the current
// linehist->line, but there doesn't appear to
// be a guarantee that every 'Z' is preceded
// by its own 'z', so do the safe thing and
// update the stack and push a new Linehist
// entry
includestack[includetop].line = a->aoffset;
} else
continue;
if (linehist == 0 || linehist->absline != absline) {
Linehist* lh = malloc(sizeof *lh);
lh->link = linehist;
lh->absline = absline;
linehist = lh;
}
linehist->file = includestack[includetop].file;
linehist->line = includestack[includetop].line;
}
return 1;
}
static Linehist *
searchhist(vlong absline)
{
Linehist *lh;
for (lh = linehist; lh; lh = lh->link)
if (lh->absline <= absline)
break;
return lh;
}
static int
guesslang(char *s)
{
if(strlen(s) >= 3 && strcmp(s+strlen(s)-3, ".go") == 0)
return DW_LANG_Go;
return DW_LANG_C;
}
/*
* Generate short opcodes when possible, long ones when neccesary.
* See section 6.2.5
*/
enum {
LINE_BASE = -1,
LINE_RANGE = 4,
OPCODE_BASE = 5
};
static void
putpclcdelta(vlong delta_pc, vlong delta_lc)
{
if (LINE_BASE <= delta_lc && delta_lc < LINE_BASE+LINE_RANGE) {
vlong opcode = OPCODE_BASE + (delta_lc - LINE_BASE) + (LINE_RANGE * delta_pc);
if (OPCODE_BASE <= opcode && opcode < 256) {
cput(opcode);
return;
}
}
if (delta_pc) {
cput(DW_LNS_advance_pc);
sleb128put(delta_pc);
}
cput(DW_LNS_advance_line);
sleb128put(delta_lc);
cput(DW_LNS_copy);
}
static void
newcfaoffsetattr(DWDie *die, int32 offs)
{
char block[10];
int i;
i = 0;
block[i++] = DW_OP_call_frame_cfa;
if (offs != 0) {
block[i++] = DW_OP_consts;
i += sleb128enc(offs, block+i);
block[i++] = DW_OP_plus;
}
newattr(die, DW_AT_location, DW_CLS_BLOCK, i, mal(i));
memmove(die->attr->data, block, i);
}
static char*
mkvarname(char* name, int da)
{
char buf[1024];
char *n;
snprint(buf, sizeof buf, "%s#%d", name, da);
n = mal(strlen(buf) + 1);
memmove(n, buf, strlen(buf));
return n;
}
/*
* Walk prog table, emit line program and build DIE tree.
*/
// flush previous compilation unit.
static void
flushunit(DWDie *dwinfo, vlong pc, vlong unitstart, int32 header_length)
{
vlong here;
if (dwinfo != nil && pc != 0) {
newattr(dwinfo, DW_AT_high_pc, DW_CLS_ADDRESS, pc+1, 0);
}
if (unitstart >= 0) {
cput(0); // start extended opcode
uleb128put(1);
cput(DW_LNE_end_sequence);
here = cpos();
cseek(unitstart);
LPUT(here - unitstart - sizeof(int32)); // unit_length
WPUT(3); // dwarf version
LPUT(header_length); // header length starting here
cseek(here);
}
}
static void
writelines(void)
{
Prog *q;
Sym *s;
Auto *a;
vlong unitstart, headerend, offs;
vlong pc, epc, lc, llc, lline;
int currfile;
int i, lang, da, dt;
Linehist *lh;
DWDie *dwinfo, *dwfunc, *dwvar, **dws;
DWDie *varhash[HASHSIZE];
char *n, *nn;
unitstart = -1;
headerend = -1;
pc = 0;
epc = 0;
lc = 1;
llc = 1;
currfile = -1;
lineo = cpos();
dwinfo = nil;
for(cursym = textp; cursym != nil; cursym = cursym->next) {
s = cursym;
if(s->text == P)
continue;
// Look for history stack. If we find one,
// we're entering a new compilation unit
if (inithist(s->autom)) {
flushunit(dwinfo, epc, unitstart, headerend - unitstart - 10);
unitstart = cpos();
if(debug['v'] > 1) {
print("dwarf writelines found %s\n", histfile[1]);
Linehist* lh;
for (lh = linehist; lh; lh = lh->link)
print("\t%8lld: [%4lld]%s\n",
lh->absline, lh->line, histfile[lh->file]);
}
lang = guesslang(histfile[1]);
finddebugruntimepath();
dwinfo = newdie(&dwroot, DW_ABRV_COMPUNIT, strdup(histfile[1]));
newattr(dwinfo, DW_AT_language, DW_CLS_CONSTANT,lang, 0);
newattr(dwinfo, DW_AT_stmt_list, DW_CLS_PTR, unitstart - lineo, 0);
newattr(dwinfo, DW_AT_low_pc, DW_CLS_ADDRESS, s->text->pc, 0);
// Write .debug_line Line Number Program Header (sec 6.2.4)
// Fields marked with (*) must be changed for 64-bit dwarf
LPUT(0); // unit_length (*), will be filled in by flushunit.
WPUT(3); // dwarf version (appendix F)
LPUT(0); // header_length (*), filled in by flushunit.
// cpos == unitstart + 4 + 2 + 4
cput(1); // minimum_instruction_length
cput(1); // default_is_stmt
cput(LINE_BASE); // line_base
cput(LINE_RANGE); // line_range
cput(OPCODE_BASE); // opcode_base (we only use 1..4)
cput(0); // standard_opcode_lengths[1]
cput(1); // standard_opcode_lengths[2]
cput(1); // standard_opcode_lengths[3]
cput(1); // standard_opcode_lengths[4]
cput(0); // include_directories (empty)
for (i=1; i < histfilesize; i++) {
strnput(histfile[i], strlen(histfile[i]) + 4);
// 4 zeros: the string termination + 3 fields.
}
cput(0); // terminate file_names.
headerend = cpos();
pc = s->text->pc;
epc = pc;
currfile = 1;
lc = 1;
llc = 1;
cput(0); // start extended opcode
uleb128put(1 + PtrSize);
cput(DW_LNE_set_address);
addrput(pc);
}
if(s->text == nil)
continue;
if (unitstart < 0) {
diag("dwarf: reachable code before seeing any history: %P", s->text);
continue;
}
dwfunc = newdie(dwinfo, DW_ABRV_FUNCTION, s->name);
newattr(dwfunc, DW_AT_low_pc, DW_CLS_ADDRESS, s->value, 0);
epc = s->value + s->size;
newattr(dwfunc, DW_AT_high_pc, DW_CLS_ADDRESS, epc, 0);
if (s->version == 0)
newattr(dwfunc, DW_AT_external, DW_CLS_FLAG, 1, 0);
if(s->text->link == nil)
continue;
for(q = s->text; q != P; q = q->link) {
lh = searchhist(q->line);
if (lh == nil) {
diag("dwarf: corrupt history or bad absolute line: %P", q);
continue;
}
if (lh->file < 1) { // 0 is the past-EOF entry.
// diag("instruction with line number past EOF in %s: %P", histfile[1], q);
continue;
}
lline = lh->line + q->line - lh->absline;
if (debug['v'] > 1)
print("%6llux %s[%lld] %P\n", (vlong)q->pc, histfile[lh->file], lline, q);
if (q->line == lc)
continue;
if (currfile != lh->file) {
currfile = lh->file;
cput(DW_LNS_set_file);
uleb128put(currfile);
}
putpclcdelta(q->pc - pc, lline - llc);
pc = q->pc;
lc = q->line;
llc = lline;
}
da = 0;
dwfunc->hash = varhash; // enable indexing of children by name
memset(varhash, 0, sizeof varhash);
for(a = s->autom; a; a = a->link) {
switch (a->type) {
case D_AUTO:
dt = DW_ABRV_AUTO;
offs = a->aoffset - PtrSize;
break;
case D_PARAM:
dt = DW_ABRV_PARAM;
offs = a->aoffset;
break;
default:
continue;
}
if (strstr(a->asym->name, ".autotmp_"))
continue;
if (find(dwfunc, a->asym->name) != nil)
n = mkvarname(a->asym->name, da);
else
n = a->asym->name;
// Drop the package prefix from locals and arguments.
nn = strrchr(n, '.');
if (nn)
n = nn + 1;
dwvar = newdie(dwfunc, dt, n);
newcfaoffsetattr(dwvar, offs);
newrefattr(dwvar, DW_AT_type, defgotype(a->gotype));
// push dwvar down dwfunc->child to preserve order
newattr(dwvar, DW_AT_internal_location, DW_CLS_CONSTANT, offs, nil);
dwfunc->child = dwvar->link; // take dwvar out from the top of the list
for (dws = &dwfunc->child; *dws != nil; dws = &(*dws)->link)
if (offs > getattr(*dws, DW_AT_internal_location)->value)
break;
dwvar->link = *dws;
*dws = dwvar;
da++;
}
dwfunc->hash = nil;
}
flushunit(dwinfo, epc, unitstart, headerend - unitstart - 10);
linesize = cpos() - lineo;
}
/*
* Emit .debug_frame
*/
enum
{
CIERESERVE = 16,
DATAALIGNMENTFACTOR = -4, // TODO -PtrSize?
FAKERETURNCOLUMN = 16 // TODO gdb6 doesnt like > 15?
};
static void
putpccfadelta(vlong deltapc, vlong cfa)
{
if (deltapc < 0x40) {
cput(DW_CFA_advance_loc + deltapc);
} else if (deltapc < 0x100) {
cput(DW_CFA_advance_loc1);
cput(deltapc);
} else if (deltapc < 0x10000) {
cput(DW_CFA_advance_loc2);
WPUT(deltapc);
} else {
cput(DW_CFA_advance_loc4);
LPUT(deltapc);
}
cput(DW_CFA_def_cfa_offset_sf);
sleb128put(cfa / DATAALIGNMENTFACTOR);
}
static void
writeframes(void)
{
Prog *p, *q;
Sym *s;
vlong fdeo, fdesize, pad, cfa, pc;
frameo = cpos();
// Emit the CIE, Section 6.4.1
LPUT(CIERESERVE); // initial length, must be multiple of PtrSize
LPUT(0xffffffff); // cid.
cput(3); // dwarf version (appendix F)
cput(0); // augmentation ""
uleb128put(1); // code_alignment_factor
sleb128put(DATAALIGNMENTFACTOR); // guess
uleb128put(FAKERETURNCOLUMN); // return_address_register
cput(DW_CFA_def_cfa);
uleb128put(DWARFREGSP); // register SP (**ABI-dependent, defined in l.h)
uleb128put(PtrSize); // offset
cput(DW_CFA_offset + FAKERETURNCOLUMN); // return address
uleb128put(-PtrSize / DATAALIGNMENTFACTOR); // at cfa - x*4
// 4 is to exclude the length field.
pad = CIERESERVE + frameo + 4 - cpos();
if (pad < 0) {
diag("dwarf: CIERESERVE too small by %lld bytes.", -pad);
errorexit();
}
strnput("", pad);
for(cursym = textp; cursym != nil; cursym = cursym->next) {
s = cursym;
if(s->text == nil)
continue;
fdeo = cpos();
// Emit a FDE, Section 6.4.1, starting wit a placeholder.
LPUT(0); // length, must be multiple of PtrSize
LPUT(0); // Pointer to the CIE above, at offset 0
addrput(0); // initial location
addrput(0); // address range
cfa = PtrSize; // CFA starts at sp+PtrSize
p = s->text;
pc = p->pc;
for(q = p; q->link != P; q = q->link) {
if (q->spadj == 0)
continue;
cfa += q->spadj;
putpccfadelta(q->link->pc - pc, cfa);
pc = q->link->pc;
}
fdesize = cpos() - fdeo - 4; // exclude the length field.
pad = rnd(fdesize, PtrSize) - fdesize;
strnput("", pad);
fdesize += pad;
// Emit the FDE header for real, Section 6.4.1.
cseek(fdeo);
LPUT(fdesize);
LPUT(0);
addrput(p->pc);
addrput(s->size);
cseek(fdeo + 4 + fdesize);
}
cflush();
framesize = cpos() - frameo;
}
/*
* Walk DWarfDebugInfoEntries, and emit .debug_info
*/
enum
{
COMPUNITHEADERSIZE = 4+2+4+1
};
static void
writeinfo(void)
{
DWDie *compunit;
vlong unitstart, here;
fwdcount = 0;
for (compunit = dwroot.child; compunit; compunit = compunit->link) {
unitstart = cpos();
// Write .debug_info Compilation Unit Header (sec 7.5.1)
// Fields marked with (*) must be changed for 64-bit dwarf
// This must match COMPUNITHEADERSIZE above.
LPUT(0); // unit_length (*), will be filled in later.
WPUT(3); // dwarf version (appendix F)
LPUT(0); // debug_abbrev_offset (*)
cput(PtrSize); // address_size
putdie(compunit);
here = cpos();
cseek(unitstart);
LPUT(here - unitstart - 4); // exclude the length field.
cseek(here);
}
cflush();
}
/*
* Emit .debug_pubnames/_types. _info must have been written before,
* because we need die->offs and infoo/infosize;
*/
static int
ispubname(DWDie *die) {
DWAttr *a;
switch(die->abbrev) {
case DW_ABRV_FUNCTION:
case DW_ABRV_VARIABLE:
a = getattr(die, DW_AT_external);
return a && a->value;
}
return 0;
}
static int
ispubtype(DWDie *die) {
return die->abbrev >= DW_ABRV_NULLTYPE;
}
static vlong
writepub(int (*ispub)(DWDie*))
{
DWDie *compunit, *die;
DWAttr *dwa;
vlong unitstart, unitend, sectionstart, here;
sectionstart = cpos();
for (compunit = dwroot.child; compunit != nil; compunit = compunit->link) {
unitstart = compunit->offs - COMPUNITHEADERSIZE;
if (compunit->link != nil)
unitend = compunit->link->offs - COMPUNITHEADERSIZE;
else
unitend = infoo + infosize;
// Write .debug_pubnames/types Header (sec 6.1.1)
LPUT(0); // unit_length (*), will be filled in later.
WPUT(2); // dwarf version (appendix F)
LPUT(unitstart); // debug_info_offset (of the Comp unit Header)
LPUT(unitend - unitstart); // debug_info_length
for (die = compunit->child; die != nil; die = die->link) {
if (!ispub(die)) continue;
LPUT(die->offs - unitstart);
dwa = getattr(die, DW_AT_name);
strnput(dwa->data, dwa->value + 1);
}
LPUT(0);
here = cpos();
cseek(sectionstart);
LPUT(here - sectionstart - 4); // exclude the length field.
cseek(here);
}
return sectionstart;
}
/*
* emit .debug_aranges. _info must have been written before,
* because we need die->offs of dw_globals.
*/
static vlong
writearanges(void)
{
DWDie *compunit;
DWAttr *b, *e;
int headersize;
vlong sectionstart;
sectionstart = cpos();
headersize = rnd(4+2+4+1+1, PtrSize); // don't count unit_length field itself
for (compunit = dwroot.child; compunit != nil; compunit = compunit->link) {
b = getattr(compunit, DW_AT_low_pc);
if (b == nil)
continue;
e = getattr(compunit, DW_AT_high_pc);
if (e == nil)
continue;
// Write .debug_aranges Header + entry (sec 6.1.2)
LPUT(headersize + 4*PtrSize - 4); // unit_length (*)
WPUT(2); // dwarf version (appendix F)
LPUT(compunit->offs - COMPUNITHEADERSIZE); // debug_info_offset
cput(PtrSize); // address_size
cput(0); // segment_size
strnput("", headersize - (4+2+4+1+1)); // align to PtrSize
addrput(b->value);
addrput(e->value - b->value);
addrput(0);
addrput(0);
}
cflush();
return sectionstart;
}
static vlong
writegdbscript(void)
{
vlong sectionstart;
sectionstart = cpos();
if (gdbscript[0]) {
cput(1); // magic 1 byte?
strnput(gdbscript, strlen(gdbscript)+1);
cflush();
}
return sectionstart;
}
static void
align(vlong size)
{
if(HEADTYPE == Hwindows) // Only Windows PE need section align.
strnput("", rnd(size, PEFILEALIGN) - size);
}
/*
* This is the main entry point for generating dwarf. After emitting
* the mandatory debug_abbrev section, it calls writelines() to set up
* the per-compilation unit part of the DIE tree, while simultaneously
* emitting the debug_line section. When the final tree contains
* forward references, it will write the debug_info section in 2
* passes.
*
*/
void
dwarfemitdebugsections(void)
{
vlong infoe;
DWDie* die;
if(debug['w']) // disable dwarf
return;
// For diagnostic messages.
newattr(&dwtypes, DW_AT_name, DW_CLS_STRING, strlen("dwtypes"), "dwtypes");
mkindex(&dwroot);
mkindex(&dwtypes);
mkindex(&dwglobals);
// Some types that must exist to define other ones.
newdie(&dwtypes, DW_ABRV_NULLTYPE, "<unspecified>");
newdie(&dwtypes, DW_ABRV_NULLTYPE, "void");
newrefattr(newdie(&dwtypes, DW_ABRV_PTRTYPE, "unsafe.Pointer"),
DW_AT_type, find(&dwtypes, "void"));
die = newdie(&dwtypes, DW_ABRV_BASETYPE, "uintptr"); // needed for array size
newattr(die, DW_AT_encoding, DW_CLS_CONSTANT, DW_ATE_unsigned, 0);
newattr(die, DW_AT_byte_size, DW_CLS_CONSTANT, PtrSize, 0);
// Needed by the prettyprinter code for interface inspection.
defgotype(lookup_or_diag("type.runtime.commonType"));
defgotype(lookup_or_diag("type.runtime.InterfaceType"));
defgotype(lookup_or_diag("type.runtime.itab"));
genasmsym(defdwsymb);
writeabbrev();
align(abbrevsize);
writelines();
align(linesize);
writeframes();
align(framesize);
synthesizestringtypes(dwtypes.child);
synthesizeslicetypes(dwtypes.child);
synthesizemaptypes(dwtypes.child);
synthesizechantypes(dwtypes.child);
reversetree(&dwroot.child);
reversetree(&dwtypes.child);
reversetree(&dwglobals.child);
movetomodule(&dwtypes);
movetomodule(&dwglobals);
infoo = cpos();
writeinfo();
infoe = cpos();
pubnameso = infoe;
pubtypeso = infoe;
arangeso = infoe;
gdbscripto = infoe;
if (fwdcount > 0) {
if (debug['v'])
Bprint(&bso, "%5.2f dwarf pass 2.\n", cputime());
cseek(infoo);
writeinfo();
if (fwdcount > 0) {
diag("dwarf: unresolved references after first dwarf info pass");
errorexit();
}
if (infoe != cpos()) {
diag("dwarf: inconsistent second dwarf info pass");
errorexit();
}
}
infosize = infoe - infoo;
align(infosize);
pubnameso = writepub(ispubname);
pubnamessize = cpos() - pubnameso;
align(pubnamessize);
pubtypeso = writepub(ispubtype);
pubtypessize = cpos() - pubtypeso;
align(pubtypessize);
arangeso = writearanges();
arangessize = cpos() - arangeso;
align(arangessize);
gdbscripto = writegdbscript();
gdbscriptsize = cpos() - gdbscripto;
align(gdbscriptsize);
}
/*
* Elf.
*/
enum
{
ElfStrDebugAbbrev,
ElfStrDebugAranges,
ElfStrDebugFrame,
ElfStrDebugInfo,
ElfStrDebugLine,
ElfStrDebugLoc,
ElfStrDebugMacinfo,
ElfStrDebugPubNames,
ElfStrDebugPubTypes,
ElfStrDebugRanges,
ElfStrDebugStr,
ElfStrGDBScripts,
NElfStrDbg
};
vlong elfstrdbg[NElfStrDbg];
void
dwarfaddshstrings(Sym *shstrtab)
{
if(debug['w']) // disable dwarf
return;
elfstrdbg[ElfStrDebugAbbrev] = addstring(shstrtab, ".debug_abbrev");
elfstrdbg[ElfStrDebugAranges] = addstring(shstrtab, ".debug_aranges");
elfstrdbg[ElfStrDebugFrame] = addstring(shstrtab, ".debug_frame");
elfstrdbg[ElfStrDebugInfo] = addstring(shstrtab, ".debug_info");
elfstrdbg[ElfStrDebugLine] = addstring(shstrtab, ".debug_line");
elfstrdbg[ElfStrDebugLoc] = addstring(shstrtab, ".debug_loc");
elfstrdbg[ElfStrDebugMacinfo] = addstring(shstrtab, ".debug_macinfo");
elfstrdbg[ElfStrDebugPubNames] = addstring(shstrtab, ".debug_pubnames");
elfstrdbg[ElfStrDebugPubTypes] = addstring(shstrtab, ".debug_pubtypes");
elfstrdbg[ElfStrDebugRanges] = addstring(shstrtab, ".debug_ranges");
elfstrdbg[ElfStrDebugStr] = addstring(shstrtab, ".debug_str");
elfstrdbg[ElfStrGDBScripts] = addstring(shstrtab, ".debug_gdb_scripts");
}
void
dwarfaddelfheaders(void)
{
ElfShdr *sh;
if(debug['w']) // disable dwarf
return;
sh = newElfShdr(elfstrdbg[ElfStrDebugAbbrev]);
sh->type = SHT_PROGBITS;
sh->off = abbrevo;
sh->size = abbrevsize;
sh->addralign = 1;
sh = newElfShdr(elfstrdbg[ElfStrDebugLine]);
sh->type = SHT_PROGBITS;
sh->off = lineo;
sh->size = linesize;
sh->addralign = 1;
sh = newElfShdr(elfstrdbg[ElfStrDebugFrame]);
sh->type = SHT_PROGBITS;
sh->off = frameo;
sh->size = framesize;
sh->addralign = 1;
sh = newElfShdr(elfstrdbg[ElfStrDebugInfo]);
sh->type = SHT_PROGBITS;
sh->off = infoo;
sh->size = infosize;
sh->addralign = 1;
if (pubnamessize > 0) {
sh = newElfShdr(elfstrdbg[ElfStrDebugPubNames]);
sh->type = SHT_PROGBITS;
sh->off = pubnameso;
sh->size = pubnamessize;
sh->addralign = 1;
}
if (pubtypessize > 0) {
sh = newElfShdr(elfstrdbg[ElfStrDebugPubTypes]);
sh->type = SHT_PROGBITS;
sh->off = pubtypeso;
sh->size = pubtypessize;
sh->addralign = 1;
}
if (arangessize) {
sh = newElfShdr(elfstrdbg[ElfStrDebugAranges]);
sh->type = SHT_PROGBITS;
sh->off = arangeso;
sh->size = arangessize;
sh->addralign = 1;
}
if (gdbscriptsize) {
sh = newElfShdr(elfstrdbg[ElfStrGDBScripts]);
sh->type = SHT_PROGBITS;
sh->off = gdbscripto;
sh->size = gdbscriptsize;
sh->addralign = 1;
}
}
/*
* Macho
*/
void
dwarfaddmachoheaders(void)
{
MachoSect *msect;
MachoSeg *ms;
vlong fakestart;
int nsect;
if(debug['w']) // disable dwarf
return;
// Zero vsize segments won't be loaded in memory, even so they
// have to be page aligned in the file.
fakestart = abbrevo & ~0xfff;
nsect = 4;
if (pubnamessize > 0)
nsect++;
if (pubtypessize > 0)
nsect++;
if (arangessize > 0)
nsect++;
if (gdbscriptsize > 0)
nsect++;
ms = newMachoSeg("__DWARF", nsect);
ms->fileoffset = fakestart;
ms->filesize = abbrevo-fakestart;
msect = newMachoSect(ms, "__debug_abbrev");
msect->off = abbrevo;
msect->size = abbrevsize;
ms->filesize += msect->size;
msect = newMachoSect(ms, "__debug_line");
msect->off = lineo;
msect->size = linesize;
ms->filesize += msect->size;
msect = newMachoSect(ms, "__debug_frame");
msect->off = frameo;
msect->size = framesize;
ms->filesize += msect->size;
msect = newMachoSect(ms, "__debug_info");
msect->off = infoo;
msect->size = infosize;
ms->filesize += msect->size;
if (pubnamessize > 0) {
msect = newMachoSect(ms, "__debug_pubnames");
msect->off = pubnameso;
msect->size = pubnamessize;
ms->filesize += msect->size;
}
if (pubtypessize > 0) {
msect = newMachoSect(ms, "__debug_pubtypes");
msect->off = pubtypeso;
msect->size = pubtypessize;
ms->filesize += msect->size;
}
if (arangessize > 0) {
msect = newMachoSect(ms, "__debug_aranges");
msect->off = arangeso;
msect->size = arangessize;
ms->filesize += msect->size;
}
// TODO(lvd) fix gdb/python to load MachO (16 char section name limit)
if (gdbscriptsize > 0) {
msect = newMachoSect(ms, "__debug_gdb_scripts");
msect->off = gdbscripto;
msect->size = gdbscriptsize;
ms->filesize += msect->size;
}
}
/*
* Windows PE
*/
void
dwarfaddpeheaders(void)
{
if(debug['w']) // disable dwarf
return;
newPEDWARFSection(".debug_abbrev", abbrevsize);
newPEDWARFSection(".debug_line", linesize);
newPEDWARFSection(".debug_frame", framesize);
newPEDWARFSection(".debug_info", infosize);
newPEDWARFSection(".debug_pubnames", pubnamessize);
newPEDWARFSection(".debug_pubtypes", pubtypessize);
newPEDWARFSection(".debug_aranges", arangessize);
newPEDWARFSection(".debug_gdb_scripts", gdbscriptsize);
}