Aren
/
rulimine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

build: Make build system more BSD friendly

This commit is contained in:
mintsuki 2021-07-26 16:09:03 +02:00
parent e9760d2e33
commit af03050db3
7 changed files with 102 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Makefile
View File

@ -2,19 +2,24 @@ PREFIX = /usr/local
DESTDIR = DESTDIR =
PATH := $(shell pwd)/toolchain/bin:$(PATH) PATH := $(shell pwd)/toolchain/bin:$(PATH)
SHELL := /usr/bin/env bash
NCPUS := $(shell nproc 2>/dev/null || sysctl -n hw.ncpu 2>/dev/null || echo 1)
TOOLCHAIN = x86_64-elf TOOLCHAIN = x86_64-elf
TOOLCHAIN_CC = $(TOOLCHAIN)-gcc TOOLCHAIN_CC = $(TOOLCHAIN)-gcc
ifeq ($(shell export "PATH=$(PATH)"; command -v $(TOOLCHAIN_CC) ; ), ) ifeq ($(shell export "PATH=$(PATH)"; command -v $(TOOLCHAIN_CC) ; ), )
TOOLCHAIN_CC := gcc TOOLCHAIN_CC := cc
endif endif
ifneq ($(MAKECMDGOALS), toolchain) ifneq ($(MAKECMDGOALS), toolchain)
ifneq ($(MAKECMDGOALS), distclean)
ifneq ($(MAKECMDGOALS), distclean2)
ifneq ($(shell export "PATH=$(PATH)"; $(TOOLCHAIN_CC) -dumpmachine | head -c 6), x86_64) ifneq ($(shell export "PATH=$(PATH)"; $(TOOLCHAIN_CC) -dumpmachine | head -c 6), x86_64)
$(error No suitable x86_64 GCC compiler found, please install an x86_64 GCC toolchain or run "make toolchain") $(error No suitable x86_64 C compiler found, please install an x86_64 C toolchain or run "make toolchain")
endif
endif
endif endif
endif endif
@ -29,7 +34,7 @@ all:
.PHONY: bin/limine-install .PHONY: bin/limine-install
bin/limine-install: bin/limine-install:
$(MAKE) -C limine-install LIMINE_HDD_BIN=`realpath bin`/limine-hdd.bin $(MAKE) -C limine-install LIMINE_HDD_BIN="`pwd`/bin/limine-hdd.bin"
[ -f limine-install/limine-install ] && cp limine-install/limine-install bin/ || true [ -f limine-install/limine-install ] && cp limine-install/limine-install bin/ || true
[ -f limine-install/limine-install.exe ] && cp limine-install/limine-install.exe bin/ || true [ -f limine-install/limine-install.exe ] && cp limine-install/limine-install.exe bin/ || true
@ -149,7 +154,7 @@ test-clean:
.PHONY: toolchain .PHONY: toolchain
toolchain: toolchain:
aux/make_toolchain.sh "`realpath ./toolchain`" -j`nproc` MAKE="$(MAKE)" aux/make_toolchain.sh "`pwd`/toolchain" -j$(NCPUS)
gnu-efi: gnu-efi:
git clone https://git.code.sf.net/p/gnu-efi/code --branch=3.0.13 --depth=1 $@ git clone https://git.code.sf.net/p/gnu-efi/code --branch=3.0.13 --depth=1 $@

125
README.md
View File

