373 lines
10 KiB
Go
373 lines
10 KiB
Go
package generator
|
|
|
|
import "testing"
|
|
|
|
func TestLiteralInteger (test *testing.T) {
|
|
testString (test,
|
|
`%"AAAAAAAAAAAAAAAAAAAAAA==::Byte" = type i8
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca i64
|
|
store i64 382, ptr %1
|
|
%2 = alloca i64
|
|
store i64 -4392, ptr %2
|
|
%3 = alloca %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"
|
|
store i8 128, ptr %3
|
|
%4 = alloca i8
|
|
store i8 -127, ptr %4
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
ia:Int = 382
|
|
ib:Int = -4392
|
|
ic:Byte = 128
|
|
id:I8 = -127
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralArray (test *testing.T) {
|
|
testString (test,
|
|
`%"AAAAAAAAAAAAAAAAAAAAAA==::Index" = type i64
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca [3 x i64]
|
|
%2 = getelementptr [3 x i64], ptr %1, i32 0, i32 0
|
|
store i64 1, ptr %2
|
|
%3 = getelementptr [3 x i64], ptr %1, i32 0, i32 1
|
|
store i64 3, ptr %3
|
|
%4 = getelementptr [3 x i64], ptr %1, i32 0, i32 2
|
|
store i64 5, ptr %4
|
|
%5 = alloca { ptr, %"AAAAAAAAAAAAAAAAAAAAAA==::Index" }
|
|
%6 = alloca [3 x i64]
|
|
%7 = getelementptr [3 x i64], ptr %6, i32 0, i32 0
|
|
store i64 4, ptr %7
|
|
%8 = getelementptr [3 x i64], ptr %6, i32 0, i32 1
|
|
store i64 6, ptr %8
|
|
%9 = getelementptr [3 x i64], ptr %6, i32 0, i32 2
|
|
store i64 8, ptr %9
|
|
%10 = getelementptr { ptr, %"AAAAAAAAAAAAAAAAAAAAAA==::Index" }, ptr %5, i32 0, i32 0
|
|
store ptr %6, ptr %10
|
|
%11 = getelementptr { ptr, %"AAAAAAAAAAAAAAAAAAAAAA==::Index" }, ptr %5, i32 0, i32 1
|
|
store %"AAAAAAAAAAAAAAAAAAAAAA==::Index" 3, ptr %11
|
|
%12 = alloca ptr
|
|
%13 = alloca [4 x i64]
|
|
%14 = getelementptr [4 x i64], ptr %13, i32 0, i32 0
|
|
store i64 7, ptr %14
|
|
%15 = getelementptr [4 x i64], ptr %13, i32 0, i32 1
|
|
store i64 9, ptr %15
|
|
%16 = getelementptr [4 x i64], ptr %13, i32 0, i32 2
|
|
store i64 11, ptr %16
|
|
%17 = getelementptr [4 x i64], ptr %13, i32 0, i32 3
|
|
store i64 zeroinitializer, ptr %17
|
|
store ptr %13, ptr %12
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
a:3:Int = (1 3 5)
|
|
b:*:Int = (4 6 8)
|
|
c:*Int = (7 9 11)
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralArrayNested (test *testing.T) {
|
|
testString (test,
|
|
`%"0zNZN147MN2wzMAQ6NS2dQ==::A" = type [2 x [2 x i64]]
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca %"0zNZN147MN2wzMAQ6NS2dQ==::A"
|
|
%2 = getelementptr [2 x [2 x i64]], ptr %1, i32 0, i32 0
|
|
%3 = getelementptr [2 x i64], ptr %2, i32 0, i32 0
|
|
store i64 70, ptr %3
|
|
%4 = getelementptr [2 x i64], ptr %2, i32 0, i32 1
|
|
store i64 90, ptr %4
|
|
%5 = getelementptr [2 x [2 x i64]], ptr %1, i32 0, i32 1
|
|
%6 = getelementptr [2 x i64], ptr %5, i32 0, i32 0
|
|
store i64 2, ptr %6
|
|
%7 = getelementptr [2 x i64], ptr %5, i32 0, i32 1
|
|
store i64 4, ptr %7
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
A: 2:2:Int
|
|
[main] 'main' = {
|
|
a:A = (
|
|
(70 90)
|
|
( 2 4))
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralArrayUndersized (test *testing.T) {
|
|
testString (test,
|
|
`define void @main() {
|
|
0:
|
|
%1 = alloca [4 x i64]
|
|
%2 = getelementptr [3 x i64], ptr %1, i32 0, i32 0
|
|
store i64 5, ptr %2
|
|
%3 = getelementptr [3 x i64], ptr %1, i32 0, i32 1
|
|
store i64 9, ptr %3
|
|
%4 = getelementptr [3 x i64], ptr %1, i32 0, i32 2
|
|
store i64 3, ptr %4
|
|
%5 = getelementptr [3 x i64], ptr %1, i32 0, i32 3
|
|
store i64 zeroinitializer, ptr %5
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
a:4:Int = (5 9 3)
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralString (test *testing.T) {
|
|
testString (test,
|
|
`%"AAAAAAAAAAAAAAAAAAAAAA==::Byte" = type i8
|
|
%"AAAAAAAAAAAAAAAAAAAAAA==::Rune" = type i32
|
|
%"AAAAAAAAAAAAAAAAAAAAAA==::Index" = type i64
|
|
%"AAAAAAAAAAAAAAAAAAAAAA==::String" = type { ptr, %"AAAAAAAAAAAAAAAAAAAAAA==::Index" }
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"
|
|
%2 = alloca %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"
|
|
store i8 97, ptr %2
|
|
%3 = load %"AAAAAAAAAAAAAAAAAAAAAA==::Byte", ptr %2
|
|
store %"AAAAAAAAAAAAAAAAAAAAAA==::Byte" %3, ptr %1
|
|
%4 = alloca %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"
|
|
%5 = alloca %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"
|
|
store i32 241, ptr %5
|
|
%6 = load %"AAAAAAAAAAAAAAAAAAAAAA==::Rune", ptr %5
|
|
store %"AAAAAAAAAAAAAAAAAAAAAA==::Rune" %6, ptr %4
|
|
%7 = alloca [5 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"]
|
|
%8 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %7, i32 0, i32 0
|
|
store i8 115, ptr %8
|
|
%9 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %7, i32 0, i32 1
|
|
store i8 99, ptr %9
|
|
%10 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %7, i32 0, i32 2
|
|
store i8 zeroinitializer, ptr %10
|
|
%11 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %7, i32 0, i32 3
|
|
store i8 zeroinitializer, ptr %11
|
|
%12 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %7, i32 0, i32 4
|
|
store i8 zeroinitializer, ptr %12
|
|
%13 = alloca [5 x %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"]
|
|
%14 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"], ptr %13, i32 0, i32 0
|
|
store i32 115, ptr %14
|
|
%15 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"], ptr %13, i32 0, i32 1
|
|
store i32 100, ptr %15
|
|
%16 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"], ptr %13, i32 0, i32 2
|
|
store i32 zeroinitializer, ptr %16
|
|
%17 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"], ptr %13, i32 0, i32 3
|
|
store i32 zeroinitializer, ptr %17
|
|
%18 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Rune"], ptr %13, i32 0, i32 4
|
|
store i32 zeroinitializer, ptr %18
|
|
%19 = alloca %"AAAAAAAAAAAAAAAAAAAAAA==::String"
|
|
%20 = alloca [2 x i8]
|
|
%21 = getelementptr [2 x i8], ptr %20, i32 0, i32 0
|
|
store i8 115, ptr %21
|
|
%22 = getelementptr [2 x i8], ptr %20, i32 0, i32 1
|
|
store i8 101, ptr %22
|
|
%23 = getelementptr %"AAAAAAAAAAAAAAAAAAAAAA==::String", ptr %19, i32 0, i32 0
|
|
store ptr %20, ptr %23
|
|
%24 = getelementptr %"AAAAAAAAAAAAAAAAAAAAAA==::String", ptr %19, i32 0, i32 1
|
|
store %"AAAAAAAAAAAAAAAAAAAAAA==::Index" 2, ptr %24
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
sa:Byte = 'a'
|
|
sb:Rune = 'ñ'
|
|
sc:5:Byte = 'sc'
|
|
sd:5:Rune = 'sd'
|
|
se:String = 'se'
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralStringPointer (test *testing.T) {
|
|
testString (test,
|
|
`%"AAAAAAAAAAAAAAAAAAAAAA==::Byte" = type i8
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca ptr
|
|
%2 = alloca [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"]
|
|
%3 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %2, i32 0, i32 0
|
|
store i8 115, ptr %3
|
|
%4 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %2, i32 0, i32 1
|
|
store i8 102, ptr %4
|
|
%5 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %2, i32 0, i32 2
|
|
store i8 zeroinitializer, ptr %5
|
|
store ptr %2, ptr %1
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
sf:*Byte = 'sf'
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralStringSlice (test *testing.T) {
|
|
testString (test,
|
|
`%"AAAAAAAAAAAAAAAAAAAAAA==::Index" = type i64
|
|
%"AAAAAAAAAAAAAAAAAAAAAA==::String" = type { ptr, %"AAAAAAAAAAAAAAAAAAAAAA==::Index" }
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca %"AAAAAAAAAAAAAAAAAAAAAA==::String"
|
|
%2 = alloca [2 x i8]
|
|
%3 = getelementptr [2 x i8], ptr %2, i32 0, i32 0
|
|
store i8 115, ptr %3
|
|
%4 = getelementptr [2 x i8], ptr %2, i32 0, i32 1
|
|
store i8 102, ptr %4
|
|
%5 = getelementptr %"AAAAAAAAAAAAAAAAAAAAAA==::String", ptr %1, i32 0, i32 0
|
|
store ptr %2, ptr %5
|
|
%6 = getelementptr %"AAAAAAAAAAAAAAAAAAAAAA==::String", ptr %1, i32 0, i32 1
|
|
store %"AAAAAAAAAAAAAAAAAAAAAA==::Index" 2, ptr %6
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
sf:String = 'sf'
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralStringUndersized (test *testing.T) {
|
|
testString (test,
|
|
`%"AAAAAAAAAAAAAAAAAAAAAA==::Byte" = type i8
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca [5 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"]
|
|
%2 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %1, i32 0, i32 0
|
|
store i8 120, ptr %2
|
|
%3 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %1, i32 0, i32 1
|
|
store i8 121, ptr %3
|
|
%4 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %1, i32 0, i32 2
|
|
store i8 122, ptr %4
|
|
%5 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %1, i32 0, i32 3
|
|
store i8 zeroinitializer, ptr %5
|
|
%6 = getelementptr [3 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %1, i32 0, i32 4
|
|
store i8 zeroinitializer, ptr %6
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
a:5:Byte = 'xyz'
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestLiteralStruct (test *testing.T) {
|
|
testString (test,
|
|
`define void @main() {
|
|
0:
|
|
%1 = alloca { i64, { i64, i64 } }
|
|
%2 = getelementptr { i64, { i64, i64 } }, ptr %1, i32 0, i32 0
|
|
store i64 1, ptr %2
|
|
%3 = getelementptr { i64, { i64, i64 } }, ptr %1, i32 0, i32 1
|
|
%4 = getelementptr { i64, i64 }, ptr %3, i32 0, i32 0
|
|
store i64 2, ptr %4
|
|
%5 = getelementptr { i64, i64 }, ptr %3, i32 0, i32 1
|
|
store i64 3, ptr %5
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
[main] 'main' = {
|
|
ta:(.x:Int y:(.z:Int a:Int)) = (.x: 1 y: (.z: 2 a: 3))
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestTypedStructInstantiation (test *testing.T) {
|
|
testString (test,
|
|
`%"0zNZN147MN2wzMAQ6NS2dQ==::A" = type { i64 }
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca %"0zNZN147MN2wzMAQ6NS2dQ==::A"
|
|
%2 = getelementptr %"0zNZN147MN2wzMAQ6NS2dQ==::A", ptr %1, i32 0, i32 0
|
|
store i64 5, ptr %2
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
A: (.x:Int)
|
|
[main] 'main' = {
|
|
a:A = (.x: 5)
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestTypedArrayInstantiation (test *testing.T) {
|
|
testString (test,
|
|
`%"0zNZN147MN2wzMAQ6NS2dQ==::A" = type [2 x i64]
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca %"0zNZN147MN2wzMAQ6NS2dQ==::A"
|
|
%2 = getelementptr [2 x i64], ptr %1, i32 0, i32 0
|
|
store i64 1, ptr %2
|
|
%3 = getelementptr [2 x i64], ptr %1, i32 0, i32 1
|
|
store i64 2, ptr %3
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
A: 2:Int
|
|
[main] 'main' = {
|
|
a:A = (1 2)
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestTypedStringInstantiation (test *testing.T) {
|
|
testString (test,
|
|
`%"AAAAAAAAAAAAAAAAAAAAAA==::Byte" = type i8
|
|
%"0zNZN147MN2wzMAQ6NS2dQ==::A" = type [1 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"]
|
|
%"AAAAAAAAAAAAAAAAAAAAAA==::Index" = type i64
|
|
%"0zNZN147MN2wzMAQ6NS2dQ==::B" = type { ptr, %"AAAAAAAAAAAAAAAAAAAAAA==::Index" }
|
|
%"0zNZN147MN2wzMAQ6NS2dQ==::C" = type ptr
|
|
define void @main() {
|
|
0:
|
|
%1 = alloca %"0zNZN147MN2wzMAQ6NS2dQ==::A"
|
|
%2 = getelementptr [1 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %1, i32 0, i32 0
|
|
store i8 104, ptr %2
|
|
%3 = alloca %"0zNZN147MN2wzMAQ6NS2dQ==::B"
|
|
%4 = alloca [1 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"]
|
|
%5 = getelementptr [1 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %4, i32 0, i32 0
|
|
store i8 104, ptr %5
|
|
%6 = getelementptr %"0zNZN147MN2wzMAQ6NS2dQ==::B", ptr %3, i32 0, i32 0
|
|
store ptr %4, ptr %6
|
|
%7 = getelementptr %"0zNZN147MN2wzMAQ6NS2dQ==::B", ptr %3, i32 0, i32 1
|
|
store %"AAAAAAAAAAAAAAAAAAAAAA==::Index" 1, ptr %7
|
|
%8 = alloca %"0zNZN147MN2wzMAQ6NS2dQ==::C"
|
|
%9 = alloca [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"]
|
|
%10 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %9, i32 0, i32 0
|
|
store i8 104, ptr %10
|
|
%11 = getelementptr [2 x %"AAAAAAAAAAAAAAAAAAAAAA==::Byte"], ptr %9, i32 0, i32 1
|
|
store i8 zeroinitializer, ptr %11
|
|
store ptr %9, ptr %8
|
|
ret void
|
|
}
|
|
`,
|
|
`
|
|
A: 1:Byte
|
|
B: *:Byte
|
|
C: *Byte
|
|
[main] 'main' = {
|
|
a:A = 'h'
|
|
b:B = 'h'
|
|
c:C = 'h'
|
|
}
|
|
`)
|
|
}
|