func (s *state) executeLNE(op DW_LNE, length LEB128, br *binary.BinaryReader) error {
switch op {
case DW_LNE_end_sequence:
s.end_sequence = true
s.header.matrix = append(s.header.matrix, s.lineEntry)
s.reset()
case DW_LNE_set_address:
var err error
if length == 8 {
s.address, err = br.Uint64()
} else {
var v uint32
v, err = br.Uint32()
s.address = uint64(v)
}
s.op_index = 0
return err
case DW_LNE_define_file:
var fe fileEntry
if err := br.ReadInterface(&fe); err != nil {
return err
} else {
s.header.file_names = append(s.header.file_names, fe)
}
case DW_LNE_set_discriminator:
var arg LEB128
if err := br.ReadInterface(&arg); err != nil {
return err
}
s.discriminator = uint(arg)
default:
panic(fmt.Errorf("%s", op))
}
return nil
}
func (m *MetadataUtil) ReadIndex(br *binary.BinaryReader, size uint) (uint32, error) {
if size != 2 {
return br.Uint32()
} else if v, e := br.Uint16(); e != nil {
return 0, e
} else {
return uint32(v), nil
}
}
func LoadAssembly(r io.ReadSeeker) (*Assembly, error) {
var (
br = binary.BinaryReader{r, binary.LittleEndian}
err error
pe_offset uint32
coff coff_file_header
cor20 image_cor20
t MetadataHeader
)
if _, err := r.Seek(pe_signature_offset, 0); err != nil {
return nil, err
}
if pe_offset, err = br.Uint32(); err != nil {
return nil, err
} else if _, err := r.Seek(int64(pe_offset), 0); err != nil {
return nil, err
}
if err := br.ReadInterface(&coff); err != nil {
return nil, err
}
net := coff.OptionalHeader.RVAS[14]
off := coff.VirtualToFileOffset(net.VirtualAddress)
if _, err := br.Seek(int64(off), 0); err != nil {
return nil, err
}
if err := br.ReadInterface(&cor20); err != nil {
return nil, err
}
off = coff.VirtualToFileOffset(cor20.MetaData.VirtualAddress)
if _, err := br.Seek(int64(off), 0); err != nil {
return nil, err
}
if err := br.ReadInterface(&t); err != nil {
return nil, err
}
if _, err := br.Seek(int64(off), 0); err != nil {
return nil, err
}
md, err := t.MetadataUtil(&br)
if err != nil {
return nil, err
}
a := Assembly{*md, make(map[string]*TypeDef)}
idx := ConcreteTableIndex{&a.MetadataUtil, 0, id_TypeDef}
for i := uint32(0); i < a.Tables[id_TypeDef].Rows; i++ {
idx.index = 1 + i
if td, err := TypeDefFromIndex(&idx); err == nil {
a.typelut[td.Name().Absolute] = td
}
}
return &a, nil
}
func (ih *Header) Read(br *binary.BinaryReader) error {
if v, err := br.Uint32(); err != nil {
return err
} else if v != 0xffffffff {
ih.Length = uint64(v)
} else if v, err := br.Uint64(); err != nil {
return err
} else {
ih.is64 = true
ih.Length = v
}
var err error
ih.Version, err = br.Uint16()
return err
}
func (ih *InfoHeader) Read(br *binary.BinaryReader) error {
err := br.ReadInterface(&ih.Header)
if err != nil {
return err
}
if ih.is64 {
ih.DebugAbbrevOffset, err = br.Int64()
} else {
var v uint32
v, err = br.Uint32()
ih.DebugAbbrevOffset = int64(v)
}
if err != nil {
return err
}
ih.AddressSize, err = br.Uint8()
return err
}
func (mh *MetadataHeader) MetadataUtil(br *binary.BinaryReader) (*MetadataUtil, error) {
var (
ret MetadataUtil
)
off, err := br.Seek(0, 1)
if err != nil {
return nil, err
}
base := off
for _, h := range mh.StreamHeaders {
switch h.Name {
case "#~":
off += int64(h.Offset)
case "#Strings":
if _, err := br.Seek(base+int64(h.Offset), 0); err != nil {
return nil, err
} else if ret.StringHeap.data, err = br.Read(int(h.Size)); err != nil {
return nil, err
}
ret.StringHeap.Rows = h.Size
case "#Blob":
if _, err := br.Seek(base+int64(h.Offset), 0); err != nil {
return nil, err
} else if ret.BlobHeap.data, err = br.Read(int(h.Size)); err != nil {
return nil, err
}
ret.BlobHeap.Rows = h.Size
case "#GUID":
if _, err := br.Seek(base+int64(h.Offset), 0); err != nil {
return nil, err
} else if ret.GuidHeap.data, err = br.Read(int(h.Size)); err != nil {
return nil, err
}
ret.GuidHeap.Rows = h.Size
}
}
if _, err := br.Seek(off, 0); err != nil {
return nil, err
}
h := hash_tilde_stream_header{}
if err := br.ReadInterface(&h); err != nil {
return nil, err
}
if h.HeapSizes&bit_stringHeapIndexSize != 0 {
ret.StringHeap.RowSize = 4
} else {
ret.StringHeap.RowSize = 2
}
if h.HeapSizes&bit_blobHeapIndexSize != 0 {
ret.BlobHeap.RowSize = 4
} else {
ret.BlobHeap.RowSize = 2
}
if h.HeapSizes&bit_guidHeapIndexSize != 0 {
ret.GuidHeap.RowSize = 4
} else {
ret.GuidHeap.RowSize = 2
}
for i := range ret.Tables {
if valid := (h.Valid >> uint(i)) & 1; valid == 0 {
continue
}
if ret.Tables[i].Rows, err = br.Uint32(); err != nil {
return nil, err
}
ret.Tables[i].RowType = table_row_type_lut[i]
}
for i := range ret.Tables {
if ret.Tables[i].Rows == 0 {
continue
}
size, err := ret.Size(ret.Tables[i].RowType)
if err != nil {
return nil, err
}
ret.Tables[i].RowSize = uint32(size)
if ret.Tables[i].data, err = br.Read(int(ret.Tables[i].RowSize * ret.Tables[i].Rows)); err != nil {
return nil, err
}
}
return &ret, nil
}
func (t *TextFile) parse(r io.ReadSeeker) (err error) {
nifl, err := TagRead(r)
if err != nil {
return err
}
if nifl.Tag != "NIFL" {
return errors.New("NIFL tag expected")
}
reader := binary.BinaryReader{Reader: nifl.Data, Endianess: binary.LittleEndian}
type niflHeaderType struct {
Unk, OffsetREL0, SizeREL0, OffsetNOF0, SizeNOF0 uint32
}
var niflHeader niflHeaderType
if err = reader.ReadInterface(&niflHeader); err != nil {
return err
}
if niflHeader.Unk != 1 {
return errors.New("NIFL header magic != 1")
}
r.Seek(int64(niflHeader.OffsetREL0), 0)
rel0, err := TagRead(r)
if rel0.Tag != "REL0" {
return errors.New("REL0 tag expected")
}
var rel0data io.ReadSeeker
var rel0strings io.ReadSeeker
reader = binary.BinaryReader{Reader: rel0.Data, Endianess: binary.LittleEndian}
rel0size, err := reader.Uint32()
rel0data = io.NewSectionReader(util.ReaderAt(rel0.Data), 8, int64(rel0size)-8)
rel0strings = io.NewSectionReader(util.ReaderAt(rel0.Data), int64(rel0size), int64(rel0.Size-rel0size))
if rel0size < textBufferDataThreshold {
rel0data, err = util.MemReader(rel0data)
if err != nil {
return err
}
}
if rel0.Size-rel0size < textBufferThreshold {
rel0strings, err = util.MemReader(rel0strings)
if err != nil {
return err
}
}
r.Seek(int64(niflHeader.OffsetNOF0), 0)
nof0, err := TagRead(r)
if nof0.Tag != "NOF0" {
return errors.New("NOF0 tag expected")
}
nof0reader := binary.BinaryReader{Reader: nof0.Data, Endianess: binary.LittleEndian}
count, err := nof0reader.Uint32()
offsets := make([]uint32, int(count)+1)
i := 0
for offset, _ := nof0reader.Uint32(); i < int(count); i++ {
end, _ := nof0reader.Uint32()
offsets[i] = end - offset
offset = end
if offsets[i]%4 != 0 {
return errors.New("nof0 entry not a multiple of 32 bits")
}
}
offsets[i] = 8
t.Entries = make([]TextEntry, len(offsets))
rel0reader := binary.BinaryReader{Reader: rel0data, Endianess: binary.LittleEndian}
pairMode := false
var pair *string
var pairi int
for i, offset := range offsets {
entry := &t.Entries[i]
entry.Value = make([]uint32, offset/4)
for i := 0; i < int(offset/4); i++ {
entry.Value[i], err = rel0reader.Uint32()
}
if entry.Value[0] == 0xffffffff {
pairMode = true
} else if entry.Value[0] == 0x14 {
pairMode = false
pair = nil
}
if len(entry.Value) == 1 && entry.Value[0] != 0xffffffff {
rel0strings.Seek(int64(entry.Value[0]-rel0size-8), 0)
charSize := 1
if pair != nil {
charSize = 2
}
entry.Text, _ = readString(charSize, rel0strings)
if pair != nil {
entry.TextStatus = TextEntryString
t.Pairs = append(t.Pairs, TextPair{*pair, entry.Text, pairi, i})
pair = nil
} else {
entry.TextStatus = TextEntryIdentifier
if pairMode {
pair = &entry.Text
pairi = i
}
}
}
}
_, err = r.Seek(int64((nof0.Size+8+0x0f)/0x10*0x10)-8, 1)
nend, err := TagRead(r)
if nend.Tag != "NEND" {
return errors.New("NEND tag expected")
}
return err
}
func (ie *InfoEntry) data(form DW_FORM, br binary.BinaryReader) interface{} {
if form == DW_FORM_ref_addr && ie.header.Version < 3 {
form = DW_FORM_addr
}
switch form {
case DW_FORM_flag_present:
return true
case DW_FORM_exprloc, DW_FORM_block:
var size LEB128
br.ReadInterface(&size)
r, _ := br.Read(int(size))
return r
case DW_FORM_block1:
size, _ := br.Uint8()
r, _ := br.Read(int(size))
return r
case DW_FORM_block2:
size, _ := br.Uint16()
r, _ := br.Read(int(size))
return r
case DW_FORM_block4:
size, _ := br.Uint32()
r, _ := br.Read(int(size))
return r
case DW_FORM_addr:
if ie.header.AddressSize == 8 {
v, _ := br.Uint64()
return v
} else {
v, _ := br.Uint32()
return uint64(v)
}
case DW_FORM_ref_addr, DW_FORM_strp, DW_FORM_sec_offset:
if ie.header.is64 {
v, _ := br.Uint64()
return v
} else {
v, _ := br.Uint32()
return uint64(v)
}
case DW_FORM_ref1, DW_FORM_flag, DW_FORM_data1:
v, _ := br.Uint8()
return uint64(v)
case DW_FORM_ref2, DW_FORM_data2:
v, _ := br.Uint16()
return uint64(v)
case DW_FORM_ref4, DW_FORM_data4:
v, _ := br.Uint32()
return uint64(v)
case DW_FORM_ref8, DW_FORM_data8:
v, _ := br.Uint64()
return v
case DW_FORM_sdata, DW_FORM_udata:
var r LEB128
br.ReadInterface(&r)
return uint64(r)
case DW_FORM_string:
buf := make([]byte, 4096)
for i := range buf {
if v, err := br.Uint8(); err != nil {
return err
} else if v == 0 {
buf = buf[:i]
break
} else {
buf[i] = byte(v)
}
}
return string(buf)
}
panic(fmt.Errorf("Unimplemented format: %s", form))
}
func (lh *lineHeader) Read(br *binary.BinaryReader) error {
start, _ := br.Seek(0, 1)
err := br.ReadInterface(&lh.Header)
if err != nil {
return err
}
if lh.is64 {
lh.header_length, err = br.Int64()
} else {
var v uint32
v, err = br.Uint32()
lh.header_length = int64(v)
}
if err != nil {
return err
}
if lh.minimum_instruction_length, err = br.Uint8(); err != nil {
return err
}
lh.maximum_operations_per_instruction = 1
// TODO:
// if lh.maximum_operations_per_instruction, err = br.Uint8(); err != nil {
// return err
// }
if err = br.ReadInterface(&lh.default_is_stmt); err != nil {
return err
} else if lh.line_base, err = br.Int8(); err != nil {
return err
} else if lh.line_range, err = br.Uint8(); err != nil {
return err
} else if lh.opcode_base, err = br.Uint8(); err != nil {
return err
}
lh.standard_opcode_lengths = make([]uint8, lh.opcode_base-1)
if err := br.ReadInterface(&lh.standard_opcode_lengths); err != nil {
return err
}
for {
var s string
if err := br.ReadInterface(&s); err != nil {
return err
} else if s == "" {
break
} else {
lh.include_directories = append(lh.include_directories, s)
}
}
for {
var f fileEntry
pos, _ := br.Seek(0, 1)
if v, err := br.Uint8(); err != nil {
return err
} else if v == '\u0000' {
break
} else {
br.Seek(pos, 0)
}
if err := br.ReadInterface(&f); err != nil {
return err
} else {
lh.file_names = append(lh.file_names, f)
}
}
var s state
s.header = lh
s.reset()
pos, _ := br.Seek(0, 1)
for (pos - 4 - start) < int64(lh.Length) {
var op DW_LNS
if err := br.ReadInterface(&op); err != nil {
return err
}
if op == 0 {
var length LEB128
if err := br.ReadInterface(&length); err != nil {
return err
}
var op2 DW_LNE
if err := br.ReadInterface(&op2); err != nil {
return err
}
s.executeLNE(op2, length-1, br)
} else {
s.execute(op, br)
}
pos, _ = br.Seek(0, 1)
}
return nil
}
