build_version pragma + macro for Mach-O

Matches the llvm-as .build_version syntax. Newer MacOS linker
complains when object files don't contain a LC_BUILD_VERSION.

Signed-off-by: Fabian Giesen <fabian.giesen@epicgames.com>

Author: Fabian Giesen

output/macho.h

@@ -30,6 +30,7 @@
 #define LC_SEGMENT			0x1
 #define LC_SEGMENT_64			0x19
 #define LC_SYMTAB			0x2
+#define LC_BUILD_VERSION		0x32
 
 /* Symbol type bits */
 #define N_STAB				0xe0
@@ -120,6 +121,24 @@
 #define VM_PROT_WRITE			0x02
 #define VM_PROT_EXECUTE			0x04
 
+/* Platforms */
+/* X-macro X(_platform, _id, _name) */
+#define MACHO_ALL_PLATFORMS \
+	X(PLATFORM_UNKNOWN, 0, "unknown") \
+	X(PLATFORM_MACOS, 1, "macos") \
+	X(PLATFORM_IOS, 2, "ios") \
+	X(PLATFORM_TVOS, 3, "tvos") \
+	X(PLATFORM_WATCHOS, 4, "watchos") \
+	X(PLATFORM_BRIDGEOS, 5, "bridgeos") \
+	X(PLATFORM_MACCATALYST, 6, "macCatalyst") \
+	X(PLATFORM_IOSSIMULATOR, 7, "iossimulator") \
+	X(PLATFORM_TVOSSIMULATOR, 8, "tvossimulator") \
+	X(PLATFORM_WATCHOSSIMULATOR, 9, "watchossimulator") \
+	X(PLATFORM_DRIVERKIT, 10, "driverkit") \
+	X(PLATFORM_XROS, 11, "xros") \
+	X(PLATFORM_XROS_SIMULATOR, 12, "xrsimulator") \
+	/* end */
+
 typedef struct {
 	uint32_t	magic;
 	uint32_t	cputype;
@@ -249,4 +268,20 @@ typedef struct {
 	uint64_t	n_value;
 } macho_nlist_64_t;
 
+/* Adapted from LLVM include/llvm/BinaryFormat/MachO.h */
+typedef struct {
+	uint32_t	tool;
+	uint32_t	version;
+} macho_build_tool_version_t;
+
+typedef struct {
+	uint32_t	cmd;
+	uint32_t	cmdsize;
+	uint32_t	platform;
+	uint32_t	minos;		/* x.y.z is 0xXXXXYYZZ */
+	uint32_t	sdk;		/* x.y.z is 0xXXXXYYZZ */
+	uint32_t	ntools;
+	/* ntools macho_build_tool_version_t follow this */
+} macho_build_version_command_t;
+
 #endif /* OUTPUT_MACHO_H */

output/outmacho.c

@@ -39,12 +39,20 @@
 #define MACHO_SEGCMD64_SIZE		72
 #define MACHO_SECTCMD64_SIZE		80
 #define MACHO_NLIST64_SIZE		16
+#define MACHO_BUILD_VERSION_SIZE	24
 
 /* Mach-O relocations numbers */
 
 #define VM_PROT_DEFAULT	(VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
 #define VM_PROT_ALL	(VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE)
 
+/* Platforms enum */
+enum macho_platform {
+#define X(_platform, _id, _name) _platform = _id,
+    MACHO_ALL_PLATFORMS
+#undef X
+};
+
 /* Our internal relocation types */
 enum reltype {
     RL_ABS,			/* Absolute relocation */
@@ -185,6 +193,10 @@ static uint64_t seg_vmsize = 0;
 static uint32_t seg_nsects = 0;
 static uint64_t rel_padcnt = 0;
 
+static uint32_t buildver_platform = PLATFORM_UNKNOWN;
+static uint32_t buildver_minos = 0; // x.y.z is 0xXXXXYYZZ
+static uint32_t buildver_sdk = 0; // x.y.z is 0xXXXXYYZZ
+
 /*
  * Functions for handling fixed-length zero-padded string
  * fields, that may or may not be null-terminated.
@@ -1235,6 +1247,11 @@ static void macho_calculate_sizes (void)
 
     /* calculate size of all headers, load commands and sections to
     ** get a pointer to the start of all the raw data */
+    if (buildver_platform != PLATFORM_UNKNOWN) {
+	++head_ncmds;
+	head_sizeofcmds += MACHO_BUILD_VERSION_SIZE;
+    }
+
     if (seg_nsects > 0) {
         ++head_ncmds;
         head_sizeofcmds += fmt.segcmd_size  + seg_nsects * fmt.sectcmd_size;
@@ -1617,6 +1634,16 @@ static void macho_write (void)
 
     offset = fmt.header_size + head_sizeofcmds;
 
+    /* emit the build_version command early, if desired */
+    if (buildver_platform != PLATFORM_UNKNOWN) {
+	fwriteint32_t(LC_BUILD_VERSION, ofile);	/* cmd == LC_BUILD_VERSION */
+	fwriteint32_t(MACHO_BUILD_VERSION_SIZE, ofile); /* size of load command */
+	fwriteint32_t(buildver_platform, ofile); /* platform */
+	fwriteint32_t(buildver_minos, ofile);	/* minos */
+	fwriteint32_t(buildver_sdk, ofile);	/* sdk */
+	fwriteint32_t(0, ofile);		/* ntools */
+    }
+
     /* emit the segment load command */
     if (seg_nsects > 0)
 	offset = macho_write_segment (offset);
@@ -1764,6 +1791,124 @@ static enum directive_result macho_no_dead_strip(const char *labels)
     return rv;
 }
 
+static bool macho_match_string(const char **pp, const char *target_name)
+{
+    const char *p = *pp;
+    while (*target_name) {
+	if (*p++ != *target_name++)
+	    return false;
+    }
+
+    /* must have exhausted the run of identifier characters */
+    if (nasm_isidchar(*p)) {
+	return false;
+    }
+
+    *pp = p;
+    return true;
+}
+
+static bool macho_scan_number(const char **pp, int64_t *result)
+{
+    bool error = false;
+    const char *p = *pp;
+    while (nasm_isdigit(*p))
+	++p;
+
+    if (p == *pp) {
+	*result = 0;
+	return false;
+    }
+
+    *result = readnum(*pp, &error);
+    *pp = p;
+    return !error;
+}
+
+static bool macho_scan_version(const char **pp, uint32_t *result)
+{
+    int64_t major = 0;
+    int64_t minor = 0;
+    int64_t trailing = 0;
+
+    /* version: major, minor (, trailing)? */
+    *result = 0;
+
+    if (!macho_scan_number(pp, &major) || major < 0 || major > 65535)
+	return false;
+    *pp = nasm_skip_spaces(*pp);
+    if (**pp != ',') /* comma after major ver is required */
+	return false;
+    *pp = nasm_skip_spaces(*pp + 1);
+
+    if (!macho_scan_number(pp, &minor) || minor < 0 || minor > 255)
+	return false;
+    *pp = nasm_skip_spaces(*pp);
+
+    if (**pp == ',') {
+	/* trailing version present */
+	*pp = nasm_skip_spaces(*pp + 1);
+	if (!macho_scan_number(pp, &trailing) || trailing < 0 || trailing > 255)
+	    return false;
+    }
+
+    *result = (uint32_t) ((major << 16) | (minor << 8) | trailing);
+    return true;
+}
+
+/*
+ * Specify a build version
+ */
+static enum directive_result macho_build_version(const char *buildversion)
+{
+    /* Matching .build_version directive in LLVM-MC */
+    const char *p;
+    uint32_t platform = PLATFORM_UNKNOWN;
+    uint32_t minos = 0;
+    uint32_t sdk = 0;
+
+    p = nasm_skip_spaces(buildversion);
+
+#define X(_platform,_id,_name) if (macho_match_string(&p, _name)) platform = _platform;
+    MACHO_ALL_PLATFORMS
+#undef X
+
+    if (platform == PLATFORM_UNKNOWN) {
+	nasm_nonfatal("unknown platform name");
+	return DIRR_ERROR;
+    }
+
+    p = nasm_skip_spaces(p);
+    if (*p != ',') {
+	nasm_nonfatal("version number required, comma expected");
+	return DIRR_ERROR;
+    }
+    p = nasm_skip_spaces(p + 1);
+
+    if (!macho_scan_version(&p, &minos)) {
+	nasm_nonfatal("malformed version number");
+	return DIRR_ERROR;
+    }
+
+    p = nasm_skip_spaces(p);
+    if (*p) {
+	if (macho_match_string(&p, "sdk_version")) {
+	    p = nasm_skip_spaces(p);
+
+	    if (!macho_scan_version(&p, &sdk)) {
+		nasm_nonfatal("malformed sdk_version");
+		return DIRR_ERROR;
+	    }
+	} else
+	    nasm_nonfatal("extra characters in build_version");
+    }
+
+    buildver_platform = platform;
+    buildver_minos = minos;
+    buildver_sdk = sdk;
+    return DIRR_OK;
+}
+
 /*
  * Mach-O pragmas
  */
@@ -1786,6 +1931,12 @@ macho_pragma(const struct pragma *pragma)
     case D_NO_DEAD_STRIP:
 	return macho_no_dead_strip(pragma->tail);
 
+    case D_unknown:
+	if (!strcmp(pragma->opname, "build_version"))
+	    return macho_build_version(pragma->tail);
+
+	return DIRR_UNKNOWN;
+
     default:
 	return DIRR_UNKNOWN;	/* Not a Mach-O directive */
     }

output/outmacho.mac

@@ -17,3 +17,8 @@ OUT: macho macho32 macho64
         %rotate 1
     %endrep
 %endmacro
+
+; This sets LC_BUILD_VERSION in the object file, analogous to as .build_version
+%imacro build_version 3+
+    %pragma __?OUTPUT_FORMAT?__ %? %1,%2,%3
+%endmacro