{ Copyright (c) 2005-2017 by Free Pascal Compiler team This unit implements support import, export, link routines for the Embedded Target This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. **************************************************************************** } unit t_embed; {$i fpcdefs.inc} interface implementation uses SysUtils, cutils,cfileutl,cclasses, globtype,globals,systems,verbose,comphook,cscript,fmodule,i_embed,link, cpuinfo; type TlinkerEmbedded=class(texternallinker) private Function WriteResponseFile: Boolean; public constructor Create; override; procedure SetDefaultInfo; override; function MakeExecutable:boolean; override; function postprocessexecutable(const fn : string;isdll:boolean):boolean; end; {***************************************************************************** TlinkerEmbedded *****************************************************************************} Constructor TlinkerEmbedded.Create; begin Inherited Create; SharedLibFiles.doubles:=true; StaticLibFiles.doubles:=true; end; procedure TlinkerEmbedded.SetDefaultInfo; const {$ifdef mips} {$ifdef mipsel} platform_select='-EL'; {$else} platform_select='-EB'; {$endif} {$else} platform_select=''; {$endif} begin with Info do begin ExeCmd[1]:='ld -g '+platform_select+' $OPT $DYNLINK $STATIC $GCSECTIONS $STRIP -L. -o $EXE -T $RES'; end; end; Function TlinkerEmbedded.WriteResponseFile: Boolean; Var linkres : TLinkRes; i : longint; HPath : TCmdStrListItem; s,s1,s2 : TCmdStr; prtobj, cprtobj : string[80]; linklibc : boolean; found1, found2 : boolean; {$if defined(ARM)} LinkStr : string; {$endif} begin WriteResponseFile:=False; linklibc:=(SharedLibFiles.Find('c')<>nil); {$if defined(ARM) or defined(i386) or defined(x86_64) or defined(AVR) or defined(MIPSEL)} prtobj:=''; {$else} prtobj:='prt0'; {$endif} cprtobj:='cprt0'; if linklibc then prtobj:=cprtobj; { Open link.res file } LinkRes:=TLinkRes.Create(outputexedir+Info.ResName,true); { Write path to search libraries } HPath:=TCmdStrListItem(current_module.locallibrarysearchpath.First); while assigned(HPath) do begin s:=HPath.Str; if (cs_link_on_target in current_settings.globalswitches) then s:=ScriptFixFileName(s); LinkRes.Add('-L'+s); HPath:=TCmdStrListItem(HPath.Next); end; HPath:=TCmdStrListItem(LibrarySearchPath.First); while assigned(HPath) do begin s:=HPath.Str; if s<>'' then LinkRes.Add('SEARCH_DIR("'+s+'")'); HPath:=TCmdStrListItem(HPath.Next); end; LinkRes.Add('INPUT ('); { add objectfiles, start with prt0 always } //s:=FindObjectFile('prt0','',false); if prtobj<>'' then begin s:=FindObjectFile(prtobj,'',false); LinkRes.AddFileName(s); end; { try to add crti and crtbegin if linking to C } if linklibc then begin if librarysearchpath.FindFile('crtbegin.o',false,s) then LinkRes.AddFileName(s); if librarysearchpath.FindFile('crti.o',false,s) then LinkRes.AddFileName(s); end; while not ObjectFiles.Empty do begin s:=ObjectFiles.GetFirst; if s<>'' then begin { vlink doesn't use SEARCH_DIR for object files } if not(cs_link_on_target in current_settings.globalswitches) then s:=FindObjectFile(s,'',false); LinkRes.AddFileName((maybequoted(s))); end; end; { Write staticlibraries } if not StaticLibFiles.Empty then begin { vlink doesn't need, and doesn't support GROUP } if (cs_link_on_target in current_settings.globalswitches) then begin LinkRes.Add(')'); LinkRes.Add('GROUP('); end; while not StaticLibFiles.Empty do begin S:=StaticLibFiles.GetFirst; LinkRes.AddFileName((maybequoted(s))); end; end; if (cs_link_on_target in current_settings.globalswitches) then begin LinkRes.Add(')'); { Write sharedlibraries like -l, also add the needed dynamic linker here to be sure that it gets linked this is needed for glibc2 systems (PFV) } linklibc:=false; while not SharedLibFiles.Empty do begin S:=SharedLibFiles.GetFirst; if s<>'c' then begin i:=Pos(target_info.sharedlibext,S); if i>0 then Delete(S,i,255); LinkRes.Add('-l'+s); end else begin LinkRes.Add('-l'+s); linklibc:=true; end; end; { be sure that libc&libgcc is the last lib } if linklibc then begin LinkRes.Add('-lc'); LinkRes.Add('-lgcc'); end; end else begin while not SharedLibFiles.Empty do begin S:=SharedLibFiles.GetFirst; LinkRes.Add('lib'+s+target_info.staticlibext); end; LinkRes.Add(')'); end; { objects which must be at the end } if linklibc then begin found1:=librarysearchpath.FindFile('crtend.o',false,s1); found2:=librarysearchpath.FindFile('crtn.o',false,s2); if found1 or found2 then begin LinkRes.Add('INPUT('); if found1 then LinkRes.AddFileName(s1); if found2 then LinkRes.AddFileName(s2); LinkRes.Add(')'); end; end; {$ifdef ARM} case current_settings.controllertype of ct_none: begin end; ct_lpc810m021fn8, ct_lpc811m001fdh16, ct_lpc812m101fdh16, ct_lpc812m101fd20, ct_lpc812m101fdh20, ct_lpc1110fd20, ct_lpc1111fdh20_002, ct_lpc1111fhn33_101, ct_lpc1111fhn33_102, ct_lpc1111fhn33_103, ct_lpc1111fhn33_201, ct_lpc1111fhn33_202, ct_lpc1111fhn33_203, ct_lpc1112fd20_102, ct_lpc1112fdh20_102, ct_lpc1112fdh28_102, ct_lpc1112fhn33_101, ct_lpc1112fhn33_102, ct_lpc1112fhn33_103, ct_lpc1112fhn33_201, ct_lpc1112fhn24_202, ct_lpc1112fhn33_202, ct_lpc1112fhn33_203, ct_lpc1112fhi33_202, ct_lpc1112fhi33_203, ct_lpc1113fhn33_201, ct_lpc1113fhn33_202, ct_lpc1113fhn33_203, ct_lpc1113fhn33_301, ct_lpc1113fhn33_302, ct_lpc1113fhn33_303, ct_lpc1113bfd48_301, ct_lpc1113bfd48_302, ct_lpc1113bfd48_303, ct_lpc1114fdh28_102, ct_lpc1114fn28_102, ct_lpc1114fhn33_201, ct_lpc1114fhn33_202, ct_lpc1114fhn33_203, ct_lpc1114fhn33_301, ct_lpc1114fhn33_302, ct_lpc1114fhn33_303, ct_lpc1114fhn33_333, ct_lpc1114fhi33_302, ct_lpc1114fhi33_303, ct_lpc1114bfd48_301, ct_lpc1114bfd48_302, ct_lpc1114bfd48_303, ct_lpc1114bfd48_323, ct_lpc1114bfd48_333, ct_lpc1115bfd48_303, ct_lpc11c12fd48_301, ct_lpc11c14fd48_301, ct_lpc11c22fd48_301, ct_lpc11c24fd48_301, ct_lpc11d24fd48_301, ct_lpc1224fbd48_101, ct_lpc1224fbd48_121, ct_lpc1224fbd64_101, ct_lpc1224fbd64_121, ct_lpc1225fbd48_301, ct_lpc1225fbd48_321, ct_lpc1225fbd64_301, ct_lpc1225fbd64_321, ct_lpc1226fbd48_301, ct_lpc1226fbd64_301, ct_lpc1227fbd48_301, ct_lpc1227fbd64_301, ct_lpc12d27fbd100_301, ct_lpc1311fhn33, ct_lpc1311fhn33_01, ct_lpc1313fhn33, ct_lpc1313fhn33_01, ct_lpc1313fbd48, ct_lpc1313fbd48_01, ct_lpc1315fhn33, ct_lpc1315fbd48, ct_lpc1316fhn33, ct_lpc1316fbd48, ct_lpc1317fhn33, ct_lpc1317fbd48, ct_lpc1317fbd64, ct_lpc1342fhn33, ct_lpc1342fbd48, ct_lpc1343fhn33, ct_lpc1343fbd48, ct_lpc1345fhn33, ct_lpc1345fbd48, ct_lpc1346fhn33, ct_lpc1346fbd48, ct_lpc1347fhn33, ct_lpc1347fbd48, ct_lpc1347fbd64, ct_lpc2114, ct_lpc2124, ct_lpc2194, ct_lpc1768, ct_at91sam7s256, ct_at91sam7se256, ct_at91sam7x256, ct_at91sam7xc256, ct_stm32f030c6, ct_stm32f030c8, ct_stm32f030f4, ct_stm32f030k6, ct_stm32f030r8, ct_stm32f050c4, ct_stm32f050c6, ct_stm32f050f4, ct_stm32f050f6, ct_stm32f050g4, ct_stm32f050g6, ct_stm32f050k4, ct_stm32f050k6, ct_stm32f051c4, ct_stm32f051c6, ct_stm32f051c8, ct_stm32f051k4, ct_stm32f051k6, ct_stm32f051k8, ct_stm32f051r4, ct_stm32f051r6, ct_stm32f051r8, ct_stm32f100x4, ct_stm32f100x6, ct_stm32f100x8, ct_stm32f100xB, ct_stm32f100xC, ct_stm32f100xD, ct_stm32f100xE, ct_stm32f101x4, ct_stm32f101x6, ct_stm32f101x8, ct_stm32f101xB, ct_stm32f101xC, ct_stm32f101xD, ct_stm32f101xE, ct_stm32f101xF, ct_stm32f101xG, ct_stm32f102x4, ct_stm32f102x6, ct_stm32f102x8, ct_stm32f102xB, ct_stm32f103x4, ct_stm32f103x6, ct_stm32f103x8, ct_stm32f103xB, ct_stm32f103xC, ct_stm32f103xD, ct_stm32f103xE, ct_stm32f103xF, ct_stm32f103xG, ct_stm32f107x8, ct_stm32f107xB, ct_stm32f107xC, ct_stm32f105r8, ct_stm32f105rb, ct_stm32f105rc, ct_stm32f105v8, ct_stm32f105vb, ct_stm32f105vc, ct_stm32f107rb, ct_stm32f107rc, ct_stm32f107vb, ct_stm32f107vc, ct_stm32f401cb, ct_stm32f401rb, ct_stm32f401vb, ct_stm32f401cc, ct_stm32f401rc, ct_stm32f401vc, ct_discoveryf401vc, ct_stm32f401cd, ct_stm32f401rd, ct_stm32f401vd, ct_stm32f401ce, ct_stm32f401re, ct_nucleof401re, ct_stm32f401ve, ct_stm32f407vg, ct_discoveryf407vg, ct_stm32f407ig, ct_stm32f407zg, ct_stm32f407ve, ct_stm32f407ze, ct_stm32f407ie, ct_stm32f411cc, ct_stm32f411rc, ct_stm32f411vc, ct_stm32f411ce, ct_stm32f411re, ct_nucleof411re, ct_stm32f411ve, ct_discoveryf411ve, ct_stm32f429vg, ct_stm32f429zg, ct_stm32f429ig, ct_stm32f429vi, ct_stm32f429zi, ct_discoveryf429zi, ct_stm32f429ii, ct_stm32f429ve, ct_stm32f429ze, ct_stm32f429ie, ct_stm32f429bg, ct_stm32f429bi, ct_stm32f429be, ct_stm32f429ng, ct_stm32f429ni, ct_stm32f429ne, ct_stm32f446mc, ct_stm32f446rc, ct_stm32f446vc, ct_stm32f446zc, ct_stm32f446me, ct_stm32f446re, ct_nucleof446re, ct_stm32f446ve, ct_stm32f446ze, ct_stm32f745xe, ct_stm32f745xg, ct_stm32f746xe, ct_stm32f746xg, ct_stm32f756xe, ct_stm32f756xg, { TI - 64 K Flash, 16 K SRAM Devices } ct_lm3s1110, ct_lm3s1133, ct_lm3s1138, ct_lm3s1150, ct_lm3s1162, ct_lm3s1165, ct_lm3s1166, ct_lm3s2110, ct_lm3s2139, ct_lm3s6100, ct_lm3s6110, { TI 128 K Flash, 32 K SRAM devices - Fury Class } ct_lm3s1601, ct_lm3s1608, ct_lm3s1620, ct_lm3s1635, ct_lm3s1636, ct_lm3s1637, ct_lm3s1651, ct_lm3s2601, ct_lm3s2608, ct_lm3s2620, ct_lm3s2637, ct_lm3s2651, ct_lm3s6610, ct_lm3s6611, ct_lm3s6618, ct_lm3s6633, ct_lm3s6637, ct_lm3s8630, { TI 256 K Flase, 32 K SRAM devices - Fury Class } ct_lm3s1911, ct_lm3s1918, ct_lm3s1937, ct_lm3s1958, ct_lm3s1960, ct_lm3s1968, ct_lm3s1969, ct_lm3s2911, ct_lm3s2918, ct_lm3s2919, ct_lm3s2939, ct_lm3s2948, ct_lm3s2950, ct_lm3s2965, ct_lm3s6911, ct_lm3s6918, ct_lm3s6938, ct_lm3s6950, ct_lm3s6952, ct_lm3s6965, ct_lm3s8930, ct_lm3s8933, ct_lm3s8938, ct_lm3s8962, ct_lm3s8970, ct_lm3s8971, { TI - Tempest Tempest - 256 K Flash, 64 K SRAM } ct_lm3s5951, ct_lm3s5956, ct_lm3s1b21, ct_lm3s2b93, ct_lm3s5b91, ct_lm3s9b81, ct_lm3s9b90, ct_lm3s9b92, ct_lm3s9b95, ct_lm3s9b96, ct_lm3s5d51, { TI - Stellaris something } ct_lm4f120h5, { Infineon } ct_xmc4500x1024, ct_xmc4500x768, ct_xmc4502x768, ct_xmc4504x512, { Allwinner } ct_allwinner_a20, { Freescale } ct_mk20dx128vfm5, ct_mk20dx128vft5, ct_mk20dx128vlf5, ct_mk20dx128vlh5, ct_teensy30, ct_mk20dx128vmp5, ct_mk20dx32vfm5, ct_mk20dx32vft5, ct_mk20dx32vlf5, ct_mk20dx32vlh5, ct_mk20dx32vmp5, ct_mk20dx64vfm5, ct_mk20dx64vft5, ct_mk20dx64vlf5, ct_mk20dx64vlh5, ct_mk20dx64vmp5, ct_mk20dx128vlh7, ct_mk20dx128vlk7, ct_mk20dx128vll7, ct_mk20dx128vmc7, ct_mk20dx256vlh7, ct_mk20dx256vlk7, ct_mk20dx256vll7, ct_mk20dx256vmc7, ct_teensy31, ct_teensy32, ct_mk20dx64vlh7, ct_mk20dx64vlk7, ct_mk20dx64vmc7, ct_mk22fn512cap12, ct_mk22fn512cbp12, ct_mk22fn512vdc12, ct_mk22fn512vlh12, ct_mk22fn512vll12, ct_mk22fn512vmp12, ct_freedom_k22f, { Atmel } ct_sam3x8e, ct_arduino_due, ct_flip_n_click, { Nordic Semiconductor } ct_nrf51422_xxaa, ct_nrf51422_xxab, ct_nrf51422_xxac, ct_nrf51822_xxaa, ct_nrf51822_xxab, ct_nrf51822_xxac, ct_nrf52832_xxaa, ct_nrf52840_xxaa, ct_sc32442b, ct_thumb2bare: begin with embedded_controllers[current_settings.controllertype] do with linkres do begin if (embedded_controllers[current_settings.controllertype].controllerunitstr='MK20D5') or (embedded_controllers[current_settings.controllertype].controllerunitstr='MK20D7') or (embedded_controllers[current_settings.controllertype].controllerunitstr='MK22F51212') or (embedded_controllers[current_settings.controllertype].controllerunitstr='MK64F12') then Add('ENTRY(_LOWLEVELSTART)') else Add('ENTRY(_START)'); Add('MEMORY'); Add('{'); if flashsize<>0 then begin LinkStr := ' flash : ORIGIN = 0x' + IntToHex(flashbase,8) + ', LENGTH = 0x' + IntToHex(flashsize,8); Add(LinkStr); end; LinkStr := ' ram : ORIGIN = 0x' + IntToHex(srambase,8) + ', LENGTH = 0x' + IntToHex(sramsize,8); Add(LinkStr); Add('}'); Add('_stack_top = 0x' + IntToHex(sramsize+srambase,8) + ';'); // Add Checksum Calculation for LPC Controllers so that the bootloader starts the uploaded binary writeln(controllerunitstr); if (controllerunitstr = 'LPC8xx') or (controllerunitstr = 'LPC11XX') or (controllerunitstr = 'LPC122X') then Add('Startup_Checksum = 0 - (_stack_top + _START + 1 + NonMaskableInt_interrupt + 1 + Hardfault_interrupt + 1);'); if (controllerunitstr = 'LPC13XX') then Add('Startup_Checksum = 0 - (_stack_top + _START + 1 + NonMaskableInt_interrupt + 1 + MemoryManagement_interrupt + 1 + BusFault_interrupt + 1 + UsageFault_interrupt + 1);'); end; end else if not (cs_link_nolink in current_settings.globalswitches) then internalerror(200902011); end; with linkres do begin Add('SECTIONS'); Add('{'); Add(' .text :'); Add(' {'); Add(' _text_start = .;'); Add(' KEEP(*(.init .init.*))'); if (embedded_controllers[current_settings.controllertype].controllerunitstr='MK20D5') or (embedded_controllers[current_settings.controllertype].controllerunitstr='MK20D7') or (embedded_controllers[current_settings.controllertype].controllerunitstr='MK22F51212') or (embedded_controllers[current_settings.controllertype].controllerunitstr='MK64F12') then begin Add(' . = 0x400;'); Add(' KEEP(*(.flash_config *.flash_config.*))'); end; Add(' *(.text .text.*)'); Add(' *(.strings)'); Add(' *(.rodata .rodata.*)'); Add(' *(.comment)'); Add(' _etext = .;'); if embedded_controllers[current_settings.controllertype].flashsize<>0 then begin Add(' } >flash'); Add(' .note.gnu.build-id : { *(.note.gnu.build-id) } >flash '); end else begin Add(' } >ram'); Add(' .note.gnu.build-id : { *(.note.gnu.build-id) } >ram '); end; Add(' .data :'); Add(' {'); Add(' _data = .;'); Add(' *(.data .data.*)'); Add(' KEEP (*(.fpc .fpc.n_version .fpc.n_links))'); Add(' _edata = .;'); if embedded_controllers[current_settings.controllertype].flashsize<>0 then begin Add(' } >ram AT >flash'); end else begin Add(' } >ram'); end; Add(' .bss :'); Add(' {'); Add(' _bss_start = .;'); Add(' *(.bss .bss.*)'); Add(' *(COMMON)'); Add(' } >ram'); Add('. = ALIGN(4);'); Add('_bss_end = . ;'); Add('}'); Add('_end = .;'); end; {$endif ARM} {$ifdef i386} with linkres do begin Add('ENTRY(_START)'); Add('SECTIONS'); Add('{'); Add(' . = 0x100000;'); Add(' .text ALIGN (0x1000) :'); Add(' {'); Add(' _text = .;'); Add(' KEEP(*(.init .init.*))'); Add(' *(.text .text.*)'); Add(' *(.strings)'); Add(' *(.rodata .rodata.*)'); Add(' *(.comment)'); Add(' _etext = .;'); Add(' }'); Add(' .data ALIGN (0x1000) :'); Add(' {'); Add(' _data = .;'); Add(' *(.data .data.*)'); Add(' KEEP (*(.fpc .fpc.n_version .fpc.n_links))'); Add(' _edata = .;'); Add(' }'); Add(' . = ALIGN(4);'); Add(' .bss :'); Add(' {'); Add(' _bss_start = .;'); Add(' *(.bss .bss.*)'); Add(' *(COMMON)'); Add(' }'); Add('_bss_end = . ;'); Add('}'); Add('_end = .;'); end; {$endif i386} {$ifdef x86_64} with linkres do begin Add('ENTRY(_START)'); Add('SECTIONS'); Add('{'); Add(' . = 0x100000;'); Add(' .text ALIGN (0x1000) :'); Add(' {'); Add(' _text = .;'); Add(' KEEP(*(.init .init.*))'); Add(' *(.text .text.*)'); Add(' *(.strings)'); Add(' *(.rodata .rodata.*)'); Add(' *(.comment)'); Add(' _etext = .;'); Add(' }'); Add(' .data ALIGN (0x1000) :'); Add(' {'); Add(' _data = .;'); Add(' *(.data .data.*)'); Add(' KEEP (*(.fpc .fpc.n_version .fpc.n_links))'); Add(' _edata = .;'); Add(' }'); Add(' . = ALIGN(4);'); Add(' .bss :'); Add(' {'); Add(' _bss_start = .;'); Add(' *(.bss .bss.*)'); Add(' *(COMMON)'); Add(' }'); Add('_bss_end = . ;'); Add('}'); Add('_end = .;'); end; {$endif x86_64} {$ifdef AVR} with linkres do begin { linker script from ld 2.19 } Add('ENTRY(_START)'); Add('OUTPUT_FORMAT("elf32-avr","elf32-avr","elf32-avr")'); case current_settings.cputype of cpu_avr1: Add('OUTPUT_ARCH(avr:1)'); cpu_avr2: Add('OUTPUT_ARCH(avr:2)'); cpu_avr25: Add('OUTPUT_ARCH(avr:25)'); cpu_avr3: Add('OUTPUT_ARCH(avr:3)'); cpu_avr31: Add('OUTPUT_ARCH(avr:31)'); cpu_avr35: Add('OUTPUT_ARCH(avr:35)'); cpu_avr4: Add('OUTPUT_ARCH(avr:4)'); cpu_avr5: Add('OUTPUT_ARCH(avr:5)'); cpu_avr51: Add('OUTPUT_ARCH(avr:51)'); cpu_avr6: Add('OUTPUT_ARCH(avr:6)'); else Internalerror(2015072701); end; Add('MEMORY'); with embedded_controllers[current_settings.controllertype] do begin Add('{'); Add(' text (rx) : ORIGIN = 0, LENGTH = 0x'+IntToHex(flashsize,6)); Add(' data (rw!x) : ORIGIN = 0x'+IntToHex($800000+srambase,6)+', LENGTH = 0x'+IntToHex(sramsize,6)); Add(' eeprom (rw!x) : ORIGIN = 0x810000, LENGTH = 0x'+IntToHex(eepromsize,6)); Add(' fuse (rw!x) : ORIGIN = 0x820000, LENGTH = 1K'); Add(' lock (rw!x) : ORIGIN = 0x830000, LENGTH = 1K'); Add(' signature (rw!x) : ORIGIN = 0x840000, LENGTH = 1K'); Add('}'); Add('_stack_top = 0x' + IntToHex(srambase+sramsize-1,4) + ';'); end; Add('SECTIONS'); Add('{'); Add(' /* Read-only sections, merged into text segment: */'); Add(' .hash : { *(.hash) }'); Add(' .dynsym : { *(.dynsym) }'); Add(' .dynstr : { *(.dynstr) }'); Add(' .gnu.version : { *(.gnu.version) }'); Add(' .gnu.version_d : { *(.gnu.version_d) }'); Add(' .gnu.version_r : { *(.gnu.version_r) }'); Add(' .rel.init : { *(.rel.init) }'); Add(' .rela.init : { *(.rela.init) }'); Add(' .rel.text :'); Add(' {'); Add(' *(.rel.text)'); Add(' *(.rel.text.*)'); Add(' *(.rel.gnu.linkonce.t*)'); Add(' }'); Add(' .rela.text :'); Add(' {'); Add(' *(.rela.text)'); Add(' *(.rela.text.*)'); Add(' *(.rela.gnu.linkonce.t*)'); Add(' }'); Add(' .rel.fini : { *(.rel.fini) }'); Add(' .rela.fini : { *(.rela.fini) }'); Add(' .rel.rodata :'); Add(' {'); Add(' *(.rel.rodata)'); Add(' *(.rel.rodata.*)'); Add(' *(.rel.gnu.linkonce.r*)'); Add(' }'); Add(' .rela.rodata :'); Add(' {'); Add(' *(.rela.rodata)'); Add(' *(.rela.rodata.*)'); Add(' *(.rela.gnu.linkonce.r*)'); Add(' }'); Add(' .rel.data :'); Add(' {'); Add(' *(.rel.data)'); Add(' *(.rel.data.*)'); Add(' *(.rel.gnu.linkonce.d*)'); Add(' }'); Add(' .rela.data :'); Add(' {'); Add(' *(.rela.data)'); Add(' *(.rela.data.*)'); Add(' *(.rela.gnu.linkonce.d*)'); Add(' }'); Add(' .rel.ctors : { *(.rel.ctors) }'); Add(' .rela.ctors : { *(.rela.ctors) }'); Add(' .rel.dtors : { *(.rel.dtors) }'); Add(' .rela.dtors : { *(.rela.dtors) }'); Add(' .rel.got : { *(.rel.got) }'); Add(' .rela.got : { *(.rela.got) }'); Add(' .rel.bss : { *(.rel.bss) }'); Add(' .rela.bss : { *(.rela.bss) }'); Add(' .rel.plt : { *(.rel.plt) }'); Add(' .rela.plt : { *(.rela.plt) }'); Add(' /* Internal text space or external memory. */'); Add(' .text :'); Add(' {'); Add(' KEEP(*(.init .init.*))'); Add(' /* For data that needs to reside in the lower 64k of progmem. */'); Add(' *(.progmem.gcc*)'); Add(' *(.progmem*)'); Add(' . = ALIGN(2);'); Add(' __trampolines_start = . ;'); Add(' /* The jump trampolines for the 16-bit limited relocs will reside here. */'); Add(' *(.trampolines)'); Add(' *(.trampolines*)'); Add(' __trampolines_end = . ;'); Add(' /* For future tablejump instruction arrays for 3 byte pc devices.'); Add(' We don''t relax jump/call instructions within these sections. */'); Add(' *(.jumptables)'); Add(' *(.jumptables*)'); Add(' /* For code that needs to reside in the lower 128k progmem. */'); Add(' *(.lowtext)'); Add(' *(.lowtext*)'); Add(' __ctors_start = . ;'); Add(' *(.ctors)'); Add(' __ctors_end = . ;'); Add(' __dtors_start = . ;'); Add(' *(.dtors)'); Add(' __dtors_end = . ;'); Add(' KEEP(SORT(*)(.ctors))'); Add(' KEEP(SORT(*)(.dtors))'); Add(' /* From this point on, we don''t bother about wether the insns are'); Add(' below or above the 16 bits boundary. */'); Add(' *(.init0) /* Start here after reset. */'); Add(' KEEP (*(.init0))'); Add(' *(.init1)'); Add(' KEEP (*(.init1))'); Add(' *(.init2) /* Clear __zero_reg__, set up stack pointer. */'); Add(' KEEP (*(.init2))'); Add(' *(.init3)'); Add(' KEEP (*(.init3))'); Add(' *(.init4) /* Initialize data and BSS. */'); Add(' KEEP (*(.init4))'); Add(' *(.init5)'); Add(' KEEP (*(.init5))'); Add(' *(.init6) /* C++ constructors. */'); Add(' KEEP (*(.init6))'); Add(' *(.init7)'); Add(' KEEP (*(.init7))'); Add(' *(.init8)'); Add(' KEEP (*(.init8))'); Add(' *(.init9) /* Call main(). */'); Add(' KEEP (*(.init9))'); Add(' *(.text)'); Add(' . = ALIGN(2);'); Add(' *(.text.*)'); Add(' . = ALIGN(2);'); Add(' *(.fini9) /* _exit() starts here. */'); Add(' KEEP (*(.fini9))'); Add(' *(.fini8)'); Add(' KEEP (*(.fini8))'); Add(' *(.fini7)'); Add(' KEEP (*(.fini7))'); Add(' *(.fini6) /* C++ destructors. */'); Add(' KEEP (*(.fini6))'); Add(' *(.fini5)'); Add(' KEEP (*(.fini5))'); Add(' *(.fini4)'); Add(' KEEP (*(.fini4))'); Add(' *(.fini3)'); Add(' KEEP (*(.fini3))'); Add(' *(.fini2)'); Add(' KEEP (*(.fini2))'); Add(' *(.fini1)'); Add(' KEEP (*(.fini1))'); Add(' *(.fini0) /* Infinite loop after program termination. */'); Add(' KEEP (*(.fini0))'); Add(' _etext = . ;'); Add(' } > text'); Add(' .data : AT (ADDR (.text) + SIZEOF (.text))'); Add(' {'); Add(' PROVIDE (__data_start = .) ;'); Add(' *(.data)'); Add(' *(.data*)'); Add(' *(.rodata) /* We need to include .rodata here if gcc is used */'); Add(' *(.rodata*) /* with -fdata-sections. */'); Add(' *(.gnu.linkonce.d*)'); Add(' . = ALIGN(2);'); Add(' _edata = . ;'); Add(' PROVIDE (__data_end = .) ;'); Add(' } > data'); Add(' .bss : AT (ADDR (.bss))'); Add(' {'); Add(' PROVIDE (__bss_start = .) ;'); Add(' *(.bss)'); Add(' *(.bss*)'); Add(' *(COMMON)'); Add(' PROVIDE (__bss_end = .) ;'); Add(' } > data'); Add(' __data_load_start = LOADADDR(.data);'); Add(' __data_load_end = __data_load_start + SIZEOF(.data);'); Add(' /* Global data not cleared after reset. */'); Add(' .noinit :'); Add(' {'); Add(' PROVIDE (__noinit_start = .) ;'); Add(' *(.noinit*)'); Add(' PROVIDE (__noinit_end = .) ;'); Add(' _end = . ;'); Add(' PROVIDE (__heap_start = .) ;'); Add(' } > data'); Add(' .eeprom :'); Add(' {'); Add(' *(.eeprom*)'); Add(' __eeprom_end = . ;'); Add(' } > eeprom'); Add(' .fuse :'); Add(' {'); Add(' KEEP(*(.fuse))'); Add(' KEEP(*(.lfuse))'); Add(' KEEP(*(.hfuse))'); Add(' KEEP(*(.efuse))'); Add(' } > fuse'); Add(' .lock :'); Add(' {'); Add(' KEEP(*(.lock*))'); Add(' } > lock'); Add(' .signature :'); Add(' {'); Add(' KEEP(*(.signature*))'); Add(' } > signature'); Add(' /* Stabs debugging sections. */'); Add(' .stab 0 : { *(.stab) }'); Add(' .stabstr 0 : { *(.stabstr) }'); Add(' .stab.excl 0 : { *(.stab.excl) }'); Add(' .stab.exclstr 0 : { *(.stab.exclstr) }'); Add(' .stab.index 0 : { *(.stab.index) }'); Add(' .stab.indexstr 0 : { *(.stab.indexstr) }'); Add(' .comment 0 : { *(.comment) }'); Add(' /* DWARF debug sections.'); Add(' Symbols in the DWARF debugging sections are relative to the beginning'); Add(' of the section so we begin them at 0. */'); Add(' /* DWARF 1 */'); Add(' .debug 0 : { *(.debug) }'); Add(' .line 0 : { *(.line) }'); Add(' /* GNU DWARF 1 extensions */'); Add(' .debug_srcinfo 0 : { *(.debug_srcinfo) }'); Add(' .debug_sfnames 0 : { *(.debug_sfnames) }'); Add(' /* DWARF 1.1 and DWARF 2 */'); Add(' .debug_aranges 0 : { *(.debug_aranges) }'); Add(' .debug_pubnames 0 : { *(.debug_pubnames) }'); Add(' /* DWARF 2 */'); Add(' .debug_info 0 : { *(.debug_info) *(.gnu.linkonce.wi.*) }'); Add(' .debug_abbrev 0 : { *(.debug_abbrev) }'); Add(' .debug_line 0 : { *(.debug_line) }'); Add(' .debug_frame 0 : { *(.debug_frame) }'); Add(' .debug_str 0 : { *(.debug_str) }'); Add(' .debug_loc 0 : { *(.debug_loc) }'); Add(' .debug_macinfo 0 : { *(.debug_macinfo) }'); Add('}'); end; {$endif AVR} {$ifdef MIPSEL} case current_settings.controllertype of ct_none: begin end; ct_pic32mx110f016b, ct_pic32mx110f016c, ct_pic32mx110f016d, ct_pic32mx120f032b, ct_pic32mx120f032c, ct_pic32mx120f032d, ct_pic32mx130f064b, ct_pic32mx130f064c, ct_pic32mx130f064d, ct_pic32mx150f128b, ct_pic32mx150f128c, ct_pic32mx150f128d, ct_pic32mx210f016b, ct_pic32mx210f016c, ct_pic32mx210f016d, ct_pic32mx220f032b, ct_pic32mx220f032c, ct_pic32mx220f032d, ct_pic32mx230f064b, ct_pic32mx230f064c, ct_pic32mx230f064d, ct_pic32mx250f128b, ct_pic32mx250f128c, ct_pic32mx250f128d, ct_pic32mx775f256h, ct_pic32mx775f256l, ct_pic32mx775f512h, ct_pic32mx775f512l, ct_pic32mx795f512h, ct_pic32mx795f512l: begin with embedded_controllers[current_settings.controllertype] do with linkres do begin Add('OUTPUT_FORMAT("elf32-tradlittlemips")'); Add('OUTPUT_ARCH(pic32mx)'); Add('ENTRY(_reset)'); Add('PROVIDE(_vector_spacing = 0x00000001);'); Add('_ebase_address = 0x'+IntToHex(flashbase,8)+';'); Add('_RESET_ADDR = 0xBFC00000;'); Add('_BEV_EXCPT_ADDR = 0xBFC00380;'); Add('_DBG_EXCPT_ADDR = 0xBFC00480;'); Add('_GEN_EXCPT_ADDR = _ebase_address + 0x180;'); Add('MEMORY'); Add('{'); if flashsize<>0 then begin Add(' kseg0_program_mem : ORIGIN = 0x'+IntToHex(flashbase,8)+', LENGTH = 0x'+IntToHex(flashsize,8)); //TODO This should better be placed into the controllertype records Add(' kseg1_boot_mem : ORIGIN = 0xBFC00000, LENGTH = 0xbef'); Add(' config3 : ORIGIN = 0xBFC00BF0, LENGTH = 0x4'); Add(' config2 : ORIGIN = 0xBFC00BF4, LENGTH = 0x4'); Add(' config1 : ORIGIN = 0xBFC00BF8, LENGTH = 0x4'); Add(' config0 : ORIGIN = 0xBFC00BFC, LENGTH = 0x4'); end; Add(' ram : ORIGIN = 0x' + IntToHex(srambase,8) + ', LENGTH = 0x' + IntToHex(sramsize,8)); Add('}'); Add('_stack_top = 0x' + IntToHex(sramsize+srambase,8) + ';'); end; end else if not (cs_link_nolink in current_settings.globalswitches) then internalerror(200902011); end; with linkres do begin Add('SECTIONS'); Add('{'); Add(' .reset _RESET_ADDR :'); Add(' {'); Add(' KEEP(*(.reset .reset.*))'); Add(' KEEP(*(.startup .startup.*))'); Add(' } > kseg1_boot_mem'); Add(' .bev_excpt _BEV_EXCPT_ADDR :'); Add(' {'); Add(' KEEP(*(.bev_handler))'); Add(' } > kseg1_boot_mem'); Add(' .text :'); Add(' {'); Add(' _text_start = .;'); Add(' . = _text_start + 0x180;'); Add(' KEEP(*(.gen_handler))'); Add(' . = _text_start + 0x200;'); Add(' KEEP(*(.init .init.*))'); Add(' *(.text .text.*)'); Add(' *(.strings)'); Add(' *(.rodata .rodata.*)'); Add(' *(.comment)'); Add(' _etext = .;'); if embedded_controllers[current_settings.controllertype].flashsize<>0 then begin Add(' } >kseg0_program_mem'); end else begin Add(' } >ram'); end; Add(' .note.gnu.build-id : { *(.note.gnu.build-id) }'); Add(' .data :'); Add(' {'); Add(' _data = .;'); Add(' *(.data .data.*)'); Add(' KEEP (*(.fpc .fpc.n_version .fpc.n_links))'); Add(' . = .;'); Add(' _gp = ALIGN(16) + 0x7ff0;'); Add(' _edata = .;'); if embedded_controllers[current_settings.controllertype].flashsize<>0 then begin Add(' } >ram AT >kseg0_program_mem'); end else begin Add(' } >ram'); end; Add(' .config_BFC00BF0 : {'); Add(' KEEP(*(.config_BFC00BF0))'); Add(' } > config3'); Add(' .config_BFC00BF4 : {'); Add(' KEEP(*(.config_BFC00BF4))'); Add(' } > config2'); Add(' .config_BFC00BF8 : {'); Add(' KEEP(*(.config_BFC00BF8))'); Add(' } > config1'); Add(' .config_BFC00BFC : {'); Add(' KEEP(*(.config_BFC00BFC))'); Add(' } > config0'); Add(' .bss :'); Add(' {'); Add(' _bss_start = .;'); Add(' *(.bss .bss.*)'); Add(' *(COMMON)'); Add(' } >ram'); Add('. = ALIGN(4);'); Add('_bss_end = . ;'); Add(' .comment 0 : { *(.comment) }'); Add(' /* DWARF debug sections.'); Add(' Symbols in the DWARF debugging sections are relative to the beginning'); Add(' of the section so we begin them at 0. */'); Add(' /* DWARF 1 */'); Add(' .debug 0 : { *(.debug) }'); Add(' .line 0 : { *(.line) }'); Add(' /* GNU DWARF 1 extensions */'); Add(' .debug_srcinfo 0 : { *(.debug_srcinfo) }'); Add(' .debug_sfnames 0 : { *(.debug_sfnames) }'); Add(' /* DWARF 1.1 and DWARF 2 */'); Add(' .debug_aranges 0 : { *(.debug_aranges) }'); Add(' .debug_pubnames 0 : { *(.debug_pubnames) }'); Add(' /* DWARF 2 */'); Add(' .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }'); Add(' .debug_abbrev 0 : { *(.debug_abbrev) }'); Add(' /DISCARD/ : { *(.debug_line) }'); Add(' .debug_frame 0 : { *(.debug_frame) }'); Add(' .debug_str 0 : { *(.debug_str) }'); Add(' /DISCARD/ : { *(.debug_loc) }'); Add(' .debug_macinfo 0 : { *(.debug_macinfo) }'); Add(' /* SGI/MIPS DWARF 2 extensions */'); Add(' .debug_weaknames 0 : { *(.debug_weaknames) }'); Add(' .debug_funcnames 0 : { *(.debug_funcnames) }'); Add(' .debug_typenames 0 : { *(.debug_typenames) }'); Add(' .debug_varnames 0 : { *(.debug_varnames) }'); Add(' /* DWARF 3 */'); Add(' .debug_pubtypes 0 : { *(.debug_pubtypes) }'); Add(' .debug_ranges 0 : { *(.debug_ranges) }'); Add(' .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }'); Add(' .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }'); Add(' .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }'); Add(' .mdebug.abi32 : { KEEP(*(.mdebug.abi32)) }'); Add(' .mdebug.abiN32 : { KEEP(*(.mdebug.abiN32)) }'); Add(' .mdebug.abi64 : { KEEP(*(.mdebug.abi64)) }'); Add(' .mdebug.abiO64 : { KEEP(*(.mdebug.abiO64)) }'); Add(' .mdebug.eabi32 : { KEEP(*(.mdebug.eabi32)) }'); Add(' .mdebug.eabi64 : { KEEP(*(.mdebug.eabi64)) }'); Add(' /DISCARD/ : { *(.rel.dyn) }'); Add(' /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }'); Add('}'); Add('_end = .;'); end; {$endif MIPSEL} { Write and Close response } linkres.writetodisk; linkres.free; WriteResponseFile:=True; end; function TlinkerEmbedded.MakeExecutable:boolean; var binstr, cmdstr : TCmdStr; success : boolean; StaticStr, GCSectionsStr, DynLinkStr, StripStr: string; begin { for future use } StaticStr:=''; StripStr:=''; DynLinkStr:=''; GCSectionsStr:='--gc-sections'; //if not(cs_link_extern in current_settings.globalswitches) then if not(cs_link_nolink in current_settings.globalswitches) then Message1(exec_i_linking,current_module.exefilename); { Write used files and libraries } WriteResponseFile(); { Call linker } SplitBinCmd(Info.ExeCmd[1],binstr,cmdstr); Replace(cmdstr,'$OPT',Info.ExtraOptions); if not(cs_link_on_target in current_settings.globalswitches) then begin Replace(cmdstr,'$EXE',(maybequoted(ScriptFixFileName(ChangeFileExt(current_module.exefilename,'.elf'))))); Replace(cmdstr,'$RES',(maybequoted(ScriptFixFileName(outputexedir+Info.ResName)))); Replace(cmdstr,'$STATIC',StaticStr); Replace(cmdstr,'$STRIP',StripStr); Replace(cmdstr,'$GCSECTIONS',GCSectionsStr); Replace(cmdstr,'$DYNLINK',DynLinkStr); end else begin Replace(cmdstr,'$EXE',maybequoted(ScriptFixFileName(ChangeFileExt(current_module.exefilename,'.elf')))); Replace(cmdstr,'$RES',maybequoted(ScriptFixFileName(outputexedir+Info.ResName))); Replace(cmdstr,'$STATIC',StaticStr); Replace(cmdstr,'$STRIP',StripStr); Replace(cmdstr,'$GCSECTIONS',GCSectionsStr); Replace(cmdstr,'$DYNLINK',DynLinkStr); end; success:=DoExec(FindUtil(utilsprefix+BinStr),cmdstr,true,false); { Remove ReponseFile } if success and not(cs_link_nolink in current_settings.globalswitches) then DeleteFile(outputexedir+Info.ResName); { Post process } if success and not(cs_link_nolink in current_settings.globalswitches) then success:=PostProcessExecutable(current_module.exefilename+'.elf',false); if success and (target_info.system in [system_arm_embedded,system_avr_embedded,system_mipsel_embedded]) then begin success:=DoExec(FindUtil(utilsprefix+'objcopy'),'-O ihex '+ ChangeFileExt(current_module.exefilename,'.elf')+' '+ ChangeFileExt(current_module.exefilename,'.hex'),true,false); if success then success:=DoExec(FindUtil(utilsprefix+'objcopy'),'-O binary '+ ChangeFileExt(current_module.exefilename,'.elf')+' '+ ChangeFileExt(current_module.exefilename,'.bin'),true,false); end; MakeExecutable:=success; { otherwise a recursive call to link method } end; function TLinkerEmbedded.postprocessexecutable(const fn : string;isdll:boolean):boolean; type TElf32header=packed record magic0123 : longint; file_class : byte; data_encoding : byte; file_version : byte; padding : array[$07..$0f] of byte; e_type : word; e_machine : word; e_version : longint; e_entry : longint; { entrypoint } e_phoff : longint; { program header offset } e_shoff : longint; { sections header offset } e_flags : longint; e_ehsize : word; { elf header size in bytes } e_phentsize : word; { size of an entry in the program header array } e_phnum : word; { 0..e_phnum-1 of entrys } e_shentsize : word; { size of an entry in sections header array } e_shnum : word; { 0..e_shnum-1 of entrys } e_shstrndx : word; { index of string section header } end; TElf32sechdr=packed record sh_name : longint; sh_type : longint; sh_flags : longint; sh_addr : longint; sh_offset : longint; sh_size : longint; sh_link : longint; sh_info : longint; sh_addralign : longint; sh_entsize : longint; end; function MayBeSwapHeader(h : telf32header) : telf32header; begin result:=h; if source_info.endian<>target_info.endian then with h do begin result.e_type:=swapendian(e_type); result.e_machine:=swapendian(e_machine); result.e_version:=swapendian(e_version); result.e_entry:=swapendian(e_entry); result.e_phoff:=swapendian(e_phoff); result.e_shoff:=swapendian(e_shoff); result.e_flags:=swapendian(e_flags); result.e_ehsize:=swapendian(e_ehsize); result.e_phentsize:=swapendian(e_phentsize); result.e_phnum:=swapendian(e_phnum); result.e_shentsize:=swapendian(e_shentsize); result.e_shnum:=swapendian(e_shnum); result.e_shstrndx:=swapendian(e_shstrndx); end; end; function MaybeSwapSecHeader(h : telf32sechdr) : telf32sechdr; begin result:=h; if source_info.endian<>target_info.endian then with h do begin result.sh_name:=swapendian(sh_name); result.sh_type:=swapendian(sh_type); result.sh_flags:=swapendian(sh_flags); result.sh_addr:=swapendian(sh_addr); result.sh_offset:=swapendian(sh_offset); result.sh_size:=swapendian(sh_size); result.sh_link:=swapendian(sh_link); result.sh_info:=swapendian(sh_info); result.sh_addralign:=swapendian(sh_addralign); result.sh_entsize:=swapendian(sh_entsize); end; end; var f : file; function ReadSectionName(pos : longint) : String; var oldpos : longint; c : char; begin oldpos:=filepos(f); seek(f,pos); Result:=''; while true do begin blockread(f,c,1); if c=#0 then break; Result:=Result+c; end; seek(f,oldpos); end; var elfheader : TElf32header; secheader : TElf32sechdr; i : longint; stringoffset : longint; secname : string; begin postprocessexecutable:=false; { open file } assign(f,fn); {$push}{$I-} reset(f,1); if ioresult<>0 then Message1(execinfo_f_cant_open_executable,fn); { read header } blockread(f,elfheader,sizeof(tElf32header)); elfheader:=MayBeSwapHeader(elfheader); seek(f,elfheader.e_shoff); { read string section header } seek(f,elfheader.e_shoff+sizeof(TElf32sechdr)*elfheader.e_shstrndx); blockread(f,secheader,sizeof(secheader)); secheader:=MaybeSwapSecHeader(secheader); stringoffset:=secheader.sh_offset; seek(f,elfheader.e_shoff); status.datasize:=0; for i:=0 to elfheader.e_shnum-1 do begin blockread(f,secheader,sizeof(secheader)); secheader:=MaybeSwapSecHeader(secheader); secname:=ReadSectionName(stringoffset+secheader.sh_name); if secname='.text' then begin Message1(execinfo_x_codesize,tostr(secheader.sh_size)); status.codesize:=secheader.sh_size; end else if secname='.data' then begin Message1(execinfo_x_initdatasize,tostr(secheader.sh_size)); inc(status.datasize,secheader.sh_size); end else if secname='.bss' then begin Message1(execinfo_x_uninitdatasize,tostr(secheader.sh_size)); inc(status.datasize,secheader.sh_size); end; end; close(f); {$pop} if ioresult<>0 then ; postprocessexecutable:=true; end; {***************************************************************************** Initialize *****************************************************************************} initialization {$ifdef arm} RegisterLinker(ld_embedded,TLinkerEmbedded); RegisterTarget(system_arm_embedded_info); {$endif arm} {$ifdef avr} RegisterLinker(ld_embedded,TLinkerEmbedded); RegisterTarget(system_avr_embedded_info); {$endif avr} {$ifdef i386} RegisterLinker(ld_embedded,TLinkerEmbedded); RegisterTarget(system_i386_embedded_info); {$endif i386} {$ifdef x86_64} RegisterLinker(ld_embedded,TLinkerEmbedded); RegisterTarget(system_x86_64_embedded_info); {$endif x86_64} {$ifdef i8086} { no need to register linker ld_embedded, because i8086_embedded uses the regular msdos linker. In case a flat binary, relocated for a specific segment address is needed (e.g. for a BIOS or a real mode bootloader), it can be produced post-compilation with exe2bin or a similar tool. } RegisterTarget(system_i8086_embedded_info); {$endif i8086} {$ifdef mipsel} RegisterLinker(ld_embedded,TLinkerEmbedded); RegisterTarget(system_mipsel_embedded_info); {$endif mipsel} {$ifdef m68k} RegisterLinker(ld_embedded,TLinkerEmbedded); RegisterTarget(system_m68k_embedded_info); {$endif m68k} end.