@ -2,11 +2,13 @@
### What is Limine? ### What is Limine?
Limine is an advanced x86/x86_64 BIOS/UEFI Bootloader which supports *modern* PC features Limine is a modern, advanced x86/x86_64 BIOS/UEFI multiprotocol bootloader used
such as Long Mode, 5-level paging, and SMP (multicore), to name a few. as the reference implementation for the
[stivale protocols](https://github.com/stivale/stivale).
### Support Limine ### Support Limine
Like Limine and want to support it? Donate Bitcoin to `bc1q00d59y75crpapw7qp8sea5j5sx6l4k2ssjylf9` :) Like Limine and want to support it? Donate Bitcoin to
`bc1q00d59y75crpapw7qp8sea5j5sx6l4k2ssjylf9` :)
### Limine's boot menu ### Limine's boot menu
@ -15,8 +17,8 @@ Like Limine and want to support it? Donate Bitcoin to `bc1q00d59y75crpapw7qp8sea
[Photo by Chris Kane from Pexels](https://www.pexels.com/photo/reflection-of-building-on-body-of-water-at-daytime-166360/) [Photo by Chris Kane from Pexels](https://www.pexels.com/photo/reflection-of-building-on-body-of-water-at-daytime-166360/)
### Supported boot protocols ### Supported boot protocols
* Linux
* stivale and stivale2 (Limine's native boot protocols, see [their specifications](https://github.com/stivale/stivale) for details) * stivale and stivale2 (Limine's native boot protocols, see [their specifications](https://github.com/stivale/stivale) for details)
* Linux
* Multiboot 1 * Multiboot 1
* Chainloading * Chainloading
@ -33,26 +35,30 @@ Like Limine and want to support it? Donate Bitcoin to `bc1q00d59y75crpapw7qp8sea
## Binary releases ## Binary releases
For convenience, for point releases, binaries are distributed. These binaries are For convenience, for point releases, binaries are distributed. These binaries
shipped in the `-binary` branches and tags of this repository (see [branches](https://github.com/limine-bootloader/limine/branches/all) and [tags](https://github.com/limine-bootloader/limine/tags)). are shipped in the `-binary` branches and tags of this repository
(see [branches](https://github.com/limine-bootloader/limine/branches/all) and
[tags](https://github.com/limine-bootloader/limine/tags)).
For example, to clone the latest binary release of the `v2.x` branch one can do For example, to clone the latest binary release of the `v2.x` branch one can do
```bash ```bash
git clone https://github.com/limine-bootloader/limine.git --branch=v2.0-branch-binary --depth=1 git clone https://github.com/limine-bootloader/limine.git --branch=v2.0-branch-binary --depth=1
``` ```
or, to clone a specific binary point release (for example v2.29) or, to clone a specific binary point release (for example v2.40)
```bash ```bash
git clone https://github.com/limine-bootloader/limine.git --branch=v2.29-binary --depth=1 git clone https://github.com/limine-bootloader/limine.git --branch=v2.40-binary --depth=1
``` ```
Additionally, the absolute latest Limine binary release can be obtained by fetching Additionally, the absolute latest Limine binary release can be obtained by
the `latest-binary` branch: fetching the `latest-binary` branch:
```bash ```bash
git clone https://github.com/limine-bootloader/limine.git --branch=latest-binary --depth=1 git clone https://github.com/limine-bootloader/limine.git --branch=latest-binary --depth=1
``` ```
`limine-install` binaries are provided for Linux and Windows. In case one wants to `limine-install` binaries are provided for Linux and Windows.
rebuild `limine-install`, simply use `make` in the binary release.
In case one wants to rebuild `limine-install`, simply use `make` in the binary
release.
## Building the bootloader ## Building the bootloader
@ -64,35 +70,39 @@ rebuild `limine-install`, simply use `make` in the binary release.
### Building the toolchain ### Building the toolchain
This step can take a long time, but it will ensure that the compiler will work with This step can take a long time, but it will ensure that the toolchain will work
Limine. If on an x86_64 host, with GCC or Clang installed, you can also skip to the next paragraph. with Limine. If on an x86_64 host, with GCC or Clang installed, you can skip to
the next paragraph in order to use the system's toolchain instead.
The toolchain building process depends on the following packages: `bash`, `make`, The toolchain's build process depends on the following packages: `GNU make`,
`curl`, `gcc`, `g++`, `GNU binutils`. `curl`, `gcc/clang`, `g++/clang++`.
Building the toolchain can be accomplished by running: Building the toolchain can be accomplished by running:
```bash ```bash
make toolchain make toolchain # (or gmake where applicable)
``` ```
*The above step may take a while*
### Building Limine ### Building Limine
In order to build Limine, the following packages have to be installed: `bash`, `make`, In order to build Limine, the following packages have to be installed:
`git`, `nasm`, `mtools` (optional, necessary to build `limine-eltorito-efi.bin`). `GNU make`, `git`, `nasm`, `mtools` (optional, necessary to build
Furthermore, either the toolchain must have been built in the previous paragraph, `limine-eltorito-efi.bin`).
or `gcc` or `llvm/clang` must also be installed. Furthermore, either the toolchain must have been built in the previous
`GNU binutils` is necessary in order to build the UEFI port of Limine. A full paragraph, or `gcc` or `llvm/clang` must also be installed.
LLVM toolchain without `GNU binutils` can be used to build the BIOS port instead. `GNU binutils` is necessary in order to build the UEFI ports of Limine. A full
LLVM toolchain without `GNU binutils` can be used to build just the BIOS port
instead.
Both the UEFI and BIOS ports of the bootloader can be built, using `GCC/GNU binutils`, with: Both the UEFI and BIOS ports of the bootloader can be built, using
`GCC/GNU binutils` (which includes the shipped toolchain), with:
```bash ```bash
make make # (or gmake where applicable)
``` ```
It is possible to pass `make` additional flags, most relevantly, `TOOLCHAIN=` which It is possible to pass `make` additional flags, most relevantly,
allows one to specify an alternative toolchain for the build system to use `TOOLCHAIN=`, which allows one to specify an alternative toolchain for the build
(the default is `x86_64-elf`, falling back to no-triple, or host, toolchain). system to use (the default is `x86_64-elf`, falling back to no-triple, or host,
toolchain).
The generated bootloader files are going to be in `bin`. The generated bootloader files are going to be in `bin`.
@ -100,29 +110,36 @@ The generated bootloader files are going to be in `bin`.
In order to build the BIOS port fully using clang/LLVM, run `make` as such: In order to build the BIOS port fully using clang/LLVM, run `make` as such:
```bash ```bash
# (or gmake where applicable)
make limine-bios bin/limine-install CC="clang" TOOLCHAIN="llvm" TOOLCHAIN_CC="clang" TOOLCHAIN_LD="ld.lld" make limine-bios bin/limine-install CC="clang" TOOLCHAIN="llvm" TOOLCHAIN_CC="clang" TOOLCHAIN_LD="ld.lld"
``` ```
And in order to build the UEFI port using clang/LLVM + `GNU binutils`, run `make` as such:
And in order to build the UEFI port using clang/LLVM + `GNU binutils`, run
`make` as such:
```bash ```bash
# (or gmake where applicable)
make limine-uefi TOOLCHAIN="llvm" TOOLCHAIN_CC="clang" TOOLCHAIN_LD="ld" TOOLCHAIN_OBJCOPY="objcopy" make limine-uefi TOOLCHAIN="llvm" TOOLCHAIN_CC="clang" TOOLCHAIN_LD="ld" TOOLCHAIN_OBJCOPY="objcopy"
``` ```
Where `ld` and `objcopy` refer to GNU binutils versions of them. Specify their
full path if necessary.
## Installing Limine binaries ## Installing Limine binaries
This step is optional as the bootloader binaries can be used from the `bin` or This step is optional as the bootloader binaries can be used from the `bin` or
release directory just fine. This step will only install them in a `share` and `bin` release directory just fine. This step will only install them to a `share` and
directories in the specified `PREFIX` (default is `/usr/local`). `bin` directories in the specified `PREFIX` (default is `/usr/local`).
Use `make install` to install Limine binaries, optionally specifying a prefix with a Use `make install` to install the Limine binaries, optionally specifying a
`PREFIX=...` option. different prefix with `make install PREFIX=/myprefix`.
## How to use ## How to use
### UEFI ### UEFI
The `BOOTX64.EFI` file is a vaild EFI application that can be simply copied to the The `BOOTX64.EFI` file is a vaild EFI application that can be simply copied to
`/EFI/BOOT` directory of a FAT formatted EFI system partition. This file can be the `/EFI/BOOT` directory of a FAT formatted EFI system partition. This file can
installed there and coexist with a BIOS installation of Limine (see below) so that be installed there and coexist with a BIOS installation of Limine (see below) so
the disk will be bootable by both BIOS and UEFI. that the disk will be bootable on both BIOS and UEFI systems.
The boot device must to contain the `limine.cfg` file in The boot device must to contain the `limine.cfg` file in
either the root or the `boot` directory of one of the partitions, formatted either the root or the `boot` directory of one of the partitions, formatted
@ -141,7 +158,8 @@ either the root or the `boot` directory of one of the partitions, formatted
with a supported file system. with a supported file system.
### BIOS/GPT ### BIOS/GPT
If using a GPT formatted device, there are 2 options one can follow for installation: If using a GPT formatted device, there are 2 options one can follow for
installation:
* Specifying a dedicated stage 2 partition. * Specifying a dedicated stage 2 partition.
* Letting `limine-install` attempt to embed stage 2 within GPT structures. * Letting `limine-install` attempt to embed stage 2 within GPT structures.
@ -154,21 +172,23 @@ limine-install <path to device/image> <1-based stage 2 partition number>
``` ```
In case one wants to let `limine-install` embed stage 2 within GPT's structures, In case one wants to let `limine-install` embed stage 2 within GPT's structures,
simply omit the partition number, and invoke `limine-install` the same as one would simply omit the partition number, and invoke `limine-install` the same as one
do for an MBR partitioned device. would do for an MBR partitioned device.
The boot device must to contain the `limine.sys` and `limine.cfg` files in The boot device must to contain the `limine.sys` and `limine.cfg` files in
either the root or the `boot` directory of one of the partitions, formatted either the root or the `boot` directory of one of the partitions, formatted
with a supported file system. with a supported file system.
### BIOS/UEFI hybrid ISO creation ### BIOS/UEFI hybrid ISO creation
In order to create a hybrid ISO with Limine, place the `limine-eltorito-efi.bin`, In order to create a hybrid ISO with Limine, place the
`limine-cd.bin`, `limine.sys`, and `limine.cfg` files into a directory which will `limine-eltorito-efi.bin`, `limine-cd.bin`, `limine.sys`, and `limine.cfg` files
serve as the root of the created ISO. into a directory which will serve as the root of the created ISO.
(`limine.sys` and `limine.cfg` must either be in the root or inside a `boot` (`limine.sys` and `limine.cfg` must either be in the root or inside a `boot`
subdirectory; `limine-eltorito-efi.bin` and `limine-cd.bin` can reside anywhere). subdirectory; `limine-eltorito-efi.bin` and `limine-cd.bin` can reside
anywhere).
Place any other file you want to be on the final ISO in said directory, then run: Place any other file you want to be on the final ISO in said directory, then
run:
``` ```
xorriso -as mkisofs -b <relative path of limine-cd.bin> \ xorriso -as mkisofs -b <relative path of limine-cd.bin> \
-no-emul-boot -boot-load-size 4 -boot-info-table \ -no-emul-boot -boot-load-size 4 -boot-info-table \
@ -191,14 +211,15 @@ it would be `boot/limine-cd.bin`.
`<relative path of limine-eltorito-efi.bin>` is the relative path of `<relative path of limine-eltorito-efi.bin>` is the relative path of
`limine-eltorito-efi.bin` inside the root directory. `limine-eltorito-efi.bin` inside the root directory.
For example, if it was copied in `<root directory>/boot/limine-eltorito-efi.bin`, For example, if it was copied in
it would be `boot/limine-eltorito-efi.bin`. `<root directory>/boot/limine-eltorito-efi.bin`, it would be
`boot/limine-eltorito-efi.bin`.
### BIOS/PXE boot ### BIOS/PXE boot
The `limine-pxe.bin` binary is a valid PXE boot image. The `limine-pxe.bin` binary is a valid PXE boot image.
In order to boot Limine from PXE it is necessary to setup a DHCP server with In order to boot Limine from PXE it is necessary to setup a DHCP server with
support for PXE booting. This can either be accomplished using a single DHCP server support for PXE booting. This can either be accomplished using a single DHCP
or your existing DHCP server and a proxy DHCP server such as dnsmasq. server or your existing DHCP server and a proxy DHCP server such as dnsmasq.
`limine.cfg` and `limine.sys` are expected to be on the server used for boot. `limine.cfg` and `limine.sys` are expected to be on the server used for boot.
@ -213,5 +234,5 @@ More info on the format of `limine.cfg` can be found in `CONFIG.md`.
Limine uses a stripped-down version of [tinf](https://github.com/jibsen/tinf). Limine uses a stripped-down version of [tinf](https://github.com/jibsen/tinf).
## Discord server ## Discord server
We have a [Discord server](https://discord.gg/QEeZMz4) if you need support, info, or We have a [Discord server](https://discord.gg/QEeZMz4) if you need support,
you just want to hang out with us. info, or you just want to hang out with us.

17
aux/make_toolchain.sh
View File

@ -1,10 +1,9 @@
#!/bin/sh #!/bin/sh
set -e set -ex
set -x
TARGET=x86_64-elf TARGET=x86_64-elf
BINUTILSVERSION=2.36.1 BINUTILSVERSION=2.37
GCCVERSION=11.1.0 GCCVERSION=11.1.0
CFLAGS="-O2 -pipe" CFLAGS="-O2 -pipe"
@ -33,8 +32,8 @@ tar -xf ../gcc-$GCCVERSION.tar.gz
mkdir build-binutils mkdir build-binutils
cd build-binutils cd build-binutils
../binutils-$BINUTILSVERSION/configure CFLAGS="$CFLAGS" CXXFLAGS="$CFLAGS" --target=$TARGET --prefix="$PREFIX" --with-sysroot --disable-nls --disable-werror --enable-targets=x86_64-elf,x86_64-pe ../binutils-$BINUTILSVERSION/configure CFLAGS="$CFLAGS" CXXFLAGS="$CFLAGS" --target=$TARGET --prefix="$PREFIX" --with-sysroot --disable-nls --disable-werror --enable-targets=x86_64-elf,x86_64-pe
make $MAKE
make install $MAKE install
cd .. cd ..
cd gcc-$GCCVERSION cd gcc-$GCCVERSION
@ -43,8 +42,8 @@ cd ..
mkdir build-gcc mkdir build-gcc
cd build-gcc cd build-gcc
../gcc-$GCCVERSION/configure CFLAGS="$CFLAGS" CXXFLAGS="$CFLAGS" --target=$TARGET --prefix="$PREFIX" --disable-nls --enable-languages=c --without-headers ../gcc-$GCCVERSION/configure CFLAGS="$CFLAGS" CXXFLAGS="$CFLAGS" --target=$TARGET --prefix="$PREFIX" --disable-nls --enable-languages=c --without-headers
make all-gcc $MAKE all-gcc
make all-target-libgcc $MAKE all-target-libgcc
make install-gcc $MAKE install-gcc
make install-target-libgcc $MAKE install-target-libgcc
cd .. cd ..

2
decompressor/Makefile
View File

@ -11,7 +11,7 @@ TOOLCHAIN_LD = $(TOOLCHAIN)-ld
TOOLCHAIN_OBJCOPY = $(TOOLCHAIN)-objcopy TOOLCHAIN_OBJCOPY = $(TOOLCHAIN)-objcopy
ifeq ($(shell command -v $(TOOLCHAIN_CC) ; ), ) ifeq ($(shell command -v $(TOOLCHAIN_CC) ; ), )
TOOLCHAIN_CC := gcc TOOLCHAIN_CC := cc
endif endif
ifeq ($(shell command -v $(TOOLCHAIN_LD) ; ), ) ifeq ($(shell command -v $(TOOLCHAIN_LD) ; ), )
TOOLCHAIN_LD := ld TOOLCHAIN_LD := ld

1
limine-install/Makefile
View File

@ -5,7 +5,6 @@ PREFIX = /usr/local
DESTDIR = DESTDIR =
LIMINE_HDD_BIN = limine-hdd.bin LIMINE_HDD_BIN = limine-hdd.bin
BUILD_DIR = $(shell realpath .)
CFLAGS = -O2 -pipe -Wall -Wextra CFLAGS = -O2 -pipe -Wall -Wextra

7
stage23/Makefile
View File

@ -25,7 +25,7 @@ TOOLCHAIN_OBJDUMP = $(TOOLCHAIN)-objdump
TOOLCHAIN_READELF = $(TOOLCHAIN)-readelf TOOLCHAIN_READELF = $(TOOLCHAIN)-readelf
ifeq ($(shell command -v $(TOOLCHAIN_CC) ; ), ) ifeq ($(shell command -v $(TOOLCHAIN_CC) ; ), )
TOOLCHAIN_CC := gcc TOOLCHAIN_CC := cc
endif endif
ifeq ($(shell command -v $(TOOLCHAIN_LD) ; ), ) ifeq ($(shell command -v $(TOOLCHAIN_LD) ; ), )
TOOLCHAIN_LD := ld TOOLCHAIN_LD := ld
@ -46,7 +46,7 @@ endif
COM_OUTPUT = false COM_OUTPUT = false
E9_OUTPUT = false E9_OUTPUT = false
BUILD_ID := $(shell dd if=/dev/urandom count=8 bs=1 2>/dev/null | od -An -t x8 | sed 's/^ /0x/') BUILD_ID := $(shell dd if=/dev/urandom count=8 bs=1 2>/dev/null | od -An -t x4 | sed 's/^ /0x/g;s/ //g')
LIMINE_VERSION := $(shell cat ../version 2>/dev/null || ( git describe --exact-match --tags `git log -n1 --pretty='%h'` 2>/dev/null || ( git log -n1 --pretty='%h' && echo -n "(`git branch --show-current`)" ) ) ) LIMINE_VERSION := $(shell cat ../version 2>/dev/null || ( git describe --exact-match --tags `git log -n1 --pretty='%h'` 2>/dev/null || ( git log -n1 --pretty='%h' && echo -n "(`git branch --show-current`)" ) ) )
WERROR = -Werror WERROR = -Werror
@ -231,7 +231,8 @@ $(BUILDDIR)/gnu-efi:
cp -r ../gnu-efi $(BUILDDIR)/ cp -r ../gnu-efi $(BUILDDIR)/
# gnu-efi's build system is broken and fails to actually detect clang. # gnu-efi's build system is broken and fails to actually detect clang.
# This is a workaround. # This is a workaround.
sed -i 's/-maccumulate-outgoing-args//g' $(BUILDDIR)/gnu-efi/Make.defaults sed 's/-maccumulate-outgoing-args//g' < "$(BUILDDIR)/gnu-efi/Make.defaults" > sed.tmp
mv sed.tmp "$(BUILDDIR)/gnu-efi/Make.defaults"
ifeq ($(TARGET), uefi) ifeq ($(TARGET), uefi)

11
stage23/gensyms.sh
View File

@ -1,13 +1,14 @@
#!/usr/bin/env bash #!/bin/sh
set -e -o pipefail set -e
set -o pipefail || true
TMP1=$(mktemp) TMP1=$(mktemp)
TMP2=$(mktemp) TMP2=$(mktemp)
TMP3=$(mktemp) TMP3=$(mktemp)
TMP4=$(mktemp) TMP4=$(mktemp)
$1 -t "$2" | sed '/\bd\b/d' | sort > "$TMP1" $1 -t "$2" | sed '/[[:<:]]d[[:>:]]/d' | sort > "$TMP1"
grep "\.text" < "$TMP1" | cut -d' ' -f1 > "$TMP2" grep "\.text" < "$TMP1" | cut -d' ' -f1 > "$TMP2"
grep "\.text" < "$TMP1" | awk 'NF{ print $NF }' > "$TMP3" grep "\.text" < "$TMP1" | awk 'NF{ print $NF }' > "$TMP3"
@ -16,11 +17,11 @@ echo "global $3_map" >> "$TMP4"
echo "$3_map:" >> "$TMP4" echo "$3_map:" >> "$TMP4"
if [ "$4" = "32" ]; then if [ "$4" = "32" ]; then
paste -d'$' "$TMP2" "$TMP3" | sed 's/^/dd 0x/g' | sed 's/$/", 0/g' | sed 's/\$/\ndb "/g' >> "$TMP4" paste -d'$' "$TMP2" "$TMP3" | sed 's/^/dd 0x/g;s/$/", 0/g;s/\$/\ndb "/g' >> "$TMP4"
echo "dd 0xffffffff" >> "$TMP4" echo "dd 0xffffffff" >> "$TMP4"
nasm -f elf32 "$TMP4" -o $3.map.o nasm -f elf32 "$TMP4" -o $3.map.o
elif [ "$4" = "64" ]; then elif [ "$4" = "64" ]; then
paste -d'$' "$TMP2" "$TMP3" | sed 's/^/dq 0x/g' | sed 's/$/", 0/g' | sed 's/\$/\ndb "/g' >> "$TMP4" paste -d'$' "$TMP2" "$TMP3" | sed 's/^/dq 0x/g;s/$/", 0/g;s/\$/\ndb "/g' >> "$TMP4"
echo "dq 0xffffffffffffffff" >> "$TMP4" echo "dq 0xffffffffffffffff" >> "$TMP4"
nasm -f elf64 "$TMP4" -o $3.map.o nasm -f elf64 "$TMP4" -o $3.map.o
fi fi