plan9asm/small_coverage_test.go at main · goplus/plan9asm · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
package plan9asm

import (
	"strings"
	"testing"
)

func TestEmitIRSourceCommentEdges(t *testing.T) {
	var b strings.Builder
	emitIRSourceComment(&b, "")
	if b.Len() != 0 {
		t.Fatalf("empty comment emitted %q", b.String())
	}
	emitIRSourceComment(&b, " \n\tMOVQ AX, BX\n\nRET\t\n")
	out := b.String()
	for _, want := range []string{
		"; s: MOVQ AX, BX",
		"; s: RET",
	} {
		if !strings.Contains(out, want) {
			t.Fatalf("missing %q in:\n%s", want, out)
		}
	}
}

func TestParseIRModuleError(t *testing.T) {
	if _, err := parseIRModule("this is not valid llvm ir"); err == nil {
		t.Fatalf("parseIRModule(invalid) unexpectedly succeeded")
	}
}

func TestNeedCFGHelpers(t *testing.T) {
	if !funcNeedsAMD64CFG(Func{Instrs: []Instr{{Op: OpMOVQ, Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX}}, {Kind: OpReg, Reg: BX}}}}}) {
		t.Fatalf("funcNeedsAMD64CFG(mem mov) = false")
	}
	if !funcNeedsAMD64CFG(Func{Instrs: []Instr{{Op: "CRC32B"}}}) {
		t.Fatalf("funcNeedsAMD64CFG(crc32) = false")
	}
	if funcNeedsAMD64CFG(Func{Instrs: []Instr{{Op: OpTEXT}, {Op: OpMOVQ, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}}, {Op: OpRET}}}) {
		t.Fatalf("funcNeedsAMD64CFG(straight-line) = true")
	}

	if !funcNeedsARM64CFG(Func{Instrs: []Instr{{Op: "MOVD.P"}}}) {
		t.Fatalf("funcNeedsARM64CFG(dot suffix) = false")
	}
	if !funcNeedsARM64CFG(Func{Instrs: []Instr{{Op: "B"}}}) {
		t.Fatalf("funcNeedsARM64CFG(branch) = false")
	}
	if funcNeedsARM64CFG(Func{Instrs: []Instr{{Op: OpTEXT}, {Op: OpMRS}, {Op: OpMOVD, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: "R0"}}}, {Op: OpRET}}}) {
		t.Fatalf("funcNeedsARM64CFG(linear subset) = true")
	}

	if !funcNeedsARMCFG(Func{Instrs: []Instr{{Op: "ADD.EQ"}}}) {
		t.Fatalf("funcNeedsARMCFG(cond exec) = false")
	}
	if !funcNeedsARMCFG(Func{Instrs: []Instr{{Op: "BL"}}}) {
		t.Fatalf("funcNeedsARMCFG(branch) = false")
	}
	if funcNeedsARMCFG(Func{Instrs: []Instr{{Op: OpTEXT}, {Op: "MOVW"}, {Op: "ADD"}, {Op: OpRET}}}) {
		t.Fatalf("funcNeedsARMCFG(linear subset) = true")
	}
}

func TestAMD64EvalI64Coverage(t *testing.T) {
	sig := FuncSig{
		Name: "example.eval",
		Args: []LLVMType{I64},
		Ret:  I64,
		Frame: FrameLayout{
			Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0}},
		},
	}
	c, b := newAMD64CtxWithFuncForTest(t, Func{}, sig, nil)
	if err := c.storeReg(AX, "17"); err != nil {
		t.Fatalf("storeReg(AX) error = %v", err)
	}
	if err := c.storeReg(BX, "128"); err != nil {
		t.Fatalf("storeReg(BX) error = %v", err)
	}

	if got, err := c.evalI64(Operand{Kind: OpImm, Imm: 7}); err != nil || got != "7" {
		t.Fatalf("evalI64(imm) = (%q, %v)", got, err)
	}
	if got, err := c.evalI64(Operand{Kind: OpReg, Reg: AX}); err != nil || got == "" {
		t.Fatalf("evalI64(reg) = (%q, %v)", got, err)
	}
	if got, err := c.evalI64(Operand{Kind: OpFP, FPOffset: 0}); err != nil || got == "" {
		t.Fatalf("evalI64(fp) = (%q, %v)", got, err)
	}
	if got, err := c.evalI64(Operand{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}); err != nil || got == "" {
		t.Fatalf("evalI64(mem) = (%q, %v)", got, err)
	}
	if got, err := c.evalI64(Operand{Kind: OpSym, Sym: "value<>(SB)"}); err != nil || got == "" {
		t.Fatalf("evalI64(sym) = (%q, %v)", got, err)
	}
	if got, err := c.evalI64(Operand{Kind: OpSym, Sym: "$value<>(SB)"}); err != nil || got == "" {
		t.Fatalf("evalI64(addr sym) = (%q, %v)", got, err)
	}
	if got, err := c.evalI64(Operand{Kind: OpSym, Sym: "bad sym"}); err != nil || got != "0" {
		t.Fatalf("evalI64(unresolved bare sym) = (%q, %v)", got, err)
	}
	if _, err := c.evalI64(Operand{Kind: OpLabel, Sym: "loop"}); err == nil {
		t.Fatalf("evalI64(label) unexpectedly succeeded")
	}

	out := b.String()
	for _, want := range []string{
		"load i64, ptr %reg_AX",
		"load i64, ptr %t",
		"load i64, ptr @\"example.value\"",
		"ptrtoint ptr @\"example.value\" to i64",
	} {
		if !strings.Contains(out, want) {
			t.Fatalf("missing %q in:\n%s", want, out)
		}
	}
}