github-repos/tinycc
1
0
Fork 0
mirror of https://github.com/mirror/tinycc.git synced 2024-12-28 04:00:06 +08:00
Code Issues Packages Projects Releases Wiki Activity
414c22c67b
tinycc/tccmacho.c

1058 lines
38 KiB
C
Raw Normal View History

macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
/*
macos: Tidy code
2020-05-26 00:47:05 +08:00
* Mach-O file handling for TCC
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "tcc.h"
macos: add overview comment
2020-06-21 04:25:08 +08:00
/* In order to make life easy for us we are generating Mach-O files which
don't make use of some modern features, but which aren't entirely classic
either in that they do use some modern features. We're also only
generating 64bit Mach-O files, and only native endian at that.
In particular we're generating executables that don't make use of
DYLD_INFO for dynamic linking info, as that requires us building a
trie of exported names. We're simply using classic symbol tables which
are still supported by modern dyld.
But we do use LC_MAIN, which is a "modern" feature in order to not have
to setup our own crt code. We're not using lazy linking, so even function
calls are resolved at startup. */
macos: Disable verbose linking output
2020-05-22 12:27:37 +08:00
#define DEBUG_MACHO 0
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
#define dprintf if (DEBUG_MACHO) printf
macos: Disable verbose linking output
2020-05-22 12:27:37 +08:00
macos: Tidy code
2020-05-26 00:47:05 +08:00
struct fat_header {
uint32_t magic; /* FAT_MAGIC or FAT_MAGIC_64 */
uint32_t nfat_arch; /* number of structs that follow */
};
struct fat_arch {
int cputype; /* cpu specifier (int) */
int cpusubtype; /* machine specifier (int) */
uint32_t offset; /* file offset to this object file */
uint32_t size; /* size of this object file */
uint32_t align; /* alignment as a power of 2 */
};
#define FAT_MAGIC 0xcafebabe
#define FAT_CIGAM 0xbebafeca
#define FAT_MAGIC_64 0xcafebabf
#define FAT_CIGAM_64 0xbfbafeca
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
struct mach_header {
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t magic; /* mach magic number identifier */
int cputype; /* cpu specifier */
int cpusubtype; /* machine specifier */
uint32_t filetype; /* type of file */
uint32_t ncmds; /* number of load commands */
uint32_t sizeofcmds; /* the size of all the load commands */
uint32_t flags; /* flags */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
struct mach_header_64 {
struct mach_header mh;
uint32_t reserved; /* reserved, pad to 64bit */
};
/* Constant for the magic field of the mach_header (32-bit architectures) */
#define MH_MAGIC 0xfeedface /* the mach magic number */
#define MH_CIGAM 0xcefaedfe /* NXSwapInt(MH_MAGIC) */
#define MH_MAGIC_64 0xfeedfacf /* the 64-bit mach magic number */
#define MH_CIGAM_64 0xcffaedfe /* NXSwapInt(MH_MAGIC_64) */
struct load_command {
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t cmd; /* type of load command */
uint32_t cmdsize; /* total size of command in bytes */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
macos: Tidy code
2020-05-26 00:47:05 +08:00
#define LC_REQ_DYLD 0x80000000
#define LC_SYMTAB 0x2
#define LC_DYSYMTAB 0xb
#define LC_LOAD_DYLIB 0xc
#define LC_ID_DYLIB 0xd
#define LC_LOAD_DYLINKER 0xe
#define LC_SEGMENT_64 0x19
#define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD)
#define LC_MAIN (0x28|LC_REQ_DYLD)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
macos: Tidy code
2020-05-26 00:47:05 +08:00
typedef int vm_prot_t;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
struct segment_command_64 { /* for 64-bit architectures */
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t cmd; /* LC_SEGMENT_64 */
uint32_t cmdsize; /* includes sizeof section_64 structs */
char segname[16]; /* segment name */
uint64_t vmaddr; /* memory address of this segment */
uint64_t vmsize; /* memory size of this segment */
uint64_t fileoff; /* file offset of this segment */
uint64_t filesize; /* amount to map from the file */
vm_prot_t maxprot; /* maximum VM protection */
vm_prot_t initprot; /* initial VM protection */
uint32_t nsects; /* number of sections in segment */
uint32_t flags; /* flags */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
struct section_64 { /* for 64-bit architectures */
macos: Tidy code
2020-05-26 00:47:05 +08:00
char sectname[16]; /* name of this section */
char segname[16]; /* segment this section goes in */
uint64_t addr; /* memory address of this section */
uint64_t size; /* size in bytes of this section */
uint32_t offset; /* file offset of this section */
uint32_t align; /* section alignment (power of 2) */
uint32_t reloff; /* file offset of relocation entries */
uint32_t nreloc; /* number of relocation entries */
uint32_t flags; /* flags (section type and attributes)*/
uint32_t reserved1; /* reserved (for offset or index) */
uint32_t reserved2; /* reserved (for count or sizeof) */
uint32_t reserved3; /* reserved */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
macos: Tidy code
2020-05-26 00:47:05 +08:00
#define S_REGULAR 0x0
#define S_ZEROFILL 0x1
#define S_NON_LAZY_SYMBOL_POINTERS 0x6
#define S_MOD_INIT_FUNC_POINTERS 0x9
#define S_MOD_TERM_FUNC_POINTERS 0xa
#define S_ATTR_PURE_INSTRUCTIONS 0x80000000
#define S_ATTR_SOME_INSTRUCTIONS 0x00000400
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
typedef uint32_t lc_str;
struct dylib_command {
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t cmd; /* LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB,
LC_REEXPORT_DYLIB */
uint32_t cmdsize; /* includes pathname string */
lc_str name; /* library's path name */
uint32_t timestamp; /* library's build time stamp */
uint32_t current_version; /* library's current version number */
uint32_t compatibility_version; /* library's compatibility vers number*/
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
struct dylinker_command {
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t cmd; /* LC_ID_DYLINKER, LC_LOAD_DYLINKER or
LC_DYLD_ENVIRONMENT */
uint32_t cmdsize; /* includes pathname string */
lc_str name; /* dynamic linker's path name */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
struct symtab_command {
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t cmd; /* LC_SYMTAB */
uint32_t cmdsize; /* sizeof(struct symtab_command) */
uint32_t symoff; /* symbol table offset */
uint32_t nsyms; /* number of symbol table entries */
uint32_t stroff; /* string table offset */
uint32_t strsize; /* string table size in bytes */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
struct dysymtab_command {
uint32_t cmd; /* LC_DYSYMTAB */
uint32_t cmdsize; /* sizeof(struct dysymtab_command) */
uint32_t ilocalsym; /* index to local symbols */
uint32_t nlocalsym; /* number of local symbols */
uint32_t iextdefsym;/* index to externally defined symbols */
uint32_t nextdefsym;/* number of externally defined symbols */
uint32_t iundefsym; /* index to undefined symbols */
uint32_t nundefsym; /* number of undefined symbols */
uint32_t tocoff; /* file offset to table of contents */
uint32_t ntoc; /* number of entries in table of contents */
uint32_t modtaboff; /* file offset to module table */
uint32_t nmodtab; /* number of module table entries */
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t extrefsymoff; /* offset to referenced symbol table */
uint32_t nextrefsyms; /* number of referenced symbol table entries */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
macos: Tidy code
2020-05-26 00:47:05 +08:00
uint32_t indirectsymoff;/* file offset to the indirect symbol table */
uint32_t nindirectsyms; /* number of indirect symbol table entries */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
uint32_t extreloff; /* offset to external relocation entries */
uint32_t nextrel; /* number of external relocation entries */
uint32_t locreloff; /* offset to local relocation entries */
uint32_t nlocrel; /* number of local relocation entries */
};
macos: Tidy code
2020-05-26 00:47:05 +08:00
#define INDIRECT_SYMBOL_LOCAL 0x80000000
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
struct entry_point_command {
uint32_t cmd; /* LC_MAIN only used in MH_EXECUTE filetypes */
uint32_t cmdsize; /* 24 */
uint64_t entryoff; /* file (__TEXT) offset of main() */
uint64_t stacksize;/* if not zero, initial stack size */
};
enum skind {
sk_unknown = 0,
sk_discard,
sk_text,
sk_stubs,
sk_ro_data,
sk_uw_info,
sk_nl_ptr, // non-lazy pointers, aka GOT
sk_la_ptr, // lazy pointers
macos: Support .init_array and .fini_array called different on Mach-O, but same functionality (list of pointers to init and fini functions).
2020-05-18 11:44:05 +08:00
sk_init,
sk_fini,
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
sk_rw_data,
sk_bss,
sk_linkedit,
sk_last
};
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
struct nlist_64 {
uint32_t n_strx; /* index into the string table */
uint8_t n_type; /* type flag, see below */
uint8_t n_sect; /* section number or NO_SECT */
uint16_t n_desc; /* see <mach-o/stab.h> */
uint64_t n_value; /* value of this symbol (or stab offset) */
};
macos: Tidy code
2020-05-26 00:47:05 +08:00
#define N_UNDF 0x0
#define N_ABS 0x2
#define N_EXT 0x1
#define N_SECT 0xe
macos: Fix memtest * free allocated memory * fix weak symbols related to -run * remove memtest from ignored tests for OSX
2020-05-26 04:18:37 +08:00
#define N_WEAK_REF 0x0040
#define N_WEAK_DEF 0x0080
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
struct macho {
struct mach_header_64 mh;
macos: Tidy code
2020-05-26 00:47:05 +08:00
int seg2lc[4], nseg;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
struct load_command **lc;
macos: Tidy code
2020-05-26 00:47:05 +08:00
struct entry_point_command *ep;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
int nlc;
struct {
Section *s;
int machosect;
} sk_to_sect[sk_last];
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
int *elfsectomacho;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
int *e2msym;
macos: Tidy code
2020-05-26 00:47:05 +08:00
Section *symtab, *strtab, *wdata, *indirsyms, *stubs;
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
int stubsym;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
uint32_t ilocal, iextdef, iundef;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
#define SHT_LINKEDIT (SHT_LOOS + 42)
macos: handle undefined symbols a bit at least data symbols coming from dylibs can be used now, as in the below. Note in the example that optind is defined in libc (really in libsystem_c.dylib, reexported from libSystem.B.dylib): static int loc; extern int _optind; int _start(void) { _optind = 0; loc = 42 + _optind; return loc - 42; }
2020-05-17 11:36:00 +08:00
#define SHN_FROMDLL (SHN_LOOS + 2) /* Symbol is undefined, comes from a DLL */
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void * add_lc(struct macho *mo, uint32_t cmd, uint32_t cmdsize)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
struct load_command *lc = tcc_mallocz(cmdsize);
macos: Tidy code
2020-05-26 00:47:05 +08:00
lc->cmd = cmd;
lc->cmdsize = cmdsize;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
mo->lc = tcc_realloc(mo->lc, sizeof(mo->lc[0]) * (mo->nlc + 1));
macos: Tidy code
2020-05-26 00:47:05 +08:00
mo->lc[mo->nlc++] = lc;
return lc;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static struct segment_command_64 * add_segment(struct macho *mo, const char *name)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
struct segment_command_64 *sc = add_lc(mo, LC_SEGMENT_64, sizeof(*sc));
bored... /* Use "-g" as alias for "-g1". Use "-g0" to disable debug */ So not using -g is now the alias for -g0 ?!? This reverts commit 8759b2581d196081e3b152b2ea71ccf1a76412eb. This reverts commit 3ce7bc6efc8079dfa182840a177dbff8199ae1d5. This reverts commit 5fb582ab7f44f8ead28a95e002042e6cb1e72b00. This reverts commit aea68dbb40b544ecf17d90665aaf13ee1e2f905d. This reverts commit fa9c31c3db1898d804db2289a11d9f368da88dd1. This reverts commit b3bebdb20a8910597955f849791f578d42ef178e. This reverts commit ecf8e5a00e5909ae664e1fafb641ddf711210904. This reverts commit fe6b5c08dc68b1bfab6b6ef6b9e29a5af7317262. This reverts commit e2e5377e7b68d57def00acda17ffcfca6dce8b84. This reverts commit 1cd79989057ff937a2bc2b8bdc7afd4f02a91407.
2022-05-08 05:16:13 +08:00
strncpy(sc->segname, name, 16);
macos: Tidy code
2020-05-26 00:47:05 +08:00
mo->seg2lc[mo->nseg++] = mo->nlc - 1;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
return sc;
}
macos: Tidy code
2020-05-26 00:47:05 +08:00
static struct segment_command_64 * get_segment(struct macho *mo, int i)
{
return (struct segment_command_64 *) (mo->lc[mo->seg2lc[i]]);
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static int add_section(struct macho *mo, struct segment_command_64 **_seg, const char *name)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
struct segment_command_64 *seg = *_seg;
int ret = seg->nsects;
struct section_64 *sec;
seg->nsects++;
seg->cmdsize += sizeof(*sec);
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
seg = tcc_realloc(seg, sizeof(*seg) + seg->nsects * sizeof(*sec));
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
sec = (struct section_64*)((char*)seg + sizeof(*seg)) + ret;
memset(sec, 0, sizeof(*sec));
bored... /* Use "-g" as alias for "-g1". Use "-g0" to disable debug */ So not using -g is now the alias for -g0 ?!? This reverts commit 8759b2581d196081e3b152b2ea71ccf1a76412eb. This reverts commit 3ce7bc6efc8079dfa182840a177dbff8199ae1d5. This reverts commit 5fb582ab7f44f8ead28a95e002042e6cb1e72b00. This reverts commit aea68dbb40b544ecf17d90665aaf13ee1e2f905d. This reverts commit fa9c31c3db1898d804db2289a11d9f368da88dd1. This reverts commit b3bebdb20a8910597955f849791f578d42ef178e. This reverts commit ecf8e5a00e5909ae664e1fafb641ddf711210904. This reverts commit fe6b5c08dc68b1bfab6b6ef6b9e29a5af7317262. This reverts commit e2e5377e7b68d57def00acda17ffcfca6dce8b84. This reverts commit 1cd79989057ff937a2bc2b8bdc7afd4f02a91407.
2022-05-08 05:16:13 +08:00
strncpy(sec->sectname, name, 16);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
strncpy(sec->segname, seg->segname, 16);
*_seg = seg;
return ret;
}
static struct section_64 *get_section(struct segment_command_64 *seg, int i)
{
macos: Tidy code
2020-05-26 00:47:05 +08:00
return (struct section_64*)((char*)seg + sizeof(*seg)) + i;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void * add_dylib(struct macho *mo, char *name)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
struct dylib_command *lc;
int sz = (sizeof(*lc) + strlen(name) + 1 + 7) & -8;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
lc = add_lc(mo, LC_LOAD_DYLIB, sz);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
lc->name = sizeof(*lc);
strcpy((char*)lc + lc->name, name);
lc->timestamp = 2;
lc->current_version = 1 << 16;
lc->compatibility_version = 1 << 16;
macos: Tidy code
2020-05-26 00:47:05 +08:00
return lc;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void check_relocs(TCCState *s1, struct macho *mo)
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
{
Section *s;
ElfW_Rel *rel;
ElfW(Sym) *sym;
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
int i, type, gotplt_entry, sym_index, for_code;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
struct sym_attr *attr;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
s1->got = new_section(s1, ".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
mo->indirsyms = new_section(s1, "LEINDIR", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
for (i = 1; i < s1->nb_sections; i++) {
s = s1->sections[i];
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
if (s->sh_type != SHT_RELX)
continue;
for_each_elem(s, 0, rel, ElfW_Rel) {
type = ELFW(R_TYPE)(rel->r_info);
gotplt_entry = gotplt_entry_type(type);
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
for_code = code_reloc(type);
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
/* We generate a non-lazy pointer for used undefined symbols
and for defined symbols that must have a place for their
address due to codegen (i.e. a reloc requiring a got slot). */
sym_index = ELFW(R_SYM)(rel->r_info);
sym = &((ElfW(Sym) *)symtab_section->data)[sym_index];
if (sym->st_shndx == SHN_UNDEF
|| gotplt_entry == ALWAYS_GOTPLT_ENTRY) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
attr = get_sym_attr(s1, sym_index, 1);
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
if (!attr->dyn_index) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
uint32_t *pi = section_ptr_add(mo->indirsyms, sizeof(*pi));
attr->got_offset = s1->got->data_offset;
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
attr->plt_offset = -1;
attr->dyn_index = 1; /* used as flag */
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
section_ptr_add(s1->got, PTR_SIZE);
macos: Fix GOT access to local defined symbols if a GOT slot is required (due to codegen, indicated by presence of some relocation types), then it needs to contain the address of the wanted symbol, also when it's local and defined, i.e. not overridable. For simplicity we use a GOT slot for that as well (other storage would require rewriting relocs and symbols, as resolving of GOT relocs is hardwired to be based on s1->got). But that means we need to fill in its indirect symbol mapping slot as well, for which Mach-O provides a mean to say "not symbol based, resolved locally". So this fixes this testcase: static int loc; int _start(void) { loc = 42; return loc - 42; } (where our codegen currently uses a GOT-based access for the write by accident)
2020-05-17 10:39:40 +08:00
if (ELFW(ST_BIND)(sym->st_info) == STB_LOCAL) {
if (sym->st_shndx == SHN_UNDEF)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error("undefined local symbol???");
macos: Tidy code
2020-05-26 00:47:05 +08:00
*pi = INDIRECT_SYMBOL_LOCAL;
macos: Fix GOT access to local defined symbols if a GOT slot is required (due to codegen, indicated by presence of some relocation types), then it needs to contain the address of the wanted symbol, also when it's local and defined, i.e. not overridable. For simplicity we use a GOT slot for that as well (other storage would require rewriting relocs and symbols, as resolving of GOT relocs is hardwired to be based on s1->got). But that means we need to fill in its indirect symbol mapping slot as well, for which Mach-O provides a mean to say "not symbol based, resolved locally". So this fixes this testcase: static int loc; int _start(void) { loc = 42; return loc - 42; } (where our codegen currently uses a GOT-based access for the write by accident)
2020-05-17 10:39:40 +08:00
/* The pointer slot we generated must point to the
symbol, whose address is only known after layout,
macos: Tidy code
2020-05-26 00:47:05 +08:00
so register a simple relocation for that. */
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
put_elf_reloc(s1->symtab, s1->got, attr->got_offset,
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
R_DATA_PTR, sym_index);
macos: Fix GOT access to local defined symbols if a GOT slot is required (due to codegen, indicated by presence of some relocation types), then it needs to contain the address of the wanted symbol, also when it's local and defined, i.e. not overridable. For simplicity we use a GOT slot for that as well (other storage would require rewriting relocs and symbols, as resolving of GOT relocs is hardwired to be based on s1->got). But that means we need to fill in its indirect symbol mapping slot as well, for which Mach-O provides a mean to say "not symbol based, resolved locally". So this fixes this testcase: static int loc; int _start(void) { loc = 42; return loc - 42; } (where our codegen currently uses a GOT-based access for the write by accident)
2020-05-17 10:39:40 +08:00
} else
*pi = mo->e2msym[sym_index];
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
}
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
if (for_code) {
if (attr->plt_offset == -1) {
uint8_t *jmp;
attr->plt_offset = mo->stubs->data_offset;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
jmp = section_ptr_add(mo->stubs, 6);
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
jmp[0] = 0xff; /* jmpq *ofs(%rip) */
jmp[1] = 0x25;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
put_elf_reloc(s1->symtab, mo->stubs,
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
attr->plt_offset + 2,
R_X86_64_GOTPCREL, sym_index);
}
rel->r_info = ELFW(R_INFO)(mo->stubsym, type);
rel->r_addend += attr->plt_offset;
}
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
}
}
}
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static int check_symbols(TCCState *s1, struct macho *mo)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
int sym_index, sym_end;
int ret = 0;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
mo->ilocal = mo->iextdef = mo->iundef = -1;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
sym_end = symtab_section->data_offset / sizeof(ElfW(Sym));
for (sym_index = 1; sym_index < sym_end; ++sym_index) {
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
int elf_index = ((struct nlist_64 *)mo->symtab->data + sym_index - 1)->n_value;
ElfW(Sym) *sym = (ElfW(Sym) *)symtab_section->data + elf_index;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
const char *name = (char*)symtab_section->link->data + sym->st_name;
unsigned type = ELFW(ST_TYPE)(sym->st_info);
unsigned bind = ELFW(ST_BIND)(sym->st_info);
unsigned vis = ELFW(ST_VISIBILITY)(sym->st_other);
win64: fix pe_isafunc() - tccpe.c: commit "tidy support for helper function" created STT_NOTYPE symbols and hence relied on ad-hoc detection which didn't work for x86_64 (as reported by Christian Jullien) - tccgen.c: However to be more safe the helper symbols are now made STT_FUNC anyway (via new VT_ASM_FUNC). Also: - tcc.h: minor reorder - riscv64-*, arm64-*, tccmacho.c: avoid some gcc format-warnings (mingw-gcc complains about "%llx" being "unknown conversion", although it does work since Vista or so)
2020-11-25 18:23:01 +08:00
dprintf("%4d (%4d): %09lx %4d %4d %4d %3d %s\n",
sym_index, elf_index, (long)sym->st_value,
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
type, bind, vis, sym->st_shndx, name);
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
if (bind == STB_LOCAL) {
if (mo->ilocal == -1)
mo->ilocal = sym_index - 1;
if (mo->iextdef != -1 || mo->iundef != -1)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error("local syms after global ones");
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
} else if (sym->st_shndx != SHN_UNDEF) {
if (mo->iextdef == -1)
mo->iextdef = sym_index - 1;
if (mo->iundef != -1)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error("external defined symbol after undefined");
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
} else if (sym->st_shndx == SHN_UNDEF) {
if (mo->iundef == -1)
mo->iundef = sym_index - 1;
macos: Fix memtest * free allocated memory * fix weak symbols related to -run * remove memtest from ignored tests for OSX
2020-05-26 04:18:37 +08:00
if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
|| find_elf_sym(s1->dynsymtab_section, name)) {
macos: handle undefined symbols a bit at least data symbols coming from dylibs can be used now, as in the below. Note in the example that optind is defined in libc (really in libsystem_c.dylib, reexported from libSystem.B.dylib): static int loc; extern int _optind; int _start(void) { _optind = 0; loc = 42 + _optind; return loc - 42; }
2020-05-17 11:36:00 +08:00
/* Mark the symbol as coming from a dylib so that
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
relocate_syms doesn't complain. Normally bind_exe_dynsyms
would do this check, and place the symbol into dynsym
which is checked by relocate_syms. But Mach-O doesn't use
bind_exe_dynsyms. */
macos: handle undefined symbols a bit at least data symbols coming from dylibs can be used now, as in the below. Note in the example that optind is defined in libc (really in libsystem_c.dylib, reexported from libSystem.B.dylib): static int loc; extern int _optind; int _start(void) { _optind = 0; loc = 42 + _optind; return loc - 42; }
2020-05-17 11:36:00 +08:00
sym->st_shndx = SHN_FROMDLL;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
continue;
macos: handle undefined symbols a bit at least data symbols coming from dylibs can be used now, as in the below. Note in the example that optind is defined in libc (really in libsystem_c.dylib, reexported from libSystem.B.dylib): static int loc; extern int _optind; int _start(void) { _optind = 0; loc = 42 + _optind; return loc - 42; }
2020-05-17 11:36:00 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error_noabort("undefined symbol '%s'", name);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
ret = -1;
}
}
return ret;
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void convert_symbol(TCCState *s1, struct macho *mo, struct nlist_64 *pn)
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
{
struct nlist_64 n = *pn;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
ElfSym *sym = (ElfW(Sym) *)symtab_section->data + pn->n_value;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
const char *name = (char*)symtab_section->link->data + sym->st_name;
switch(ELFW(ST_TYPE)(sym->st_info)) {
case STT_NOTYPE:
case STT_OBJECT:
case STT_FUNC:
macos: section syms, strtab, runtime uncovered by the backtrace/boundcheck tests: * handle STT_SECTION symbols * call tcc_add_runtime (to get the bcheck.o/bt-exe.o files added) * add .stab strtab into segments (we should probably add all stab syms to the output LC_SYMTAB eventually, but right now TCC uses 32 bit stabs, while mach-o uses 32/64bit stabs
2020-05-22 10:37:35 +08:00
case STT_SECTION:
macos: Tidy code
2020-05-26 00:47:05 +08:00
n.n_type = N_SECT;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
break;
case STT_FILE:
macos: Tidy code
2020-05-26 00:47:05 +08:00
n.n_type = N_ABS;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
break;
default:
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error("unhandled ELF symbol type %d %s",
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
ELFW(ST_TYPE)(sym->st_info), name);
}
if (sym->st_shndx == SHN_UNDEF)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error("should have been rewritten to SHN_FROMDLL: %s", name);
macos: handle undefined symbols a bit at least data symbols coming from dylibs can be used now, as in the below. Note in the example that optind is defined in libc (really in libsystem_c.dylib, reexported from libSystem.B.dylib): static int loc; extern int _optind; int _start(void) { _optind = 0; loc = 42 + _optind; return loc - 42; }
2020-05-17 11:36:00 +08:00
else if (sym->st_shndx == SHN_FROMDLL)
macos: Tidy code
2020-05-26 00:47:05 +08:00
n.n_type = N_UNDF, n.n_sect = 0;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
else if (sym->st_shndx == SHN_ABS)
macos: Tidy code
2020-05-26 00:47:05 +08:00
n.n_type = N_ABS, n.n_sect = 0;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
else if (sym->st_shndx >= SHN_LORESERVE)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error("unhandled ELF symbol section %d %s", sym->st_shndx, name);
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
else if (!mo->elfsectomacho[sym->st_shndx])
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error("ELF section %d not mapped into Mach-O for symbol %s",
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
sym->st_shndx, name);
else
n.n_sect = mo->elfsectomacho[sym->st_shndx];
if (ELFW(ST_BIND)(sym->st_info) == STB_GLOBAL)
macos: Tidy code
2020-05-26 00:47:05 +08:00
n.n_type |= N_EXT;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
else if (ELFW(ST_BIND)(sym->st_info) == STB_WEAK)
macos: Fix memtest * free allocated memory * fix weak symbols related to -run * remove memtest from ignored tests for OSX
2020-05-26 04:18:37 +08:00
n.n_desc |= N_WEAK_REF | (n.n_type != N_UNDF ? N_WEAK_DEF : 0);
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
n.n_strx = pn->n_strx;
n.n_value = sym->st_value;
*pn = n;
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void convert_symbols(TCCState *s1, struct macho *mo)
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
{
macos: Tidy code
2020-05-26 00:47:05 +08:00
struct nlist_64 *pn;
for_each_elem(mo->symtab, 0, pn, struct nlist_64)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
convert_symbol(s1, mo, pn);
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static int machosymcmp(const void *_a, const void *_b)
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
{
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
TCCState *s1 = tcc_state;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
int ea = ((struct nlist_64 *)_a)->n_value;
int eb = ((struct nlist_64 *)_b)->n_value;
ElfSym *sa = (ElfSym *)symtab_section->data + ea;
ElfSym *sb = (ElfSym *)symtab_section->data + eb;
int r;
macos: Tidy code
2020-05-26 00:47:05 +08:00
/* locals, then defined externals, then undefined externals, the
last two sections also by name, otherwise stable sort */
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
r = (ELFW(ST_BIND)(sb->st_info) == STB_LOCAL)
- (ELFW(ST_BIND)(sa->st_info) == STB_LOCAL);
if (r)
return r;
macos: handle undefined symbols a bit at least data symbols coming from dylibs can be used now, as in the below. Note in the example that optind is defined in libc (really in libsystem_c.dylib, reexported from libSystem.B.dylib): static int loc; extern int _optind; int _start(void) { _optind = 0; loc = 42 + _optind; return loc - 42; }
2020-05-17 11:36:00 +08:00
r = (sa->st_shndx == SHN_UNDEF) - (sb->st_shndx == SHN_UNDEF);
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
if (r)
return r;
if (ELFW(ST_BIND)(sa->st_info) != STB_LOCAL) {
const char * na = (char*)symtab_section->link->data + sa->st_name;
const char * nb = (char*)symtab_section->link->data + sb->st_name;
r = strcmp(na, nb);
if (r)
return r;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
}
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
return ea - eb;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void create_symtab(TCCState *s1, struct macho *mo)
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
{
int sym_index, sym_end;
struct nlist_64 *pn;
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
/* Stub creation belongs to check_relocs, but we need to create
the symbol now, so its included in the sorting. */
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
mo->stubs = new_section(s1, "__stubs", SHT_PROGBITS, SHF_ALLOC | SHF_EXECINSTR);
mo->stubsym = put_elf_sym(s1->symtab, 0, 0,
macos: Tidy code
2020-05-26 00:47:05 +08:00
ELFW(ST_INFO)(STB_LOCAL, STT_SECTION), 0,
macos: Support external functions these are resolved non-lazy for now. We only need to generate the jump stub (using the GOT slot that will be initialized due to the non-lazy pointer marking, like with data symbols). On x86-64 we don't even need special marking of these stubs (with S_SYMBOL_STUBS and associated additional indirect symbol entries), as that's only used on i386 (where the stubs are self-modifying). So, this now works: extern int _printf(const char*, ...); int _start(void) { _printf("hello\n"); return 0; }
2020-05-18 10:35:38 +08:00
mo->stubs->sh_num, ".__stubs");
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
mo->symtab = new_section(s1, "LESYMTAB", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
mo->strtab = new_section(s1, "LESTRTAB", SHT_LINKEDIT, SHF_ALLOC | SHF_WRITE);
put_elf_str(mo->strtab, " "); /* Mach-O starts strtab with a space */
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
sym_end = symtab_section->data_offset / sizeof(ElfW(Sym));
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
pn = section_ptr_add(mo->symtab, sizeof(*pn) * (sym_end - 1));
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
for (sym_index = 1; sym_index < sym_end; ++sym_index) {
ElfW(Sym) *sym = (ElfW(Sym) *)symtab_section->data + sym_index;
const char *name = (char*)symtab_section->link->data + sym->st_name;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
pn[sym_index - 1].n_strx = put_elf_str(mo->strtab, name);
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
pn[sym_index - 1].n_value = sym_index;
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_enter_state(s1); /* qsort needs global state */
qsort(pn, sym_end - 1, sizeof(*pn), machosymcmp);
tcc_exit_state(s1);
mo->e2msym = tcc_malloc(sym_end * sizeof(*mo->e2msym));
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
mo->e2msym[0] = -1;
for (sym_index = 1; sym_index < sym_end; ++sym_index) {
mo->e2msym[pn[sym_index - 1].n_value] = sym_index - 1;
}
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
}
tccelf: use rodata_section, use more rodata in tcc itself libtcc.c: add -Wwrite-strings to -Wall tccgen.c: ro float-consts, string-consts, ro arrays if base type is tccpe.c: merge IAT with rodata tccrun.c: mprotect rodata accordingly. free section data after copy x86_64.c: do not use got for static data. tcc -bench: show data.rw/ro Probably STB_LOCAL should never get to put_got_entry(), and currently it doesn't seem to happen (See "Hack Alarm" there) Other files: use more ro-data in tinycc
2021-02-01 22:10:58 +08:00
const struct {
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
int seg;
uint32_t flags;
tccelf: use rodata_section, use more rodata in tcc itself libtcc.c: add -Wwrite-strings to -Wall tccgen.c: ro float-consts, string-consts, ro arrays if base type is tccpe.c: merge IAT with rodata tccrun.c: mprotect rodata accordingly. free section data after copy x86_64.c: do not use got for static data. tcc -bench: show data.rw/ro Probably STB_LOCAL should never get to put_got_entry(), and currently it doesn't seem to happen (See "Hack Alarm" there) Other files: use more ro-data in tinycc
2021-02-01 22:10:58 +08:00
const char *name;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
} skinfo[sk_last] = {
some cleanups related to recent commits - configure/Makefile : cleanup, really use CC_NAME - tccasm.c : remove C99 construct that MSVC doesn't compile - arm-gen.c, x86_64-gen.c, riscv64-gen.c, tccmacho.c : ditto - arm64-gen.c: commit 383acf8eff2818f8f0c5 wrote: "Instead of a cast, it would be better to pass the exact type." It is true that there are better solutions but it is not passing the exact type (I think). - tcctest.c: revert "fix cast test for clang" 03646ad46ff5d9a6d946 this obviously wants to test non-portable conversions - 114_bound_signal.test: clock_nanosleep is too new for older linuxes, just use sleep() instead
2020-06-27 23:22:04 +08:00
/*[sk_unknown] =*/ { 0 },
/*[sk_discard] =*/ { 0 },
/*[sk_text] =*/ { 1, S_REGULAR | S_ATTR_PURE_INSTRUCTIONS
macos: Tidy code
2020-05-26 00:47:05 +08:00
| S_ATTR_SOME_INSTRUCTIONS, "__text" },
some cleanups related to recent commits - configure/Makefile : cleanup, really use CC_NAME - tccasm.c : remove C99 construct that MSVC doesn't compile - arm-gen.c, x86_64-gen.c, riscv64-gen.c, tccmacho.c : ditto - arm64-gen.c: commit 383acf8eff2818f8f0c5 wrote: "Instead of a cast, it would be better to pass the exact type." It is true that there are better solutions but it is not passing the exact type (I think). - tcctest.c: revert "fix cast test for clang" 03646ad46ff5d9a6d946 this obviously wants to test non-portable conversions - 114_bound_signal.test: clock_nanosleep is too new for older linuxes, just use sleep() instead
2020-06-27 23:22:04 +08:00
/*[sk_stubs] =*/ { 0 },
/*[sk_ro_data] =*/ { 1, S_REGULAR, "__rodata" },
/*[sk_uw_info] =*/ { 0 },
/*[sk_nl_ptr] =*/ { 2, S_NON_LAZY_SYMBOL_POINTERS, "__got" },
/*[sk_la_ptr] =*/ { 0 },
/*[sk_init] =*/ { 2, S_MOD_INIT_FUNC_POINTERS, "__mod_init_func" },
/*[sk_fini] =*/ { 2, S_MOD_TERM_FUNC_POINTERS, "__mod_term_func" },
/*[sk_rw_data] =*/ { 2, S_REGULAR, "__data" },
/*[sk_bss] =*/ { 2, S_ZEROFILL, "__bss" },
/*[sk_linkedit] =*/ { 3, S_REGULAR, NULL },
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
};
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void collect_sections(TCCState *s1, struct macho *mo)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
int i, sk, numsec;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
uint64_t curaddr, fileofs;
Section *s;
struct segment_command_64 *seg = NULL;
struct dylinker_command *dyldlc;
struct symtab_command *symlc;
struct dysymtab_command *dysymlc;
char *str;
macos: Tidy code
2020-05-26 00:47:05 +08:00
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
seg = add_segment(mo, "__PAGEZERO");
macos: Tidy code
2020-05-26 00:47:05 +08:00
seg->vmsize = (uint64_t)1 << 32;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
seg = add_segment(mo, "__TEXT");
macos: Tidy code
2020-05-26 00:47:05 +08:00
seg->vmaddr = (uint64_t)1 << 32;
seg->maxprot = 7; // rwx
seg->initprot = 5; // r-x
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
seg = add_segment(mo, "__DATA");
macos: Tidy code
2020-05-26 00:47:05 +08:00
seg->vmaddr = -1;
seg->maxprot = 7; // rwx
seg->initprot = 3; // rw-
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
seg = add_segment(mo, "__LINKEDIT");
macos: Tidy code
2020-05-26 00:47:05 +08:00
seg->vmaddr = -1;
seg->maxprot = 7; // rwx
seg->initprot = 1; // r--
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
mo->ep = add_lc(mo, LC_MAIN, sizeof(*mo->ep));
macos: Tidy code
2020-05-26 00:47:05 +08:00
mo->ep->entryoff = 4096;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
i = (sizeof(*dyldlc) + strlen("/usr/lib/dyld") + 1 + 7) &-8;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
dyldlc = add_lc(mo, LC_LOAD_DYLINKER, i);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
dyldlc->name = sizeof(*dyldlc);
str = (char*)dyldlc + dyldlc->name;
strcpy(str, "/usr/lib/dyld");
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
symlc = add_lc(mo, LC_SYMTAB, sizeof(*symlc));
dysymlc = add_lc(mo, LC_DYSYMTAB, sizeof(*dysymlc));
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
for(i = 0; i < s1->nb_loaded_dlls; i++) {
DLLReference *dllref = s1->loaded_dlls[i];
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
if (dllref->level == 0)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
add_dylib(mo, dllref->name);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
}
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
macos: Tidy code
2020-05-26 00:47:05 +08:00
/* dyld requires a writable segment with classic Mach-O, but it ignores
zero-sized segments for this, so force to have some data. */
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
section_ptr_add(data_section, 1);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
memset (mo->sk_to_sect, 0, sizeof(mo->sk_to_sect));
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
for (i = s1->nb_sections; i-- > 1;) {
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
int type, flags;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
s = s1->sections[i];
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
type = s->sh_type;
flags = s->sh_flags;
sk = sk_unknown;
if (flags & SHF_ALLOC) {
switch (type) {
default: sk = sk_unknown; break;
macos: Support .init_array and .fini_array called different on Mach-O, but same functionality (list of pointers to init and fini functions).
2020-05-18 11:44:05 +08:00
case SHT_INIT_ARRAY: sk = sk_init; break;
case SHT_FINI_ARRAY: sk = sk_fini; break;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
case SHT_NOBITS: sk = sk_bss; break;
case SHT_SYMTAB: sk = sk_discard; break;
macos: section syms, strtab, runtime uncovered by the backtrace/boundcheck tests: * handle STT_SECTION symbols * call tcc_add_runtime (to get the bcheck.o/bt-exe.o files added) * add .stab strtab into segments (we should probably add all stab syms to the output LC_SYMTAB eventually, but right now TCC uses 32 bit stabs, while mach-o uses 32/64bit stabs
2020-05-22 10:37:35 +08:00
case SHT_STRTAB: sk = s == stabstr_section ? sk_ro_data : sk_discard; break;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
case SHT_RELX: sk = sk_discard; break;
case SHT_LINKEDIT: sk = sk_linkedit; break;
case SHT_PROGBITS:
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
if (s == s1->got)
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
sk = sk_nl_ptr;
else if (flags & SHF_EXECINSTR)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
sk = sk_text;
else if (flags & SHF_WRITE)
sk = sk_rw_data;
else
sk = sk_ro_data;
break;
}
} else
sk = sk_discard;
s->prev = mo->sk_to_sect[sk].s;
mo->sk_to_sect[sk].s = s;
}
fileofs = 4096; /* leave space for mach-o headers */
macos: Tidy code
2020-05-26 00:47:05 +08:00
curaddr = get_segment(mo, 1)->vmaddr;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
curaddr += 4096;
seg = NULL;
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
numsec = 0;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
mo->elfsectomacho = tcc_mallocz(sizeof(*mo->elfsectomacho) * s1->nb_sections);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
for (sk = sk_unknown; sk < sk_last; sk++) {
struct section_64 *sec = NULL;
if (seg) {
seg->vmsize = curaddr - seg->vmaddr;
seg->filesize = fileofs - seg->fileoff;
}
if (skinfo[sk].seg && mo->sk_to_sect[sk].s) {
uint64_t al = 0;
int si;
macos: Tidy code
2020-05-26 00:47:05 +08:00
seg = get_segment(mo, skinfo[sk].seg);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
if (skinfo[sk].name) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
si = add_section(mo, &seg, skinfo[sk].name);
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
numsec++;
macos: Tidy code
2020-05-26 00:47:05 +08:00
mo->lc[mo->seg2lc[skinfo[sk].seg]] = (struct load_command*)seg;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
mo->sk_to_sect[sk].machosect = si;
sec = get_section(seg, si);
sec->flags = skinfo[sk].flags;
}
if (seg->vmaddr == -1) {
curaddr = (curaddr + 4095) & -4096;
seg->vmaddr = curaddr;
fileofs = (fileofs + 4095) & -4096;
seg->fileoff = fileofs;
}
for (s = mo->sk_to_sect[sk].s; s; s = s->prev) {
int a = exact_log2p1(s->sh_addralign);
if (a && al < (a - 1))
al = a - 1;
s->sh_size = s->data_offset;
}
if (sec)
sec->align = al;
some cleanups related to recent commits - configure/Makefile : cleanup, really use CC_NAME - tccasm.c : remove C99 construct that MSVC doesn't compile - arm-gen.c, x86_64-gen.c, riscv64-gen.c, tccmacho.c : ditto - arm64-gen.c: commit 383acf8eff2818f8f0c5 wrote: "Instead of a cast, it would be better to pass the exact type." It is true that there are better solutions but it is not passing the exact type (I think). - tcctest.c: revert "fix cast test for clang" 03646ad46ff5d9a6d946 this obviously wants to test non-portable conversions - 114_bound_signal.test: clock_nanosleep is too new for older linuxes, just use sleep() instead
2020-06-27 23:22:04 +08:00
al = 1ULL << al;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
if (al > 4096)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_warning("alignment > 4096"), sec->align = 12, al = 4096;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
curaddr = (curaddr + al - 1) & -al;
fileofs = (fileofs + al - 1) & -al;
if (sec) {
sec->addr = curaddr;
sec->offset = fileofs;
}
for (s = mo->sk_to_sect[sk].s; s; s = s->prev) {
al = s->sh_addralign;
curaddr = (curaddr + al - 1) & -al;
win64: fix pe_isafunc() - tccpe.c: commit "tidy support for helper function" created STT_NOTYPE symbols and hence relied on ad-hoc detection which didn't work for x86_64 (as reported by Christian Jullien) - tccgen.c: However to be more safe the helper symbols are now made STT_FUNC anyway (via new VT_ASM_FUNC). Also: - tcc.h: minor reorder - riscv64-*, arm64-*, tccmacho.c: avoid some gcc format-warnings (mingw-gcc complains about "%llx" being "unknown conversion", although it does work since Vista or so)
2020-11-25 18:23:01 +08:00
dprintf("curaddr now 0x%lx\n", (long)curaddr);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
s->sh_addr = curaddr;
curaddr += s->sh_size;
if (s->sh_type != SHT_NOBITS) {
fileofs = (fileofs + al - 1) & -al;
s->sh_offset = fileofs;
fileofs += s->sh_size;
win64: fix pe_isafunc() - tccpe.c: commit "tidy support for helper function" created STT_NOTYPE symbols and hence relied on ad-hoc detection which didn't work for x86_64 (as reported by Christian Jullien) - tccgen.c: However to be more safe the helper symbols are now made STT_FUNC anyway (via new VT_ASM_FUNC). Also: - tcc.h: minor reorder - riscv64-*, arm64-*, tccmacho.c: avoid some gcc format-warnings (mingw-gcc complains about "%llx" being "unknown conversion", although it does work since Vista or so)
2020-11-25 18:23:01 +08:00
dprintf("fileofs now %ld\n", (long)fileofs);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
if (sec)
mo->elfsectomacho[s->sh_num] = numsec;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
if (sec)
sec->size = curaddr - sec->addr;
}
macos: Disable verbose linking output
2020-05-22 12:27:37 +08:00
if (DEBUG_MACHO)
for (s = mo->sk_to_sect[sk].s; s; s = s->prev) {
int type = s->sh_type;
int flags = s->sh_flags;
win64: fix pe_isafunc() - tccpe.c: commit "tidy support for helper function" created STT_NOTYPE symbols and hence relied on ad-hoc detection which didn't work for x86_64 (as reported by Christian Jullien) - tccgen.c: However to be more safe the helper symbols are now made STT_FUNC anyway (via new VT_ASM_FUNC). Also: - tcc.h: minor reorder - riscv64-*, arm64-*, tccmacho.c: avoid some gcc format-warnings (mingw-gcc complains about "%llx" being "unknown conversion", although it does work since Vista or so)
2020-11-25 18:23:01 +08:00
printf("%d section %-16s %-10s %09lx %04x %02d %s,%s,%s\n",
macos: Disable verbose linking output
2020-05-22 12:27:37 +08:00
sk,
s->name,
type == SHT_PROGBITS ? "progbits" :
type == SHT_NOBITS ? "nobits" :
type == SHT_SYMTAB ? "symtab" :
type == SHT_STRTAB ? "strtab" :
type == SHT_INIT_ARRAY ? "init" :
type == SHT_FINI_ARRAY ? "fini" :
type == SHT_RELX ? "rel" : "???",
win64: fix pe_isafunc() - tccpe.c: commit "tidy support for helper function" created STT_NOTYPE symbols and hence relied on ad-hoc detection which didn't work for x86_64 (as reported by Christian Jullien) - tccgen.c: However to be more safe the helper symbols are now made STT_FUNC anyway (via new VT_ASM_FUNC). Also: - tcc.h: minor reorder - riscv64-*, arm64-*, tccmacho.c: avoid some gcc format-warnings (mingw-gcc complains about "%llx" being "unknown conversion", although it does work since Vista or so)
2020-11-25 18:23:01 +08:00
(long)s->sh_addr,
macos: Disable verbose linking output
2020-05-22 12:27:37 +08:00
(unsigned)s->data_offset,
s->sh_addralign,
flags & SHF_ALLOC ? "alloc" : "",
flags & SHF_WRITE ? "write" : "",
flags & SHF_EXECINSTR ? "exec" : ""
);
}
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
if (seg) {
seg->vmsize = curaddr - seg->vmaddr;
seg->filesize = fileofs - seg->fileoff;
}
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
/* Fill symtab info */
symlc->symoff = mo->symtab->sh_offset;
symlc->nsyms = mo->symtab->data_offset / sizeof(struct nlist_64);
symlc->stroff = mo->strtab->sh_offset;
symlc->strsize = mo->strtab->data_offset;
macos: dynamic symbol table and __got this now sorts the symbols properly (local, global defined, undefined; the latter two by name), marks the three ranges within LC_DYSYMTAB, generates a __got section (non-lazy pointers) and slots for relocations which need them, and the indirect symbol mapping for them. This doesn't yet deal with undefined symbols. But it means compared to last example now this also works, i.e. read access to _global_ data: % cat simple3.c int loc = 42; int _start(void) { return loc - 42; }
2020-05-17 10:19:59 +08:00
dysymlc->iundefsym = mo->iundef == -1 ? symlc->nsyms : mo->iundef;
dysymlc->iextdefsym = mo->iextdef == -1 ? dysymlc->iundefsym : mo->iextdef;
dysymlc->ilocalsym = mo->ilocal == -1 ? dysymlc->iextdefsym : mo->ilocal;
dysymlc->nlocalsym = dysymlc->iextdefsym - dysymlc->ilocalsym;
dysymlc->nextdefsym = dysymlc->iundefsym - dysymlc->iextdefsym;
dysymlc->nundefsym = symlc->nsyms - dysymlc->iundefsym;
dysymlc->indirectsymoff = mo->indirsyms->sh_offset;
dysymlc->nindirectsyms = mo->indirsyms->data_offset / sizeof(uint32_t);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
static void macho_write(TCCState *s1, struct macho *mo, FILE *fp)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
int i, sk;
uint64_t fileofs = 0;
Section *s;
mo->mh.mh.magic = MH_MAGIC_64;
mo->mh.mh.cputype = 0x1000007; // x86_64
mo->mh.mh.cpusubtype = 0x80000003;// all | CPU_SUBTYPE_LIB64
mo->mh.mh.filetype = 2; // MH_EXECUTE
mo->mh.mh.flags = 4; // DYLDLINK
macos: Tidy code
2020-05-26 00:47:05 +08:00
mo->mh.mh.ncmds = mo->nlc;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
mo->mh.mh.sizeofcmds = 0;
for (i = 0; i < mo->nlc; i++)
mo->mh.mh.sizeofcmds += mo->lc[i]->cmdsize;
fwrite(&mo->mh, 1, sizeof(mo->mh), fp);
fileofs += sizeof(mo->mh);
for (i = 0; i < mo->nlc; i++) {
fwrite(mo->lc[i], 1, mo->lc[i]->cmdsize, fp);
fileofs += mo->lc[i]->cmdsize;
}
for (sk = sk_unknown; sk < sk_last; sk++) {
rework leading underscores tested on win32/64 to pass the tests when enabled - libtcc.c : let tcc define __leading_underscore if enabled tcc_add_symbol() : add _ automatically - tccelf.c : remove tcc_get_symbol_err(), find_c_sym() currently symbol length is limited to 256 in several places, so we can use a fixed local buffer for now as well. - win32/lib/crtinit.c : new file for init/fini - lib/*.S, tests7* : use __leading_underscore - bt-log.c: this file wont work relibaly if compiled with gcc
2020-06-27 23:15:06 +08:00
//struct segment_command_64 *seg;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
if (!skinfo[sk].seg || !mo->sk_to_sect[sk].s)
continue;
rework leading underscores tested on win32/64 to pass the tests when enabled - libtcc.c : let tcc define __leading_underscore if enabled tcc_add_symbol() : add _ automatically - tccelf.c : remove tcc_get_symbol_err(), find_c_sym() currently symbol length is limited to 256 in several places, so we can use a fixed local buffer for now as well. - win32/lib/crtinit.c : new file for init/fini - lib/*.S, tests7* : use __leading_underscore - bt-log.c: this file wont work relibaly if compiled with gcc
2020-06-27 23:15:06 +08:00
/*seg =*/ get_segment(mo, skinfo[sk].seg);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
for (s = mo->sk_to_sect[sk].s; s; s = s->prev) {
if (s->sh_type != SHT_NOBITS) {
while (fileofs < s->sh_offset)
fputc(0, fp), fileofs++;
if (s->sh_size) {
fwrite(s->data, 1, s->sh_size, fp);
fileofs += s->sh_size;
}
}
}
}
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
ST_FUNC int macho_output_file(TCCState *s1, const char *filename)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
{
int fd, mode, file_type;
FILE *fp;
macos: Fix memtest * free allocated memory * fix weak symbols related to -run * remove memtest from ignored tests for OSX
2020-05-26 04:18:37 +08:00
int i, ret = -1;
macos: initialize macho struct with memset which removes a clang warning on macOS.
2020-07-07 13:47:48 +08:00
struct macho mo;
(void)memset(&mo, 0, sizeof(mo));
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
file_type = s1->output_type;
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
if (file_type == TCC_OUTPUT_OBJ)
mode = 0666;
else
mode = 0777;
unlink(filename);
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, mode);
Add some missing fdopen(3) checks (Domingo Alvarez Duarte)
2022-03-01 04:19:41 +08:00
if (fd < 0 || (fp = fdopen(fd, "wb")) == NULL) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_error_noabort("could not write '%s: %s'", filename, strerror(errno));
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
return -1;
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
if (s1->verbose)
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
printf("<- %s\n", filename);
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_add_runtime(s1);
resolve_common_syms(s1);
create_symtab(s1, &mo);
check_relocs(s1, &mo);
ret = check_symbols(s1, &mo);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
if (!ret) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
collect_sections(s1, &mo);
relocate_syms(s1, s1->symtab, 0);
mo.ep->entryoff = get_sym_addr(s1, "main", 1, 1)
Revert commit 55f8963dfab5c543f7f34589d3ef9d3f2da3db14 from wanjochan until better tested on all platforms
2020-09-10 11:49:15 +08:00
- get_segment(&mo, 1)->vmaddr;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
if (s1->nb_errors)
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
goto do_ret;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
relocate_sections(s1);
convert_symbols(s1, &mo);
macho_write(s1, &mo, fp);
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
}
macos: Create symtab this creates a proper LC_SYMTAB, with reasonable entries. It's not sorted, so not usable for LC_DYSYMTAB. But 'nm -x -no-sort' allows to see us some useful info. This also relocates sections and symbols, so now this example works as well (i.e. read access to static local data): % cat simple2.c static int loc = 42; int main(void) { return loc - 42; }
2020-05-16 09:26:53 +08:00
do_ret:
macos: Fix memtest * free allocated memory * fix weak symbols related to -run * remove memtest from ignored tests for OSX
2020-05-26 04:18:37 +08:00
for (i = 0; i < mo.nlc; i++)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_free(mo.lc[i]);
tcc_free(mo.lc);
tcc_free(mo.elfsectomacho);
tcc_free(mo.e2msym);
macos: Fix memtest * free allocated memory * fix weak symbols related to -run * remove memtest from ignored tests for OSX
2020-05-26 04:18:37 +08:00
macos: First cut at generating Mach-O executables this does generate a working executable for a very simple example input, e.g. this: % cat simple.c int main(void) { return 0; } % ./tcc -B. -c simple.c % ./tcc -nostdlib -B. simple.o -lc % ./a.out && echo okay okay (the -lc is actually not necessary right now, see below). This has many limitations: * no symbol table, hence no calls to external functions from e.g. libc, aka libSystemB * no proper entry point (should be main, but is hardcoded to first real .text address) * libSystemB is hardcoded, no other libs are supported (but again no external calls anyway) * generated Mach-O executable is in old format: neither LC_DYLD_INFO no export tries for symbols are created (no symbol table at all!) * the __LINKEDIT segment is faked and empty, as dyld doesn't like it empty even if no symbols point into it * same with __DATA, dyld wants a non-empty writable segment which we enforce with useless data * no relocations, hence no function call stubs (lazy or not) are generated * hardcodes some other constants as well
2020-05-15 09:46:55 +08:00
fclose(fp);
return ret;
}
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
fix cross compiling on openbsd
2021-01-12 16:59:52 +08:00
static uint32_t macho_swap32(uint32_t x)
macos: Tidy code
2020-05-26 00:47:05 +08:00
{
return (x >> 24) | (x << 24) | ((x >> 8) & 0xff00) | ((x & 0xff00) << 8);
}
fix cross compiling on openbsd
2021-01-12 16:59:52 +08:00
#define SWAP(x) (swap ? macho_swap32(x) : (x))
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
#define tbd_parse_movepast(s) \
(pos = (pos = strstr(pos, s)) ? pos + strlen(s) : NULL)
#define tbd_parse_movetoany(cs) (pos = strpbrk(pos, cs))
#define tbd_parse_skipws while (*pos && (*pos==' '||*pos=='\n')) ++pos
#define tbd_parse_tramplequote if(*pos=='\''||*pos=='"') tbd_parse_trample
#define tbd_parse_tramplespace if(*pos==' ') tbd_parse_trample
#define tbd_parse_trample *pos++=0
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
#ifdef TCC_IS_NATIVE
/* Looks for the active developer SDK set by xcode-select (or the default
one set during installation.) */
Revert "Fix some errors on arm64-asm.c, rename some variables, fix several code style declarations" This reverts commit 61537d899af7bc163238ac21f666170ad84b6851.
2021-10-22 13:39:26 +08:00
ST_FUNC void tcc_add_macos_sdkpath(TCCState* s)
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
{
char *sdkroot = NULL, *pos = NULL;
void* xcs = dlopen("libxcselect.dylib", RTLD_GLOBAL | RTLD_LAZY);
CString path;
int (*f)(unsigned int, char**) = dlsym(xcs, "xcselect_host_sdk_path");
cstr_new(&path);
if (f) f(1, &sdkroot);
if (sdkroot)
pos = strstr(sdkroot,"SDKs/MacOSX");
if (pos)
[macOS] fix format warning
2021-07-27 13:54:46 +08:00
cstr_printf(&path, "%.*s.sdk/usr/lib", (int)(pos - sdkroot + 11), sdkroot);
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
/* must use free from libc directly */
#pragma push_macro("free")
#undef free
free(sdkroot);
#pragma pop_macro("free")
if (path.size)
tcc_add_library_path(s, (char*)path.data);
else
tcc_add_library_path(s,
"/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/lib"
":" "/Applications/Xcode.app/Developer/SDKs/MacOSX.sdk/usr/lib"
);
cstr_free(&path);
}
macOS 11: `tcc -run` using dyld shared cache
2021-07-04 17:07:48 +08:00
ST_FUNC const char* macho_tbd_soname(const char* filename) {
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
char *soname, *data, *pos;
const char *ret = filename;
macOS 11: `tcc -run` using dyld shared cache
2021-07-04 17:07:48 +08:00
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
int fd = open(filename,O_RDONLY);
if (fd<0) return ret;
pos = data = tcc_load_text(fd);
if (!tbd_parse_movepast("install-name: ")) goto the_end;
macOS 11: `tcc -run` using dyld shared cache
2021-07-04 17:07:48 +08:00
tbd_parse_skipws;
tbd_parse_tramplequote;
soname = pos;
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
if (!tbd_parse_movetoany("\n \"'")) goto the_end;
macOS 11: `tcc -run` using dyld shared cache
2021-07-04 17:07:48 +08:00
tbd_parse_trample;
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
ret = tcc_strdup(soname);
the_end:
macOS 11: `tcc -run` using dyld shared cache
2021-07-04 17:07:48 +08:00
tcc_free(data);
return ret;
}
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
#endif /* TCC_IS_NATIVE */
macOS 11: `tcc -run` using dyld shared cache
2021-07-04 17:07:48 +08:00
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
ST_FUNC int macho_load_tbd(TCCState* s1, int fd, const char* filename, int lev)
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
{
Minor fixes for gnu90 compatibility
2021-07-06 21:59:12 +08:00
char *soname, *data, *pos;
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
int ret = -1;
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
pos = data = tcc_load_text(fd);
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
if (!tbd_parse_movepast("install-name: ")) goto the_end;
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
tbd_parse_skipws;
tbd_parse_tramplequote;
soname = pos;
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
if (!tbd_parse_movetoany("\n \"'")) goto the_end;
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
tbd_parse_trample;
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
ret = 0;
libtcc: extend tcc_add_dllref() libtcc.c: - integrate find_dllref loop into tcc_add_dllref() tccelf.c: - make sure a DT_NEEDED tag is put for versions even when the dll was not previously loaded. Related commit 4c82b003420fabbb95e077866784badc1a49189b 48 insertions(+), 77 deletions(-)
2022-05-29 02:47:48 +08:00
if (tcc_add_dllref(s1, soname, lev)->found)
goto the_end;
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
while(pos) {
char* sym = NULL;
Minor fixes for gnu90 compatibility
2021-07-06 21:59:12 +08:00
int cont = 1;
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
if (!tbd_parse_movepast("symbols: ")) break;
if (!tbd_parse_movepast("[")) break;
while (cont) {
tbd_parse_skipws;
tbd_parse_tramplequote;
sym = pos;
if (!tbd_parse_movetoany(",] \"'")) break;
tbd_parse_tramplequote;
tbd_parse_tramplespace;
tbd_parse_skipws;
if (*pos==0||*pos==']') cont=0;
tbd_parse_trample;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
set_elf_sym(s1->dynsymtab_section, 0, 0,
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE), 0, SHN_UNDEF, sym);
}
}
the_end:
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_free(data);
macos: yet another tbd adjustment configure: - re-enable apple M1-arm64 - however, with --cpu=x86_64, set -arch in CFLAGS/LDFLAGS too (assume rosetta) Makefile: - re-enable osx cross-test (Please do not disable tests) tcc.h - set TCC_IS_NATIVE for TCC_TARGET_MACHO on __APPLE__ - apply TCC_USING_DOUBLE_FOR_LDOUBLE for x86_64-osx libtcc.c: - cleanup tcc_add_file_internal() - new function char *tcc_load_text(int fd); and use it for tbd files
2021-07-26 02:39:11 +08:00
return ret;
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
}
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
ST_FUNC int macho_load_dll(TCCState * s1, int fd, const char* filename, int lev)
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
{
unsigned char buf[sizeof(struct mach_header_64)];
void *buf2;
uint32_t machofs = 0;
struct fat_header fh;
struct mach_header mh;
struct load_command *lc;
int i, swap = 0;
const char *soname = filename;
struct nlist_64 *symtab = 0;
uint32_t nsyms = 0;
char *strtab = 0;
uint32_t strsize = 0;
uint32_t iextdef = 0;
uint32_t nextdef = 0;
again:
if (full_read(fd, buf, sizeof(buf)) != sizeof(buf))
return -1;
memcpy(&fh, buf, sizeof(fh));
if (fh.magic == FAT_MAGIC || fh.magic == FAT_CIGAM) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
struct fat_arch *fa = load_data(fd, sizeof(fh),
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
fh.nfat_arch * sizeof(*fa));
swap = fh.magic == FAT_CIGAM;
for (i = 0; i < SWAP(fh.nfat_arch); i++)
if (SWAP(fa[i].cputype) == 0x01000007 /* CPU_TYPE_X86_64 */
&& SWAP(fa[i].cpusubtype) == 3) /* CPU_SUBTYPE_X86_ALL */
break;
if (i == SWAP(fh.nfat_arch)) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_free(fa);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
return -1;
}
machofs = SWAP(fa[i].offset);
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_free(fa);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
lseek(fd, machofs, SEEK_SET);
goto again;
} else if (fh.magic == FAT_MAGIC_64 || fh.magic == FAT_CIGAM_64) {
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_warning("%s: Mach-O fat 64bit files of type 0x%x not handled",
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
filename, fh.magic);
return -1;
}
memcpy(&mh, buf, sizeof(mh));
if (mh.magic != MH_MAGIC_64)
return -1;
dprintf("found Mach-O at %d\n", machofs);
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
buf2 = load_data(fd, machofs + sizeof(struct mach_header_64), mh.sizeofcmds);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
for (i = 0, lc = buf2; i < mh.ncmds; i++) {
dprintf("lc %2d: 0x%08x\n", i, lc->cmd);
macos: Tidy code
2020-05-26 00:47:05 +08:00
switch (lc->cmd) {
case LC_SYMTAB:
{
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
struct symtab_command *sc = (struct symtab_command*)lc;
nsyms = sc->nsyms;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
symtab = load_data(fd, machofs + sc->symoff, nsyms * sizeof(*symtab));
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
strsize = sc->strsize;
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
strtab = load_data(fd, machofs + sc->stroff, strsize);
macos: Tidy code
2020-05-26 00:47:05 +08:00
break;
}
case LC_ID_DYLIB:
{
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
struct dylib_command *dc = (struct dylib_command*)lc;
soname = (char*)lc + dc->name;
dprintf(" ID_DYLIB %d 0x%x 0x%x %s\n",
dc->timestamp, dc->current_version,
dc->compatibility_version, soname);
macos: Tidy code
2020-05-26 00:47:05 +08:00
break;
}
case LC_REEXPORT_DYLIB:
{
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
struct dylib_command *dc = (struct dylib_command*)lc;
char *name = (char*)lc + dc->name;
int subfd = open(name, O_RDONLY | O_BINARY);
some cleanups related to recent commits - configure/Makefile : cleanup, really use CC_NAME - tccasm.c : remove C99 construct that MSVC doesn't compile - arm-gen.c, x86_64-gen.c, riscv64-gen.c, tccmacho.c : ditto - arm64-gen.c: commit 383acf8eff2818f8f0c5 wrote: "Instead of a cast, it would be better to pass the exact type." It is true that there are better solutions but it is not passing the exact type (I think). - tcctest.c: revert "fix cast test for clang" 03646ad46ff5d9a6d946 this obviously wants to test non-portable conversions - 114_bound_signal.test: clock_nanosleep is too new for older linuxes, just use sleep() instead
2020-06-27 23:22:04 +08:00
dprintf(" REEXPORT %s\n", name);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
if (subfd < 0)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_warning("can't open %s (reexported from %s)", name, filename);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
else {
/* Hopefully the REEXPORTs never form a cycle, we don't check
for that! */
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
macho_load_dll(s1, subfd, name, lev + 1);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
close(subfd);
}
macos: Tidy code
2020-05-26 00:47:05 +08:00
break;
}
case LC_DYSYMTAB:
{
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
struct dysymtab_command *dc = (struct dysymtab_command*)lc;
iextdef = dc->iextdefsym;
nextdef = dc->nextdefsym;
macos: Tidy code
2020-05-26 00:47:05 +08:00
break;
}
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
}
lc = (struct load_command*) ((char*)lc + lc->cmdsize);
}
libtcc: extend tcc_add_dllref() libtcc.c: - integrate find_dllref loop into tcc_add_dllref() tccelf.c: - make sure a DT_NEEDED tag is put for versions even when the dll was not previously loaded. Related commit 4c82b003420fabbb95e077866784badc1a49189b 48 insertions(+), 77 deletions(-)
2022-05-29 02:47:48 +08:00
if (tcc_add_dllref(s1, soname, lev)->found)
macOS 11: link using dyld shared cache Supports linking using .tbd definitions found in the default installed command-line tools SDK or Xcode.app SDK. Only for creating executables (not yet for `tcc -run`).
2021-07-04 17:06:55 +08:00
goto the_end;
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
if (!nsyms || !nextdef)
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_warning("%s doesn't export any symbols?", filename);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
//dprintf("symbols (all):\n");
dprintf("symbols (exported):\n");
dprintf(" n: typ sec desc value name\n");
//for (i = 0; i < nsyms; i++) {
for (i = iextdef; i < iextdef + nextdef; i++) {
struct nlist_64 *sym = symtab + i;
win64: fix pe_isafunc() - tccpe.c: commit "tidy support for helper function" created STT_NOTYPE symbols and hence relied on ad-hoc detection which didn't work for x86_64 (as reported by Christian Jullien) - tccgen.c: However to be more safe the helper symbols are now made STT_FUNC anyway (via new VT_ASM_FUNC). Also: - tcc.h: minor reorder - riscv64-*, arm64-*, tccmacho.c: avoid some gcc format-warnings (mingw-gcc complains about "%llx" being "unknown conversion", although it does work since Vista or so)
2020-11-25 18:23:01 +08:00
dprintf("%5d: %3d %3d 0x%04x 0x%016lx %s\n",
i, sym->n_type, sym->n_sect, sym->n_desc, (long)sym->n_value,
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
strtab + sym->n_strx);
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
set_elf_sym(s1->dynsymtab_section, 0, 0,
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
ELFW(ST_INFO)(STB_GLOBAL, STT_NOTYPE),
0, SHN_UNDEF, strtab + sym->n_strx);
}
the_end:
Revert "Move almost all global variables to TCCState, actually all tests pass on Ubuntu 18.04 x86_64" This reverts commit af686a796bda94dc92fc3ad140ef438dafa08950.
2021-10-22 13:39:54 +08:00
tcc_free(strtab);
tcc_free(symtab);
tcc_free(buf2);
macos: Read exported symbols from dylibs up to now we simply assumed that any undefined symbols will be provided by some shared libs on the cmdline. Now we check this.
2020-05-25 23:27:01 +08:00
return 0;
}
Reference in New Issue Copy Permalink