Method loadFunctions

elf_reader.go:441–507

loadFunctions extracts instruction streams from the given program section starting at each symbol in the section. The section's symbols must already be narrowed down to STT_NOTYPE (emitted by clang <8) or STT_FUNC. The resulting map is indexed by function name.

(sec *elfSection)

//
// The resulting map is indexed by function name.
func (ec *elfCode) loadFunctions(sec *elfSection) (map[string]asm.Instructions, error) {
	progs := make(map[string]asm.Instructions)

	// Pull out ExtInfos once per section to avoid map lookups on every
	// instruction.
	fo, lo, ro := ec.extInfo.Section(sec.Name)

	// Raw instruction count since start of the section. ExtInfos point at raw
	// insn offsets and ignore the gaps between symbols in case of linked objects.
	// We need to count them, we can't obtain this info by any other means.
	var raw asm.RawInstructionOffset

	// Sort symbols by offset so we can track instructions by their raw offsets.
	for _, sym := range sec.symbolsSorted() {
		if progs[sym.Name] != nil {
			return nil, fmt.Errorf("duplicate symbol %s in section %s", sym.Name, sec.Name)
		}

		if sym.Value > math.MaxUint32 || sym.Size > math.MaxUint32 {
			return nil, fmt.Errorf("symbol %s: offset or size exceeds 32 bits in section %s", sym.Name, sec.Name)
		}
		if sym.Value+sym.Size > sec.Size {
			return nil, fmt.Errorf("symbol %s: size goes out of bounds of section %s", sym.Name, sec.Name)
		}

		// Decode the symbol's instruction stream, limited to its size.
		sr := internal.NewBufferedSectionReader(sec, int64(sym.Value), int64(sym.Size))
		insns := make(asm.Instructions, 0, sym.Size/asm.InstructionSize)
		insns, err := asm.AppendInstructions(insns, sr, ec.ByteOrder, platform.Linux)
		if err != nil {
			return nil, fmt.Errorf("decoding instructions for symbol %s in section %s: %w", sym.Name, sec.Name, err)
		}
		if len(insns) == 0 {
			return nil, fmt.Errorf("no instructions found for symbol %s in section %s", sym.Name, sec.Name)
		}

		// Mark the first instruction as the start of a function.
		insns[0] = insns[0].WithSymbol(sym.Name)

		iter := insns.Iterate()
		for iter.Next() {
			// Global byte offset of the instruction within the ELF section.
			offset := sym.Value + iter.Offset.Bytes()

			// Apply any relocations for the current instruction. If no relocation is
			// present, resolve any section-relative function calls.
			if rel, ok := sec.relocations[offset]; ok {
				if err := ec.relocateInstruction(iter.Ins, rel); err != nil {
					return nil, fmt.Errorf("offset %d in section %s: relocating instruction: %w", offset, sec.Name, err)
				}
			} else {
				if err := referenceRelativeJump(iter.Ins, offset, sec.symbols); err != nil {
					return nil, fmt.Errorf("offset %d in section %s: resolving relative jump: %w", offset, sec.Name, err)
				}
			}

			assignMetadata(iter.Ins, raw, &fo, &lo, &ro)