diff --git a/x86/x86asm/decode_test.go b/x86/x86asm/decode_test.go
index b6098b8..fae8490 100644
--- a/x86/x86asm/decode_test.go
+++ b/x86/x86asm/decode_test.go
@@ -54,9 +54,9 @@
 		} else {
 			switch syntax {
 			case "gnu":
-				out = GNUSyntax(inst)
+				out = GNUSyntax(inst, 0)
 			case "intel":
-				out = IntelSyntax(inst)
+				out = IntelSyntax(inst, 0)
 			case "plan9": // [sic]
 				out = GoSyntax(inst, 0, nil)
 			default:
diff --git a/x86/x86asm/ext_test.go b/x86/x86asm/ext_test.go
index eadfd71..a6097e1 100644
--- a/x86/x86asm/ext_test.go
+++ b/x86/x86asm/ext_test.go
@@ -248,9 +248,9 @@
 	} else {
 		switch syntax {
 		case "gnu":
-			text = GNUSyntax(inst)
+			text = GNUSyntax(inst, 0)
 		case "intel":
-			text = IntelSyntax(inst)
+			text = IntelSyntax(inst, 0)
 		case "plan9": // [sic]
 			text = GoSyntax(inst, 0, nil)
 		default:
diff --git a/x86/x86asm/format_test.go b/x86/x86asm/format_test.go
new file mode 100644
index 0000000..1f53638
--- /dev/null
+++ b/x86/x86asm/format_test.go
@@ -0,0 +1,66 @@
+// Copyright 2017 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package x86asm
+
+import (
+	"encoding/hex"
+	"testing"
+)
+
+func testFormattingSymname(addr uint64) (string, uint64) {
+	switch addr {
+	case 0x424080:
+		return "runtime.printint", 0x424080
+	}
+	return "", 0
+}
+
+func TestFormatting(t *testing.T) {
+	testCases := []struct {
+		PC    uint64
+		bytes string
+
+		goSyntax, intelSyntax, gnuSyntax string
+	}{
+		{0x4816b2, "0f8677010000",
+			"JBE 0x48182f",
+			"jbe 0x48182f",
+			"jbe 0x48182f"},
+		{0x45065b, "488b442408",
+			"MOVQ 0x8(SP), AX",
+			"mov rax, qword ptr [rsp+0x8]",
+			"mov 0x8(%rsp),%rax"},
+		{0x450678, "488b05e9790700",
+			"MOVQ 0x779e9(IP), AX",
+			"mov rax, qword ptr [rip+0x779e9]",
+			"mov 0x779e9(%rip),%rax"},
+		{0x450664, "e8173afdff",
+			"CALL runtime.printint(SB)",
+			"call 0x424080",
+			"callq 0x424080"},
+		{0x45069b, "488d0575d90100",
+			"LEAQ 0x1d975(IP), AX",
+			"lea rax, ptr [rip+0x1d975]",
+			"lea 0x1d975(%rip),%rax"},
+	}
+
+	for _, testCase := range testCases {
+		t.Logf("%#x %s %s", testCase.PC, testCase.bytes, testCase.goSyntax)
+		bs, _ := hex.DecodeString(testCase.bytes)
+		inst, err := Decode(bs, 64)
+		if err != nil {
+			t.Errorf("decode error %v", err)
+		}
+		if out := GoSyntax(inst, testCase.PC, testFormattingSymname); out != testCase.goSyntax {
+			t.Errorf("GoSyntax: %q", out)
+		}
+		if out := IntelSyntax(inst, testCase.PC); out != testCase.intelSyntax {
+			t.Errorf("IntelSyntax: %q expected: %q", out, testCase.intelSyntax)
+		}
+		if out := GNUSyntax(inst, testCase.PC); out != testCase.gnuSyntax {
+			t.Errorf("GNUSyntax: %q expected: %q", out, testCase.gnuSyntax)
+		}
+	}
+}
diff --git a/x86/x86asm/gnu.go b/x86/x86asm/gnu.go
index 728e5d1..073b746 100644
--- a/x86/x86asm/gnu.go
+++ b/x86/x86asm/gnu.go
@@ -11,7 +11,7 @@
 
 // GNUSyntax returns the GNU assembler syntax for the instruction, as defined by GNU binutils.
 // This general form is often called ``AT&T syntax'' as a reference to AT&T System V Unix.
-func GNUSyntax(inst Inst) string {
+func GNUSyntax(inst Inst, pc uint64) string {
 	// Rewrite instruction to mimic GNU peculiarities.
 	// Note that inst has been passed by value and contains
 	// no pointers, so any changes we make here are local
@@ -403,7 +403,7 @@
 		if a == Imm(1) && (inst.Opcode>>24)&^1 == 0xD0 {
 			continue
 		}
-		args = append(args, gnuArg(&inst, a, &usedPrefixes))
+		args = append(args, gnuArg(&inst, pc, a, &usedPrefixes))
 	}
 
 	// The default is to print the arguments in reverse Intel order.
@@ -513,7 +513,7 @@
 // gnuArg returns the GNU syntax for the argument x from the instruction inst.
 // If *usedPrefixes is false and x is a Mem, then the formatting
 // includes any segment prefixes and sets *usedPrefixes to true.
-func gnuArg(inst *Inst, x Arg, usedPrefixes *bool) string {
+func gnuArg(inst *Inst, pc uint64, x Arg, usedPrefixes *bool) string {
 	if x == nil {
 		return "<nil>"
 	}
@@ -644,7 +644,12 @@
 		}
 		return fmt.Sprintf("%s%s(%s,%s,%d)", seg, disp, base, index, x.Scale)
 	case Rel:
-		return fmt.Sprintf(".%+#x", int32(x))
+		if pc == 0 {
+			return fmt.Sprintf(".%+#x", int64(x))
+		} else {
+			addr := pc + uint64(inst.Len) + uint64(x)
+			return fmt.Sprintf("%#x", addr)
+		}
 	case Imm:
 		if inst.Mode == 32 {
 			return fmt.Sprintf("$%#x", uint32(x))
diff --git a/x86/x86asm/intel.go b/x86/x86asm/intel.go
index 63fa2cf..6b0e36a 100644
--- a/x86/x86asm/intel.go
+++ b/x86/x86asm/intel.go
@@ -10,7 +10,7 @@
 )
 
 // IntelSyntax returns the Intel assembler syntax for the instruction, as defined by Intel's XED tool.
-func IntelSyntax(inst Inst) string {
+func IntelSyntax(inst Inst, pc uint64) string {
 	var iargs []Arg
 	for _, a := range inst.Args {
 		if a == nil {
@@ -256,7 +256,7 @@
 		if a == nil {
 			break
 		}
-		args = append(args, intelArg(&inst, a))
+		args = append(args, intelArg(&inst, pc, a))
 	}
 
 	var op string
@@ -334,7 +334,7 @@
 	return prefix + op
 }
 
-func intelArg(inst *Inst, arg Arg) string {
+func intelArg(inst *Inst, pc uint64, arg Arg) string {
 	switch a := arg.(type) {
 	case Imm:
 		if inst.Mode == 32 {
@@ -422,13 +422,13 @@
 		}
 		prefix += "["
 		if a.Base != 0 {
-			prefix += intelArg(inst, a.Base)
+			prefix += intelArg(inst, pc, a.Base)
 		}
 		if a.Scale != 0 && a.Index != 0 {
 			if a.Base != 0 {
 				prefix += "+"
 			}
-			prefix += fmt.Sprintf("%s*%d", intelArg(inst, a.Index), a.Scale)
+			prefix += fmt.Sprintf("%s*%d", intelArg(inst, pc, a.Index), a.Scale)
 		}
 		if a.Disp != 0 {
 			if prefix[len(prefix)-1] == '[' && (a.Disp >= 0 || int64(int32(a.Disp)) != a.Disp) {
@@ -440,7 +440,12 @@
 		prefix += "]"
 		return prefix
 	case Rel:
-		return fmt.Sprintf(".%+#x", int64(a))
+		if pc == 0 {
+			return fmt.Sprintf(".%+#x", int64(a))
+		} else {
+			addr := pc + uint64(inst.Len) + uint64(a)
+			return fmt.Sprintf("%#x", addr)
+		}
 	case Reg:
 		if int(a) < len(intelReg) && intelReg[a] != "" {
 			switch inst.Op {