If rom is over 64K then use part of e-segment for 32bit code.
Push 32bit code as high as it can go in the f-segment.
Do version building before layoutrom.py - this way layoutrom knows
full size of rom.
Make layoutrom.py build the full ld script - remove now unused ld
scripts that just imported the output of layoutrom.py.
Also, use "objdump" instead of "nm" - reduce toolchain requirements.
Enhance tools/checkrom.py so that it can pad bios.bin to size qemu is
happy with.
Also, add dependencies to build rules for local tools - if tool
changes automatically rerun it.
Make sure option roms don't overwrite the 32bit code (should the 32bit
code be in the e-segment).
Make sure shadow code works even if part of the code is in the
e-segment.
OBJCOPY=objcopy
OBJDUMP=objdump
-NM=nm
STRIP=strip
.PHONY : all FORCE
$(OUT)ccode.16.s: ; $(call whole-compile, $(CFLAGS16) -S, $(addprefix src/, $(SRC16)),$@)
+$(OUT)ccode32.o: ; $(call whole-compile, $(CFLAGS), $(addprefix src/, $(SRC32)),$@)
+
$(OUT)code16.o: romlayout.S $(OUT)ccode.16.s $(OUT)asm-offsets.h
@echo " Compiling (16bit) $@"
$(Q)$(CC) $(CFLAGS16INC) -c -D__ASSEMBLY__ $< -o $@
-$(OUT)code32.o: ; $(call whole-compile, $(CFLAGS), $(addprefix src/, $(SRC32)),$@)
-
-$(OUT)romlayout16.lds $(OUT)romlayout32.lds: $(OUT)code32.o $(OUT)code16.o
- @echo " Building layout information $@"
+$(OUT)romlayout16.lds $(OUT)romlayout32.lds $(OUT)code32.o: $(OUT)ccode32.o $(OUT)code16.o tools/layoutrom.py
+ @echo " Building ld scripts (version \"$(VERSION)\")"
+ $(Q)echo 'const char VERSION[] = "$(VERSION)";' > $(OUT)version.c
+ $(Q)$(CC) $(CFLAGS) -c $(OUT)version.c -o $(OUT)version.o
+ $(Q)$(LD) -melf_i386 -r $(OUT)ccode32.o $(OUT)version.o -o $(OUT)code32.o
$(Q)$(OBJDUMP) -thr $(OUT)code32.o > $(OUT)code32.o.objdump
$(Q)$(OBJDUMP) -thr $(OUT)code16.o > $(OUT)code16.o.objdump
$(Q)./tools/layoutrom.py $(OUT)code16.o.objdump $(OUT)code32.o.objdump $(OUT)romlayout16.lds $(OUT)romlayout32.lds
-$(OUT)layout16.lds: $(OUT)romlayout16.lds
-$(OUT)rombios32.lds: $(OUT)romlayout32.lds
-
-$(OUT)rom16.o: $(OUT)code16.o $(OUT)rom32.o $(OUT)layout16.lds
+$(OUT)rom16.o: $(OUT)code16.o $(OUT)rom32.o $(OUT)romlayout16.lds
@echo " Linking (no relocs) $@"
- $(Q)$(LD) -r -T $(OUT)layout16.lds $< -o $@
+ $(Q)$(LD) -r -T $(OUT)romlayout16.lds $< -o $@
-$(OUT)rom32.o: $(OUT)code32.o $(OUT)rombios32.lds
+$(OUT)rom32.o: $(OUT)code32.o $(OUT)romlayout32.lds
@echo " Linking (no relocs) $@"
- $(Q)$(LD) -r -T $(OUT)rombios32.lds $< -o $@
+ $(Q)$(LD) -r -T $(OUT)romlayout32.lds $< -o $@
$(OUT)rom.o: $(OUT)rom16.o $(OUT)rom32.o $(OUT)rombios16.lds $(OUT)rombios.lds
@echo " Linking $@ (version \"$(VERSION)\")"
- $(Q)echo 'const char VERSION[] __attribute__((section(".data32.version"))) = "$(VERSION)";' > $(OUT)version.c
- $(Q)$(CC) $(CFLAGS) -c $(OUT)version.c -o $(OUT)version.o
$(Q)$(LD) -T $(OUT)rombios16.lds $(OUT)rom16.o -R $(OUT)rom32.o -o $(OUT)rom16.reloc.o
$(Q)$(STRIP) $(OUT)rom16.reloc.o -o $(OUT)rom16.final.o
$(Q)$(OBJCOPY) --adjust-vma 0xf0000 $(OUT)rom16.o $(OUT)rom16.moved.o
- $(Q)$(LD) -T $(OUT)rombios.lds $(OUT)rom16.final.o $(OUT)rom32.o $(OUT)version.o -R $(OUT)rom16.moved.o -o $@
+ $(Q)$(LD) -T $(OUT)rombios.lds $(OUT)rom16.final.o $(OUT)rom32.o -R $(OUT)rom16.moved.o -o $@
-$(OUT)bios.bin.elf: $(OUT)rom.o
+$(OUT)bios.bin.elf $(OUT)bios.bin: $(OUT)rom.o tools/checkrom.py
@echo " Prepping $@"
- $(Q)$(NM) $< | ./tools/checkrom.py
- $(Q)$(STRIP) $< -o $@
-
-$(OUT)bios.bin: $(OUT)bios.bin.elf
- @echo " Extracting binary $@"
- $(Q)$(OBJCOPY) -O binary $< $@
+ $(Q)$(OBJDUMP) -thr $< > $<.objdump
+ $(Q)$(OBJCOPY) -O binary $< $(OUT)bios.bin.raw
+ $(Q)./tools/checkrom.py $<.objdump $(OUT)bios.bin.raw $(OUT)bios.bin
+ $(Q)$(STRIP) $< -o $(OUT)bios.bin.elf
################ VGA build rules
@echo " Extracting binary $@"
$(Q)$(OBJCOPY) -O binary $< $@
-$(OUT)vgabios.bin: $(OUT)vgabios.bin.raw
+$(OUT)vgabios.bin: $(OUT)vgabios.bin.raw tools/buildrom.py
@echo " Finalizing rom $@"
$(Q)./tools/buildrom.py $< $@
+++ /dev/null
-// Placement of the 16bit code.
-//
-// Copyright (C) 2008,2009 Kevin O'Connor <kevin@koconnor.net>
-//
-// This file may be distributed under the terms of the GNU LGPLv3 license.
-
-#include "config.h" // BUILD_BIOS_ADDR
-
-OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
-OUTPUT_ARCH("i386")
-SECTIONS
-{
-
-// The actual placement of the 16bit sections is determined by the
-// script tools/layoutrom.py
-#include "../out/romlayout16.lds"
-
- // Discard regular data sections to force a link error if
- // 16bit code attempts to access data not marked with VAR16.
- /DISCARD/ : { *(.text*) *(.rodata*) *(.data*) *(.bss*) *(COMMON) }
-}
return pci;
}
+// Return the memory position up to which roms may be located.
+static inline u32
+max_rom()
+{
+ extern u8 code32_start[];
+ if ((u32)code32_start > BUILD_BIOS_ADDR)
+ return BUILD_BIOS_ADDR;
+ return (u32)code32_start;
+}
+
// Copy a rom to its permanent location below 1MiB
static struct rom_header *
copy_rom(struct rom_header *rom)
{
u32 romsize = rom->size * 512;
- if (RomEnd + romsize > BUILD_BIOS_ADDR) {
+ if (RomEnd + romsize > max_rom()) {
// Option rom doesn't fit.
dprintf(1, "Option rom %p doesn't fit.\n", rom);
return NULL;
&& ((OPTIONROM_VENDEV_2 >> 16)
| ((OPTIONROM_VENDEV_2 & 0xffff)) << 16) == vendev)
return copy_rom((void*)OPTIONROM_MEM_2);
- int ret = cbfs_copy_optionrom((void*)RomEnd, BUILD_BIOS_ADDR - RomEnd
- , vendev);
+ int ret = cbfs_copy_optionrom((void*)RomEnd, max_rom() - RomEnd, vendev);
if (ret < 0)
return NULL;
return (void*)RomEnd;
file = cbfs_findprefix(prefix, file);
if (!file)
break;
- int ret = cbfs_copyfile(file, (void*)RomEnd, BUILD_BIOS_ADDR - RomEnd);
+ int ret = cbfs_copyfile(file, (void*)RomEnd, max_rom() - RomEnd);
if (ret > 0)
init_optionrom((void*)RomEnd, 0, isvga);
}
if (CONFIG_OPTIONROMS_DEPLOYED) {
// Option roms are already deployed on the system.
u32 pos = RomEnd;
- while (pos < BUILD_BIOS_ADDR) {
+ while (pos < max_rom()) {
int ret = init_optionrom((void*)pos, 0, 0);
if (ret)
pos += OPTION_ROM_ALIGN;
//
// This file may be distributed under the terms of the GNU LGPLv3 license.
-OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
+#include "config.h" // BUILD_BIOS_ADDR
+
+OUTPUT_FORMAT("elf32-i386")
OUTPUT_ARCH("i386")
ENTRY(post32)
SECTIONS
{
.text code32_start : {
*(.text32)
- *(.data32.version)
- . = code16_start ;
+ . = code16_start + BUILD_BIOS_ADDR - code32_start ;
*(.text16)
final_code16_end = . ;
}
//
// This file may be distributed under the terms of the GNU LGPLv3 license.
-#include "config.h" // BUILD_BIOS_ADDR
-
OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
OUTPUT_ARCH("i386")
SECTIONS
+++ /dev/null
-// Linker definitions for 32 bit code
-//
-// Copyright (C) 2008 Kevin O'Connor <kevin@koconnor.net>
-//
-// This file may be distributed under the terms of the GNU LGPLv3 license.
-
-#include "config.h" // BUILD_BIOS_ADDR
-
-OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
-OUTPUT_ARCH("i386")
-SECTIONS
-{
- .text32 BUILD_BIOS_ADDR : {
- code32_start = ABSOLUTE(.) ;
-
-// The actual sections kept is determined by the script tools/layoutrom.py
-#include "../out/romlayout32.lds"
-
- freespace_start = . ;
- code32_end = ABSOLUTE(.) ;
- }
-}
// Enable shadowing and copy bios.
static void
-copy_bios(u16 bdf)
+__make_bios_writable(u16 bdf)
{
- pci_config_writeb(bdf, 0x59, 0x30);
- memcpy((void*)BUILD_BIOS_ADDR, (void*)BIOS_SRC_ADDR, BUILD_BIOS_SIZE);
-}
-
-// Make the 0xc0000-0x100000 area read/writable.
-void
-make_bios_writable()
-{
- if (CONFIG_COREBOOT)
- return;
-
- dprintf(3, "enabling shadow ram\n");
-
- // Locate chip controlling ram shadowing.
- int bdf = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82441);
- if (bdf < 0) {
- dprintf(1, "Unable to unlock ram - bridge not found\n");
- return;
- }
-
// Make ram from 0xc0000-0xf0000 writable
int clear = 0;
int i;
if (clear)
memset((void*)BUILD_BIOS_TMP_ADDR, 0, 32*1024);
+ // Make ram from 0xf0000-0x100000 writable
int reg = pci_config_readb(bdf, 0x59);
- if (reg & 0x10) {
- // Ram already present - just enable writes
- pci_config_writeb(bdf, 0x59, 0x30);
+ pci_config_writeb(bdf, 0x59, 0x30);
+ if (reg & 0x10)
+ // Ram already present.
+ return;
+
+ // Copy bios.
+ memcpy((void*)BUILD_BIOS_ADDR, (void*)BIOS_SRC_ADDR, BUILD_BIOS_SIZE);
+}
+
+// Make the 0xc0000-0x100000 area read/writable.
+void
+make_bios_writable()
+{
+ if (CONFIG_COREBOOT)
+ return;
+
+ dprintf(3, "enabling shadow ram\n");
+
+ // Locate chip controlling ram shadowing.
+ int bdf = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82441);
+ if (bdf < 0) {
+ dprintf(1, "Unable to unlock ram - bridge not found\n");
return;
}
- // Enable shadowing and copy bios.
- if (IN_RANGE((u32)copy_bios, BUILD_BIOS_ADDR, BUILD_BIOS_SIZE)) {
- // Jump to shadow enable function - use the copy in the
- // temporary storage area so that memory does not change under
- // the executing code.
- u32 pos = (u32)copy_bios - BUILD_BIOS_ADDR + BIOS_SRC_ADDR;
+ int reg = pci_config_readb(bdf, 0x59);
+ if (!(reg & 0x10)) {
+ // QEMU doesn't fully implement the piix shadow capabilities -
+ // if ram isn't backing the bios segment when shadowing is
+ // disabled, the code itself wont be in memory. So, run the
+ // code from the high-memory flash location.
+ u32 pos = (u32)__make_bios_writable - BUILD_BIOS_ADDR + BIOS_SRC_ADDR;
void (*func)(u16 bdf) = (void*)pos;
func(bdf);
- } else {
- copy_bios(bdf);
+ return;
}
+ // Ram already present - just enable writes
+ __make_bios_writable(bdf);
}
// Make the BIOS code segment area (0xf0000) read-only.
# This file may be distributed under the terms of the GNU GPLv3 license.
import sys
+import layoutrom
def main():
- # Read in symbols (that are valid)
+ # Get args
+ objinfo, rawfile, outfile = sys.argv[1:]
+
+ # Read in symbols
+ objinfofile = open(objinfo, 'rb')
+ symbols = layoutrom.parseObjDump(objinfofile)[1]
syms = {}
- for line in sys.stdin.readlines():
- try:
- addr, type, sym = line.split()
- syms[sym] = int(addr, 16)
- except:
- pass
+ for name, (addr, section) in symbols.items():
+ syms[name] = addr
+
+ # Read in raw file
+ f = open(rawfile, 'rb')
+ rawdata = f.read()
+ f.close()
+ datasize = len(rawdata)
+ finalsize = 64*1024
+ if datasize > 64*1024:
+ finalsize = 128*1024
+ # Sanity checks
c16e = syms['code16_end'] + 0xf0000
f16e = syms['final_code16_end']
if c16e != f16e:
print "Error! 16bit code moved during linking (0x%x vs 0x%x)" % (
c16e, f16e)
sys.exit(1)
+ if datasize > finalsize:
+ print "Error! Code is too big (0x%x vs 0x%x)" % (
+ datasize, finalsize)
+ sys.exit(1)
+ # Print statistics
sizefree = syms['freespace_end'] - syms['freespace_start']
size16 = syms['code16_end'] - syms['code16_start']
size32 = syms['code32_end'] - syms['code32_start']
totalc = size16+size32
print "16bit size: %d" % size16
print "32bit size: %d" % size32
- print "Total size: %d Free space: %d Percent used: %.1f%%" % (
- totalc, sizefree
- , (totalc / float(size16+size32+sizefree)) * 100.0)
+ print "Total size: %d Free space: %d Percent used: %.1f%% (%dKiB rom)" % (
+ totalc, sizefree + finalsize - datasize
+ , (totalc / float(finalsize)) * 100.0
+ , finalsize / 1024)
+
+ # Write final file
+ f = open(outfile, 'wb')
+ f.write(("\0" * (finalsize - datasize)) + rawdata)
+ f.close()
if __name__ == '__main__':
main()
#!/usr/bin/env python
-# Script to arrange sections to ensure fixed offsets.
+# Script to analyze code and arrange ld sections.
#
# Copyright (C) 2008 Kevin O'Connor <kevin@koconnor.net>
#
import sys
-
+# Align 'pos' to 'alignbytes' offset
def alignpos(pos, alignbytes):
mask = alignbytes - 1
return (pos + mask) & ~mask
+# LD script headers/trailers
+COMMONHEADER = """
+/* DO NOT EDIT! This is an autogenerated file. See tools/layoutrom.py. */
+OUTPUT_FORMAT("elf32-i386")
+OUTPUT_ARCH("i386")
+SECTIONS
+{
+"""
+COMMONTRAILER = """
+}
+"""
+
######################################################################
# 16bit fixed address section fitting
######################################################################
-MAXPOS = 0x10000
+# Get the maximum start position for a list of sections that end at an
+# address.
+def getSectionsStart(sections, endaddr, minalign=1):
+ totspace = 0
+ for size, align, name in sections:
+ if align > minalign:
+ minalign = align
+ totspace = alignpos(totspace, align) + size
+ return (endaddr - totspace) / minalign * minalign
+
+# Write LD script includes for the given sections
+def outSections(file, sections):
+ for size, align, name in sections:
+ file.write("*(%s)\n" % (name,))
+
+# The 16bit code can't exceed 64K of space.
+MAXPOS = 64*1024
+# Layout the 16bit code. This ensures sections with fixed offset
+# requirements are placed in the correct location. It also places the
+# 16bit code as high as possible in the f-segment.
def doLayout16(sections, outname):
textsections = []
rodatasections = []
# , fitnextaddr, nextfixedaddr - fitnextaddr)
firstfixed = fixedsections[0][0]
- # Find overall start position
- restalign = 0
- restspace = 0
- restsections = []
- for section in textsections + rodatasections + datasections:
- size, align, name = section
- if align > restalign:
- restalign = align
- restspace = alignpos(restspace, align) + size
- restsections.append(section)
- startrest = (firstfixed - restspace) / restalign * restalign
-
# Report stats
total = MAXPOS-firstfixed
slack = total - totalused
firstfixed, MAXPOS, total, slack,
(float(slack) / total) * 100.0))
+ # Find overall start position
+ start16 = getSectionsStart(
+ textsections + rodatasections + datasections, firstfixed)
+
# Write header
output = open(outname, 'wb')
- output.write("""
+ output.write(COMMONHEADER + """
.text16 0x%x : {
code16_start = ABSOLUTE(.) ;
freespace_end = . ;
-""" % startrest)
+""" % start16)
# Write regular sections
- for section in restsections:
- name = section[2]
- if rodatasections and name == rodatasections[0][2]:
- output.write("code16_rodata = . ;\n")
- output.write("*(%s)\n" % (name,))
+ outSections(output, textsections)
+ output.write("code16_rodata = . ;\n")
+ outSections(output, rodatasections)
+ outSections(output, datasections)
# Write fixed sections
for addr, section, extrasections in fixedsections:
output.write("""
code16_end = ABSOLUTE(.) ;
}
-""")
+
+ /* Discard regular data sections to force a link error if
+ * 16bit code attempts to access data not marked with VAR16
+ */
+ /DISCARD/ : { *(.text*) *(.rodata*) *(.data*) *(.bss*) *(COMMON) }
+""" + COMMONTRAILER)
+
+ return start16
######################################################################
# 32bit section outputting
######################################################################
-def outsections(file, sections, prefix):
+# Return the subset of sections with a given name prefix
+def getSectionsPrefix(sections, prefix):
lp = len(prefix)
+ out = []
for size, align, name in sections:
if name[:lp] == prefix:
- file.write("*(%s)\n" % (name,))
-
-def doLayout32(sections, outname):
+ out.append((size, align, name))
+ return out
+
+# Layout the 32bit code. This places the code as high as possible.
+def doLayout32(sections, outname, start16):
+ start16 += 0xf0000
+ # Find sections to output
+ textsections = getSectionsPrefix(sections, '.text.')
+ rodatasections = getSectionsPrefix(sections, '.rodata')
+ datasections = getSectionsPrefix(sections, '.data.')
+ bsssections = getSectionsPrefix(sections, '.bss.')
+ start32 = getSectionsStart(
+ textsections + rodatasections + datasections + bsssections, start16, 512)
+
+ # Write sections
output = open(outname, 'wb')
- outsections(output, sections, '.text.')
+ output.write(COMMONHEADER + """
+ .text32 0x%x : {
+ code32_start = ABSOLUTE(.) ;
+""" % start32)
+
+ outSections(output, textsections)
output.write("code32_rodata = . ;\n")
- outsections(output, sections, '.rodata')
- outsections(output, sections, '.data.')
- outsections(output, sections, '.bss.')
+ outSections(output, rodatasections)
+ outSections(output, datasections)
+ outSections(output, bsssections)
+
+ output.write("""
+ freespace_start = . ;
+ code32_end = ABSOLUTE(.) ;
+ }
+""" + COMMONTRAILER)
######################################################################
# Section garbage collection
######################################################################
+# Note required section, and recursively set all referenced sections
+# as required.
def keepsection(name, pri, alt):
if name in pri[3]:
# Already kept - nothing to do.
return
# Keep all sections that this section points to
for symbol in relocs:
- section = pri[1].get(symbol)
- if section is not None and section[:9] != '.discard.':
+ addr, section = pri[1].get(symbol, (None, None))
+ if (section is not None and '*' not in section
+ and section[:9] != '.discard.'):
keepsection(section, pri, alt)
continue
# Not in primary sections - it may be a cross 16/32 reference
- section = alt[1].get(symbol)
- if section is not None:
+ addr, section = alt[1].get(symbol, (None, None))
+ if section is not None and '*' not in section:
keepsection(section, alt, pri)
+# Determine which sections are actually referenced and need to be
+# placed into the output file.
def gc(info16, info32):
# pri = (sections, symbols, relocs, keep sections)
pri = (info16[0], info16[1], info16[2], [])
try:
section, off, symbol = line[17:].split()
off = int(off, 16)
- if '*' not in section:
- symbols[symbol] = section
+ addr = int(line[:8], 16)
+ symbols[symbol] = addr, section
except:
pass
continue
sections16, sections32 = gc(info16, info32)
- doLayout16(sections16, out16)
- doLayout32(sections32, out32)
+ start16 = doLayout16(sections16, out16)
+ doLayout32(sections32, out32, start16)
if __name__ == '__main__':
main()
projects / seabios.git / commitdiff