Merge tag 'nasm-2.12.02rc9'

NASM 2.12.02rc9

Resolved Conflicts:
	asm/preproc.c
	version

Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>

asm/preproc.c

@@ -1507,7 +1507,7 @@ static bool in_list(const StrList *list, const char *str)
  * the end of the path.
  */
 static FILE *inc_fopen(const char *file, StrList **dhead, StrList ***dtail,
-                       bool missing_ok, enum file_flags mode)
+                       char **found_path, bool missing_ok, enum file_flags mode)
 {
     FILE *fp;
     char *prefix = "";
@@ -1515,11 +1515,20 @@ static FILE *inc_fopen(const char *file, StrList **dhead, StrList ***dtail,
     int len = strlen(file);
     size_t prefix_len = 0;
     StrList *sl;
+    size_t path_len;
 
     while (1) {
-        sl = nasm_malloc(prefix_len+len+1+sizeof sl->next);
+        path_len = prefix_len + len + 1;
+
+        sl = nasm_malloc(path_len + sizeof sl->next);
         memcpy(sl->str, prefix, prefix_len);
         memcpy(sl->str+prefix_len, file, len+1);
+
+        if (found_path != NULL) {
+            *found_path = nasm_malloc(path_len);
+            memcpy(*found_path, sl->str, path_len);
+        }
+
         fp = nasm_open_read(sl->str, mode);
         if (fp && dhead && !in_list(*dhead, sl->str)) {
             sl->next = NULL;
@@ -1530,6 +1539,12 @@ static FILE *inc_fopen(const char *file, StrList **dhead, StrList ***dtail,
         }
         if (fp)
             return fp;
+
+        if (found_path != NULL && *found_path != NULL) {
+            nasm_free(*found_path);
+            *found_path = NULL;
+        }
+
         if (!ip) {
             if (!missing_ok)
                 break;
@@ -1568,7 +1583,7 @@ FILE *pp_input_fopen(const char *filename, enum file_flags mode)
     StrList *xsl = NULL;
     StrList **xst = &xsl;
 
-    fp = inc_fopen(filename, &xsl, &xst, true, mode);
+    fp = inc_fopen(filename, &xsl, &xst, NULL, true, mode);
     if (xsl)
         nasm_free(xsl);
     return fp;
@@ -2173,7 +2188,7 @@ static int do_directive(Token * tline)
     bool casesense;
     int k, m;
     int offset;
-    char *p, *pp;
+    char *p, *pp, *found_path;
     const char *mname;
     Include *inc;
     Context *ctx;
@@ -2515,12 +2530,13 @@ static int do_directive(Token * tline)
         inc = nasm_malloc(sizeof(Include));
         inc->next = istk;
         inc->conds = NULL;
-        inc->fp = inc_fopen(p, dephead, &deptail, pass == 0, NF_TEXT);
+        found_path = NULL;
+        inc->fp = inc_fopen(p, dephead, &deptail, &found_path, pass == 0, NF_TEXT);
         if (!inc->fp) {
             /* -MG given but file not found */
             nasm_free(inc);
         } else {
-            inc->fname = src_set_fname(p);
+            inc->fname = src_set_fname(found_path ? found_path : p);
             inc->lineno = src_set_linnum(0);
             inc->lineinc = 1;
             inc->expansion = NULL;
@@ -3258,7 +3274,7 @@ issue_error:
         if (t->type != TOK_INTERNAL_STRING)
             nasm_unquote(p, NULL);
 
-        fp = inc_fopen(p, &xsl, &xst, true, NF_TEXT);
+        fp = inc_fopen(p, &xsl, &xst, NULL, true, NF_TEXT);
         if (fp) {
             p = xsl->str;
             fclose(fp);         /* Don't actually care about the file */

output/outmacho.c

@@ -464,7 +464,7 @@ static int64_t add_reloc(struct section *sect, int32_t section,
 	    r->snum = raa_read(extsyms, section);
 	    if (reltype == RL_BRANCH)
 		r->type = X86_64_RELOC_BRANCH;
-	    else if (reltype == GENERIC_RELOC_VANILLA)
+	    else if (r->type == GENERIC_RELOC_VANILLA)
 		adjust = -sect->size;
 	} else {
 	    /* local */

output/outobj.c

@@ -1101,9 +1101,43 @@ static void obj_out(int32_t segto, const void *data,
 
         ldata = *(int64_t *)data;
         if (type != OUT_ADDRESS) {
-            ldata += size;
-	    size = realsize(type, size);
+	    /*
+	     * For 16-bit and 32-bit x86 code, the size and realsize() always
+	     * matches as only jumps, calls and loops uses PC relative
+	     * addressing and the address isn't followed by any other opcode
+	     * bytes.  In 64-bit mode there is RIP relative addressing which
+	     * means the fixup location can be followed by an immediate value,
+	     * meaning that size > realsize().
+	     *
+	     * When the CPU is calculating the effective address, it takes the
+	     * RIP at the end of the instruction and adds the fixed up relative
+	     * address value to it.
+	     *
+	     * The linker's point of reference is the end of the fixup location
+	     * (which is the end of the instruction for Jcc, CALL, LOOP[cc]).
+	     * It is calculating distance between the target symbol and the end
+	     * of the fixup location, and add this to the displacement value we
+	     * are calculating here and storing at the fixup location.
+	     *
+	     * To get the right effect, we need to _reduce_ the displacement
+	     * value by the number of bytes following the fixup.
+	     *
+	     * Example:
+	     *  data at address 0x100; REL4ADR at 0x050, 4 byte immediate,
+	     *  end of fixup at 0x054, end of instruction at 0x058.
+	     *  => size = 8.
+	     *  => realsize() -> 4
+	     *  => CPU needs a value of:   0x100 - 0x058 = 0x0a8
+	     *  => linker/loader will add: 0x100 - 0x054 = 0x0ac
+	     *  => We must add an addend of -4.
+	     *  => realsize() - size = -4.
+	     *
+	     * The code used to do size - realsize() at least since v0.90,
+	     * probably because it wasn't needed...
+	     */
 	    ldata -= size;
+	    size = realsize(type, size);
+	    ldata += size;
         }
 
 	if (size > UINT_MAX)