srctree

 

/// Tracked section headers with incremental updates to Zig object.

/// .rela.* sections are only used when emitting a relocatable object file.

 

 

 

 

// Linker-defined symbols

dynamic_index: ?Symbol.Index = null,

try self.base.file.?.pwriteAll(&[1]u8{0}, end_pos);

}

 

const shdr = &self.shdrs.items[shdr_index];

const maybe_phdr = if (self.phdr_to_shdr_table.get(shdr_index)) |phndx| &self.phdrs.items[phndx] else null;

const is_zerofill = shdr.sh_type == elf.SHT_NOBITS;

 

pub fn growNonAllocSection(

self: *Elf,

needed_size: u64,

min_alignment: u32,

requires_file_copy: bool,

self.markDirty(shdr_index);

}

 

const zig_object = self.zigObjectPtr().?;

if (zig_object.dwarf) |_| {

if (self.debug_info_section_index.? == shdr_index) {

mem.writeInt(u16, hdr_buf[index..][0..2], e_shnum, endian);

index += 2;

 

index += 2;

 

assert(index == e_ehsize);

}

}

 

const shdr = self.shdrs.items[shndx];

const name = self.getShString(shdr.sh_name);

const flags = shdr.sh_flags;

 

pub fn sortShdrs(self: *Elf) !void {

const Entry = struct {

 

pub fn lessThan(elf_file: *Elf, lhs: @This(), rhs: @This()) bool {

return elf_file.shdrRank(lhs.shndx) < elf_file.shdrRank(rhs.shndx);

var entries = try std.ArrayList(Entry).initCapacity(gpa, self.shdrs.items.len);

defer entries.deinit();

for (0..self.shdrs.items.len) |shndx| {

}

 

mem.sort(Entry, entries.items, self, Entry.lessThan);

 

defer gpa.free(backlinks);

for (entries.items, 0..) |entry, i| {

}

 

const slice = try self.shdrs.toOwnedSlice(gpa);

try self.resetShdrIndexes(backlinks);

}

 

const gpa = self.base.comp.gpa;

 

&self.eh_frame_section_index,

&self.eh_frame_rela_section_index,

&self.eh_frame_hdr_section_index,

// virtual and file offsets. However, the simple one will do for one

// as we are more interested in quick turnaround and compatibility

// with `findFreeSpace` mechanics than anything else.

const gpa = self.base.comp.gpa;

var covers: [max_number_of_object_segments]Cover = undefined;

for (&covers) |*cover| {

}

 

fn allocateSpecialPhdrs(self: *Elf) void {

.{ self.phdr_interp_index, self.interp_section_index },

.{ self.phdr_dynamic_index, self.dynamic_section_index },

.{ self.phdr_gnu_eh_frame_index, self.eh_frame_hdr_section_index },

if (self.phdr_tls_index) |index| {

const slice = self.shdrs.items;

const phdr = &self.phdrs.items[index];

while (shndx < slice.len) {

const shdr = slice[shndx];

if (shdr.sh_flags & elf.SHF_TLS == 0) {

}

};

 

self.zig_text_section_index,

self.zig_data_rel_ro_section_index,

self.zig_data_section_index,

return false;

}

 

self.debug_info_section_index,

self.debug_abbrev_section_index,

self.debug_str_section_index,

return index;

}

 

const entsize: u64 = switch (self.ptr_width) {

.p32 => @sizeOf(elf.Elf32_Rela),

.p64 => @sizeOf(elf.Elf64_Rela),

offset: u64 = 0,

};

 

const gpa = self.base.comp.gpa;

const shdr = try self.shdrs.addOne(gpa);

shdr.* = .{

.sh_name = try self.insertShString(opts.name),

return index;

}

 

for (self.shdrs.items, 0..) |*shdr, i| {

const this_name = self.getShString(shdr.sh_name);

} else return null;

}

 

 

input_section_index: u32 = 0,

 

/// Index of the output section.

 

/// Index of the input section containing this atom's relocs.

relocs_section_index: u32 = 0,

return self.relocs_section_index;

}

 

if (self.output_section_index == 0) return null;

return self.output_section_index;

}

 

try self.strtab.appendSlice(allocator, shstrtab);

 

const symtab_index = for (self.shdrs.items, 0..) |shdr, i| switch (shdr.sh_type) {

else => {},

} else null;

 

=> {},

 

else => {

if (self.skipShdr(shndx, elf_file)) continue;

try self.addAtom(allocator, handle, shdr, shndx, elf_file);

},

}

}

 

const name = blk: {

const name = self.getString(shdr.sh_name);

if (elf_file.base.isRelocatable()) break :blk name;

return out_shndx;

}

 

const comp = elf_file.base.comp;

const shdr = self.shdrs.items[index];

const name = self.getString(shdr.sh_name);

 

var sh_flags: u32 = elf.SHF_ALLOC | elf.SHF_WRITE;

if (is_tls) sh_flags |= elf.SHF_TLS;

const shdr = try self.shdrs.addOne(gpa);

const sh_size = math.cast(usize, this_sym.st_size) orelse return error.Overflow;

shdr.* = .{

 

atom_index: Atom.Index = 0,

 

/// Assigned output section index for this atom.

 

/// Index of the source symbol this symbol references.

/// Use `elfSym` to pull the source symbol from the relevant file.

file_ptr != .linker_defined;

}

 

if (symbol.output_section_index == 0) return null;

return symbol.output_section_index;

}

if (file_ptr == .shared_object) break :blk elf.STB_GLOBAL;

break :blk esym.st_bind();

};

if (file_ptr == .shared_object or esym.st_shndx == elf.SHN_UNDEF) break :blk elf.SHN_UNDEF;

if (elf_file.base.isRelocatable() and esym.st_shndx == elf.SHN_COMMON) break :blk elf.SHN_COMMON;

if (symbol.atom(elf_file) == null and file_ptr != .linker_defined) break :blk elf.SHN_ABS;

};

const st_value = blk: {

if (symbol.flags.has_copy_rel) break :blk symbol.address(.{}, elf_file);

 

elf_file: *Elf,

decl: *const Module.Decl,

code: []const u8,

_ = self;

const mod = elf_file.base.comp.module.?;

const any_non_single_threaded = elf_file.base.comp.config.any_non_single_threaded;

elf_file: *Elf,

decl_index: InternPool.DeclIndex,

sym_index: Symbol.Index,

code: []const u8,

stt_bits: u8,

) !void {

elf_file: *Elf,

decl_index: InternPool.DeclIndex,

sym_index: Symbol.Index,

code: []const u8,

) !void {

const gpa = elf_file.base.comp.gpa;

name: []const u8,

tv: TypedValue,

required_alignment: InternPool.Alignment,

src_loc: Module.SrcLoc,

) !LowerConstResult {

const gpa = elf_file.base.comp.gpa;

 

.st_name = st_name,

.st_info = elf.STT_OBJECT,

.st_other = 0,

.st_value = st_value,

.st_size = st_size,

};

.st_name = st_name,

.st_info = elf.STT_OBJECT,

.st_other = 0,

.st_value = st_value,

.st_size = st_size,

};

.st_name = st_name,

.st_info = elf.STT_FUNC,

.st_other = 0,

.st_value = sym.pltAddress(elf_file),

.st_size = 16,

};

.st_name = st_name,

.st_info = elf.STT_FUNC,

.st_other = 0,

.st_value = sym.pltGotAddress(elf_file),

.st_size = 16,

};

}

}

 

const shdr = &elf_file.shdrs.items[shndx];

for (copy_rel.symbols.items) |sym_index| {

const symbol = elf_file.symbol(sym_index);