mirror of
https://github.com/c3lang/c3c.git
synced 2026-02-27 12:01:16 +00:00
Change printfln to printfn. Make LLVM 15 tests default.
This commit is contained in:
Christoffer Lerno
committed by
Christoffer Lerno
Christoffer Lerno
parent
3298ff2e15
commit
dc16f65c8e
@@ -38,25 +38,24 @@ fn void main()
|
||||
|
||||
/* #expect: vector_bit.ll
|
||||
|
||||
; Function Attrs: nounwind
|
||||
define void @vector_bit_testf() #0 {
|
||||
entry:
|
||||
%y = alloca <4 x float>, align 16
|
||||
%w = alloca <4 x i32>, align 16
|
||||
store <4 x float> <float 0.000000e+00, float 2.000000e+00, float 3.000000e+00, float 0.000000e+00>, <4 x float>* %y, align 16
|
||||
%0 = load <4 x float>, <4 x float>* %y, align 16
|
||||
store <4 x float> <float 0.000000e+00, float 2.000000e+00, float 3.000000e+00, float 0.000000e+00>, ptr %y, align 16
|
||||
%0 = load <4 x float>, ptr %y, align 16
|
||||
%not = fcmp une <4 x float> %0, zeroinitializer
|
||||
%1 = sext <4 x i1> %not to <4 x i32>
|
||||
store <4 x i32> %1, <4 x i32>* %w, align 16
|
||||
%2 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %1, ptr %w, align 16
|
||||
%2 = load <4 x i32>, ptr %w, align 16
|
||||
%3 = extractelement <4 x i32> %2, i64 0
|
||||
%4 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%4 = load <4 x i32>, ptr %w, align 16
|
||||
%5 = extractelement <4 x i32> %4, i64 1
|
||||
%6 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%6 = load <4 x i32>, ptr %w, align 16
|
||||
%7 = extractelement <4 x i32> %6, i64 2
|
||||
%8 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%8 = load <4 x i32>, ptr %w, align 16
|
||||
%9 = extractelement <4 x i32> %8, i64 3
|
||||
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i32 0, i32 0), i32 %3, i32 %5, i32 %7, i32 %9)
|
||||
%10 = call i32 (ptr, ...) @printf(ptr @.str, i32 %3, i32 %5, i32 %7, i32 %9)
|
||||
ret void
|
||||
}
|
||||
|
||||
@@ -66,90 +65,90 @@ entry:
|
||||
%y = alloca <4 x i32>, align 16
|
||||
%z = alloca <4 x i32>, align 16
|
||||
%w = alloca <4 x i32>, align 16
|
||||
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, <4 x i32>* %y, align 16
|
||||
store <4 x i32> <i32 2, i32 3, i32 13, i32 -100>, <4 x i32>* %z, align 16
|
||||
store <4 x i32> zeroinitializer, <4 x i32>* %w, align 16
|
||||
%0 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%1 = load <4 x i32>, <4 x i32>* %z, align 16
|
||||
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, ptr %y, align 16
|
||||
store <4 x i32> <i32 2, i32 3, i32 13, i32 -100>, ptr %z, align 16
|
||||
store <4 x i32> zeroinitializer, ptr %w, align 16
|
||||
%0 = load <4 x i32>, ptr %y, align 16
|
||||
%1 = load <4 x i32>, ptr %z, align 16
|
||||
%and = and <4 x i32> %0, %1
|
||||
store <4 x i32> %and, <4 x i32>* %w, align 16
|
||||
%2 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %and, ptr %w, align 16
|
||||
%2 = load <4 x i32>, ptr %w, align 16
|
||||
%3 = extractelement <4 x i32> %2, i64 0
|
||||
%4 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%4 = load <4 x i32>, ptr %w, align 16
|
||||
%5 = extractelement <4 x i32> %4, i64 1
|
||||
%6 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%6 = load <4 x i32>, ptr %w, align 16
|
||||
%7 = extractelement <4 x i32> %6, i64 2
|
||||
%8 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%8 = load <4 x i32>, ptr %w, align 16
|
||||
%9 = extractelement <4 x i32> %8, i64 3
|
||||
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i32 0, i32 0), i32 %3, i32 %5, i32 %7, i32 %9)
|
||||
%11 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%12 = load <4 x i32>, <4 x i32>* %z, align 16
|
||||
%10 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %3, i32 %5, i32 %7, i32 %9)
|
||||
%11 = load <4 x i32>, ptr %y, align 16
|
||||
%12 = load <4 x i32>, ptr %z, align 16
|
||||
%or = or <4 x i32> %11, %12
|
||||
store <4 x i32> %or, <4 x i32>* %w, align 16
|
||||
%13 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %or, ptr %w, align 16
|
||||
%13 = load <4 x i32>, ptr %w, align 16
|
||||
%14 = extractelement <4 x i32> %13, i64 0
|
||||
%15 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%15 = load <4 x i32>, ptr %w, align 16
|
||||
%16 = extractelement <4 x i32> %15, i64 1
|
||||
%17 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%17 = load <4 x i32>, ptr %w, align 16
|
||||
%18 = extractelement <4 x i32> %17, i64 2
|
||||
%19 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%19 = load <4 x i32>, ptr %w, align 16
|
||||
%20 = extractelement <4 x i32> %19, i64 3
|
||||
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i32 0, i32 0), i32 %14, i32 %16, i32 %18, i32 %20)
|
||||
%22 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%23 = load <4 x i32>, <4 x i32>* %z, align 16
|
||||
%21 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %14, i32 %16, i32 %18, i32 %20)
|
||||
%22 = load <4 x i32>, ptr %y, align 16
|
||||
%23 = load <4 x i32>, ptr %z, align 16
|
||||
%xor = xor <4 x i32> %22, %23
|
||||
store <4 x i32> %xor, <4 x i32>* %w, align 16
|
||||
%24 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %xor, ptr %w, align 16
|
||||
%24 = load <4 x i32>, ptr %w, align 16
|
||||
%25 = extractelement <4 x i32> %24, i64 0
|
||||
%26 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%26 = load <4 x i32>, ptr %w, align 16
|
||||
%27 = extractelement <4 x i32> %26, i64 1
|
||||
%28 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%28 = load <4 x i32>, ptr %w, align 16
|
||||
%29 = extractelement <4 x i32> %28, i64 2
|
||||
%30 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%30 = load <4 x i32>, ptr %w, align 16
|
||||
%31 = extractelement <4 x i32> %30, i64 3
|
||||
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i32 0, i32 0), i32 %25, i32 %27, i32 %29, i32 %31)
|
||||
%33 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%32 = call i32 (ptr, ...) @printf(ptr @.str.3, i32 %25, i32 %27, i32 %29, i32 %31)
|
||||
%33 = load <4 x i32>, ptr %y, align 16
|
||||
%bnot = xor <4 x i32> %33, <i32 -1, i32 -1, i32 -1, i32 -1>
|
||||
store <4 x i32> %bnot, <4 x i32>* %w, align 16
|
||||
%34 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %bnot, ptr %w, align 16
|
||||
%34 = load <4 x i32>, ptr %w, align 16
|
||||
%35 = extractelement <4 x i32> %34, i64 0
|
||||
%36 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%36 = load <4 x i32>, ptr %w, align 16
|
||||
%37 = extractelement <4 x i32> %36, i64 1
|
||||
%38 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%38 = load <4 x i32>, ptr %w, align 16
|
||||
%39 = extractelement <4 x i32> %38, i64 2
|
||||
%40 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%40 = load <4 x i32>, ptr %w, align 16
|
||||
%41 = extractelement <4 x i32> %40, i64 3
|
||||
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.4, i32 0, i32 0), i32 %35, i32 %37, i32 %39, i32 %41)
|
||||
%43 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%44 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%42 = call i32 (ptr, ...) @printf(ptr @.str.4, i32 %35, i32 %37, i32 %39, i32 %41)
|
||||
%43 = load <4 x i32>, ptr %y, align 16
|
||||
%44 = load <4 x i32>, ptr %y, align 16
|
||||
%neg = sub <4 x i32> zeroinitializer, %44
|
||||
store <4 x i32> %neg, <4 x i32>* %w, align 16
|
||||
%45 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %neg, ptr %w, align 16
|
||||
%45 = load <4 x i32>, ptr %w, align 16
|
||||
%46 = extractelement <4 x i32> %45, i64 0
|
||||
%47 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%47 = load <4 x i32>, ptr %w, align 16
|
||||
%48 = extractelement <4 x i32> %47, i64 1
|
||||
%49 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%49 = load <4 x i32>, ptr %w, align 16
|
||||
%50 = extractelement <4 x i32> %49, i64 2
|
||||
%51 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%51 = load <4 x i32>, ptr %w, align 16
|
||||
%52 = extractelement <4 x i32> %51, i64 3
|
||||
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i32 0, i32 0), i32 %46, i32 %48, i32 %50, i32 %52)
|
||||
%54 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%53 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %46, i32 %48, i32 %50, i32 %52)
|
||||
%54 = load <4 x i32>, ptr %y, align 16
|
||||
%not = icmp eq <4 x i32> %54, zeroinitializer
|
||||
%55 = sext <4 x i1> %not to <4 x i32>
|
||||
store <4 x i32> %55, <4 x i32>* %w, align 16
|
||||
store <4 x i32> <i32 -1, i32 13, i32 0, i32 0>, <4 x i32>* %w, align 16
|
||||
%56 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %55, ptr %w, align 16
|
||||
store <4 x i32> <i32 -1, i32 13, i32 0, i32 0>, ptr %w, align 16
|
||||
%56 = load <4 x i32>, ptr %w, align 16
|
||||
%not1 = icmp eq <4 x i32> %56, zeroinitializer
|
||||
%57 = sext <4 x i1> %not1 to <4 x i32>
|
||||
store <4 x i32> %57, <4 x i32>* %w, align 16
|
||||
%58 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
store <4 x i32> %57, ptr %w, align 16
|
||||
%58 = load <4 x i32>, ptr %w, align 16
|
||||
%59 = extractelement <4 x i32> %58, i64 0
|
||||
%60 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%60 = load <4 x i32>, ptr %w, align 16
|
||||
%61 = extractelement <4 x i32> %60, i64 1
|
||||
%62 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%62 = load <4 x i32>, ptr %w, align 16
|
||||
%63 = extractelement <4 x i32> %62, i64 2
|
||||
%64 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%64 = load <4 x i32>, ptr %w, align 16
|
||||
%65 = extractelement <4 x i32> %64, i64 3
|
||||
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i32 0, i32 0), i32 %59, i32 %61, i32 %63, i32 %65)
|
||||
%66 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %59, i32 %61, i32 %63, i32 %65)
|
||||
ret void
|
||||
}
|
||||
|
||||
@@ -42,73 +42,73 @@ define void @vector_incdec_testf() #0 {
|
||||
entry:
|
||||
%y = alloca <4 x float>, align 16
|
||||
%z = alloca <4 x float>, align 16
|
||||
store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, <4 x float>* %y, align 16
|
||||
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float -1.000000e+02>, <4 x float>* %z, align 16
|
||||
%0 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%1 = load <4 x float>, <4 x float>* %z, align 16
|
||||
store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, ptr %y, align 16
|
||||
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float -1.000000e+02>, ptr %z, align 16
|
||||
%0 = load <4 x float>, ptr %y, align 16
|
||||
%1 = load <4 x float>, ptr %z, align 16
|
||||
%fadd = fadd <4 x float> %0, %1
|
||||
store <4 x float> %fadd, <4 x float>* %y, align 16
|
||||
%2 = load <4 x float>, <4 x float>* %y, align 16
|
||||
store <4 x float> %fadd, ptr %y, align 16
|
||||
%2 = load <4 x float>, ptr %y, align 16
|
||||
%3 = extractelement <4 x float> %2, i64 0
|
||||
%fpfpext = fpext float %3 to double
|
||||
%4 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%4 = load <4 x float>, ptr %y, align 16
|
||||
%5 = extractelement <4 x float> %4, i64 1
|
||||
%fpfpext1 = fpext float %5 to double
|
||||
%6 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%6 = load <4 x float>, ptr %y, align 16
|
||||
%7 = extractelement <4 x float> %6, i64 2
|
||||
%fpfpext2 = fpext float %7 to double
|
||||
%8 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%8 = load <4 x float>, ptr %y, align 16
|
||||
%9 = extractelement <4 x float> %8, i64 3
|
||||
%fpfpext3 = fpext float %9 to double
|
||||
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i32 0, i32 0), double %fpfpext, double %fpfpext1, double %fpfpext2, double %fpfpext3)
|
||||
%11 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%10 = call i32 (ptr, ...) @printf(ptr @.str, double %fpfpext, double %fpfpext1, double %fpfpext2, double %fpfpext3)
|
||||
%11 = load <4 x float>, ptr %y, align 16
|
||||
%fincdec = fadd <4 x float> %11, <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>
|
||||
store <4 x float> %fincdec, <4 x float>* %y, align 16
|
||||
%12 = load <4 x float>, <4 x float>* %y, align 16
|
||||
store <4 x float> %fincdec, ptr %y, align 16
|
||||
%12 = load <4 x float>, ptr %y, align 16
|
||||
%13 = extractelement <4 x float> %12, i64 0
|
||||
%fpfpext4 = fpext float %13 to double
|
||||
%14 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%14 = load <4 x float>, ptr %y, align 16
|
||||
%15 = extractelement <4 x float> %14, i64 1
|
||||
%fpfpext5 = fpext float %15 to double
|
||||
%16 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%16 = load <4 x float>, ptr %y, align 16
|
||||
%17 = extractelement <4 x float> %16, i64 2
|
||||
%fpfpext6 = fpext float %17 to double
|
||||
%18 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%18 = load <4 x float>, ptr %y, align 16
|
||||
%19 = extractelement <4 x float> %18, i64 3
|
||||
%fpfpext7 = fpext float %19 to double
|
||||
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i32 0, i32 0), double %fpfpext4, double %fpfpext5, double %fpfpext6, double %fpfpext7)
|
||||
%21 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%20 = call i32 (ptr, ...) @printf(ptr @.str.1, double %fpfpext4, double %fpfpext5, double %fpfpext6, double %fpfpext7)
|
||||
%21 = load <4 x float>, ptr %y, align 16
|
||||
%fincdec8 = fadd <4 x float> %21, <float 1.000000e+00, float 1.000000e+00, float 1.000000e+00, float 1.000000e+00>
|
||||
store <4 x float> %fincdec8, <4 x float>* %y, align 16
|
||||
%22 = load <4 x float>, <4 x float>* %y, align 16
|
||||
store <4 x float> %fincdec8, ptr %y, align 16
|
||||
%22 = load <4 x float>, ptr %y, align 16
|
||||
%23 = extractelement <4 x float> %22, i64 0
|
||||
%fpfpext9 = fpext float %23 to double
|
||||
%24 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%24 = load <4 x float>, ptr %y, align 16
|
||||
%25 = extractelement <4 x float> %24, i64 1
|
||||
%fpfpext10 = fpext float %25 to double
|
||||
%26 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%26 = load <4 x float>, ptr %y, align 16
|
||||
%27 = extractelement <4 x float> %26, i64 2
|
||||
%fpfpext11 = fpext float %27 to double
|
||||
%28 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%28 = load <4 x float>, ptr %y, align 16
|
||||
%29 = extractelement <4 x float> %28, i64 3
|
||||
%fpfpext12 = fpext float %29 to double
|
||||
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i32 0, i32 0), double %fpfpext9, double %fpfpext10, double %fpfpext11, double %fpfpext12)
|
||||
%31 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%30 = call i32 (ptr, ...) @printf(ptr @.str.2, double %fpfpext9, double %fpfpext10, double %fpfpext11, double %fpfpext12)
|
||||
%31 = load <4 x float>, ptr %y, align 16
|
||||
%fincdec13 = fadd <4 x float> %31, <float -1.000000e+00, float -1.000000e+00, float -1.000000e+00, float -1.000000e+00>
|
||||
store <4 x float> %fincdec13, <4 x float>* %y, align 16
|
||||
%32 = load <4 x float>, <4 x float>* %y, align 16
|
||||
store <4 x float> %fincdec13, ptr %y, align 16
|
||||
%32 = load <4 x float>, ptr %y, align 16
|
||||
%33 = extractelement <4 x float> %32, i64 0
|
||||
%fpfpext14 = fpext float %33 to double
|
||||
%34 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%34 = load <4 x float>, ptr %y, align 16
|
||||
%35 = extractelement <4 x float> %34, i64 1
|
||||
%fpfpext15 = fpext float %35 to double
|
||||
%36 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%36 = load <4 x float>, ptr %y, align 16
|
||||
%37 = extractelement <4 x float> %36, i64 2
|
||||
%fpfpext16 = fpext float %37 to double
|
||||
%38 = load <4 x float>, <4 x float>* %y, align 16
|
||||
%38 = load <4 x float>, ptr %y, align 16
|
||||
%39 = extractelement <4 x float> %38, i64 3
|
||||
%fpfpext17 = fpext float %39 to double
|
||||
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i32 0, i32 0), double %fpfpext14, double %fpfpext15, double %fpfpext16, double %fpfpext17)
|
||||
%40 = call i32 (ptr, ...) @printf(ptr @.str.3, double %fpfpext14, double %fpfpext15, double %fpfpext16, double %fpfpext17)
|
||||
ret void
|
||||
}
|
||||
|
||||
@@ -118,67 +118,67 @@ entry:
|
||||
%y = alloca <4 x i32>, align 16
|
||||
%z = alloca <4 x i32>, align 16
|
||||
%w = alloca <4 x i32>, align 16
|
||||
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, <4 x i32>* %y, align 16
|
||||
store <4 x i32> <i32 2, i32 2, i32 2, i32 -100>, <4 x i32>* %z, align 16
|
||||
%0 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%1 = load <4 x i32>, <4 x i32>* %z, align 16
|
||||
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, ptr %y, align 16
|
||||
store <4 x i32> <i32 2, i32 2, i32 2, i32 -100>, ptr %z, align 16
|
||||
%0 = load <4 x i32>, ptr %y, align 16
|
||||
%1 = load <4 x i32>, ptr %z, align 16
|
||||
%add = add <4 x i32> %0, %1
|
||||
store <4 x i32> %add, <4 x i32>* %y, align 16
|
||||
%2 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
store <4 x i32> %add, ptr %y, align 16
|
||||
%2 = load <4 x i32>, ptr %y, align 16
|
||||
%3 = extractelement <4 x i32> %2, i64 0
|
||||
%4 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%4 = load <4 x i32>, ptr %y, align 16
|
||||
%5 = extractelement <4 x i32> %4, i64 1
|
||||
%6 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%6 = load <4 x i32>, ptr %y, align 16
|
||||
%7 = extractelement <4 x i32> %6, i64 2
|
||||
%8 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%8 = load <4 x i32>, ptr %y, align 16
|
||||
%9 = extractelement <4 x i32> %8, i64 3
|
||||
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i32 0, i32 0), i32 %3, i32 %5, i32 %7, i32 %9)
|
||||
%11 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%10 = call i32 (ptr, ...) @printf(ptr @.str.4, i32 %3, i32 %5, i32 %7, i32 %9)
|
||||
%11 = load <4 x i32>, ptr %y, align 16
|
||||
%add1 = add <4 x i32> %11, <i32 1, i32 1, i32 1, i32 1>
|
||||
store <4 x i32> %add1, <4 x i32>* %y, align 16
|
||||
%12 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
store <4 x i32> %add1, ptr %y, align 16
|
||||
%12 = load <4 x i32>, ptr %y, align 16
|
||||
%13 = extractelement <4 x i32> %12, i64 0
|
||||
%14 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%14 = load <4 x i32>, ptr %y, align 16
|
||||
%15 = extractelement <4 x i32> %14, i64 1
|
||||
%16 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%16 = load <4 x i32>, ptr %y, align 16
|
||||
%17 = extractelement <4 x i32> %16, i64 2
|
||||
%18 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%18 = load <4 x i32>, ptr %y, align 16
|
||||
%19 = extractelement <4 x i32> %18, i64 3
|
||||
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i32 0, i32 0), i32 %13, i32 %15, i32 %17, i32 %19)
|
||||
%21 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%20 = call i32 (ptr, ...) @printf(ptr @.str.5, i32 %13, i32 %15, i32 %17, i32 %19)
|
||||
%21 = load <4 x i32>, ptr %y, align 16
|
||||
%add2 = add <4 x i32> %21, <i32 1, i32 1, i32 1, i32 1>
|
||||
store <4 x i32> %add2, <4 x i32>* %y, align 16
|
||||
%22 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
store <4 x i32> %add2, ptr %y, align 16
|
||||
%22 = load <4 x i32>, ptr %y, align 16
|
||||
%23 = extractelement <4 x i32> %22, i64 0
|
||||
%24 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%24 = load <4 x i32>, ptr %y, align 16
|
||||
%25 = extractelement <4 x i32> %24, i64 1
|
||||
%26 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%26 = load <4 x i32>, ptr %y, align 16
|
||||
%27 = extractelement <4 x i32> %26, i64 2
|
||||
%28 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%28 = load <4 x i32>, ptr %y, align 16
|
||||
%29 = extractelement <4 x i32> %28, i64 3
|
||||
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i32 0, i32 0), i32 %23, i32 %25, i32 %27, i32 %29)
|
||||
%31 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%30 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %23, i32 %25, i32 %27, i32 %29)
|
||||
%31 = load <4 x i32>, ptr %y, align 16
|
||||
%sub = sub <4 x i32> %31, <i32 1, i32 1, i32 1, i32 1>
|
||||
store <4 x i32> %sub, <4 x i32>* %y, align 16
|
||||
store <4 x i32> %31, <4 x i32>* %w, align 16
|
||||
%32 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
store <4 x i32> %sub, ptr %y, align 16
|
||||
store <4 x i32> %31, ptr %w, align 16
|
||||
%32 = load <4 x i32>, ptr %y, align 16
|
||||
%33 = extractelement <4 x i32> %32, i64 0
|
||||
%34 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%34 = load <4 x i32>, ptr %y, align 16
|
||||
%35 = extractelement <4 x i32> %34, i64 1
|
||||
%36 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%36 = load <4 x i32>, ptr %y, align 16
|
||||
%37 = extractelement <4 x i32> %36, i64 2
|
||||
%38 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%38 = load <4 x i32>, ptr %y, align 16
|
||||
%39 = extractelement <4 x i32> %38, i64 3
|
||||
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.7, i32 0, i32 0), i32 %33, i32 %35, i32 %37, i32 %39)
|
||||
%41 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%40 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %33, i32 %35, i32 %37, i32 %39)
|
||||
%41 = load <4 x i32>, ptr %w, align 16
|
||||
%42 = extractelement <4 x i32> %41, i64 0
|
||||
%43 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%43 = load <4 x i32>, ptr %w, align 16
|
||||
%44 = extractelement <4 x i32> %43, i64 1
|
||||
%45 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%45 = load <4 x i32>, ptr %w, align 16
|
||||
%46 = extractelement <4 x i32> %45, i64 2
|
||||
%47 = load <4 x i32>, <4 x i32>* %w, align 16
|
||||
%47 = load <4 x i32>, ptr %w, align 16
|
||||
%48 = extractelement <4 x i32> %47, i64 3
|
||||
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.8, i32 0, i32 0), i32 %42, i32 %44, i32 %46, i32 %48)
|
||||
%49 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %42, i32 %44, i32 %46, i32 %48)
|
||||
ret void
|
||||
}
|
||||
|
||||
|
||||
@@ -25,29 +25,29 @@ entry:
|
||||
%bar2 = alloca <4 x i32>, align 16
|
||||
%bar3 = alloca <4 x i32>, align 16
|
||||
%bar4 = alloca <4 x i32>, align 16
|
||||
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, <4 x i32>* %foo, align 16
|
||||
%0 = load <4 x i32>, <4 x i32>* %foo, align 16
|
||||
store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, ptr %foo, align 16
|
||||
%0 = load <4 x i32>, ptr %foo, align 16
|
||||
%1 = extractelement <4 x i32> %0, i64 0
|
||||
store i32 %1, i32* %z, align 4
|
||||
%2 = load <4 x i32>, <4 x i32>* %foo, align 16
|
||||
%3 = load i32, i32* %z, align 4
|
||||
store i32 %1, ptr %z, align 4
|
||||
%2 = load <4 x i32>, ptr %foo, align 16
|
||||
%3 = load i32, ptr %z, align 4
|
||||
%add = add i32 %3, 1
|
||||
%elemset = insertelement <4 x i32> %2, i32 %add, i64 2
|
||||
store <4 x i32> %elemset, <4 x i32>* %foo, align 16
|
||||
store <4 x i32> zeroinitializer, <4 x i32>* %bar, align 16
|
||||
%4 = load i32, i32* %z, align 4
|
||||
store <4 x i32> %elemset, ptr %foo, align 16
|
||||
store <4 x i32> zeroinitializer, ptr %bar, align 16
|
||||
%4 = load i32, ptr %z, align 4
|
||||
%5 = insertelement <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>, i32 %4, i64 1
|
||||
%6 = insertelement <4 x i32> %5, i32 3, i64 2
|
||||
%7 = insertelement <4 x i32> %6, i32 4, i64 3
|
||||
store <4 x i32> %7, <4 x i32>* %bar2, align 16
|
||||
%8 = load i32, i32* %z, align 4
|
||||
store <4 x i32> %7, ptr %bar2, align 16
|
||||
%8 = load i32, ptr %z, align 4
|
||||
%9 = insertelement <4 x i32> zeroinitializer, i32 %8, i64 1
|
||||
store <4 x i32> %9, <4 x i32>* %bar3, align 16
|
||||
%10 = load i32, i32* %z, align 4
|
||||
store <4 x i32> %9, ptr %bar3, align 16
|
||||
%10 = load i32, ptr %z, align 4
|
||||
%11 = insertelement <4 x i32> zeroinitializer, i32 %10, i64 0
|
||||
%12 = insertelement <4 x i32> %11, i32 %10, i64 1
|
||||
%13 = insertelement <4 x i32> %12, i32 %10, i64 2
|
||||
%14 = insertelement <4 x i32> %13, i32 %10, i64 3
|
||||
store <4 x i32> %14, <4 x i32>* %bar4, align 16
|
||||
store <4 x i32> %14, ptr %bar4, align 16
|
||||
ret void
|
||||
}
|
||||
@@ -96,319 +96,318 @@ entry:
|
||||
%v = alloca <4 x float>, align 16
|
||||
%.anon85 = alloca i64, align 8
|
||||
%v89 = alloca <4 x float>, align 16
|
||||
store float 0x3FE921CAC0000000, float* %radians, align 4
|
||||
store <3 x float> <float 0.000000e+00, float 0.000000e+00, float 1.000000e+00>, <3 x float>* %axis, align 16
|
||||
%0 = load float, float* %radians, align 4
|
||||
store float 0x3FE921CAC0000000, ptr %radians, align 4
|
||||
store <3 x float> <float 0.000000e+00, float 0.000000e+00, float 1.000000e+00>, ptr %axis, align 16
|
||||
%0 = load float, ptr %radians, align 4
|
||||
%1 = call float @llvm.cos.f32(float %0)
|
||||
store float %1, float* %cosr, align 4
|
||||
%2 = load float, float* %radians, align 4
|
||||
store float %1, ptr %cosr, align 4
|
||||
%2 = load float, ptr %radians, align 4
|
||||
%3 = call float @llvm.sin.f32(float %2)
|
||||
store float %3, float* %sinr, align 4
|
||||
%4 = load <3 x float>, <3 x float>* %axis, align 16
|
||||
store float %3, ptr %sinr, align 4
|
||||
%4 = load <3 x float>, ptr %axis, align 16
|
||||
%5 = extractelement <3 x float> %4, i64 0
|
||||
store float %5, float* %x, align 4
|
||||
%6 = load <3 x float>, <3 x float>* %axis, align 16
|
||||
store float %5, ptr %x, align 4
|
||||
%6 = load <3 x float>, ptr %axis, align 16
|
||||
%7 = extractelement <3 x float> %6, i64 1
|
||||
store float %7, float* %y, align 4
|
||||
%8 = load <3 x float>, <3 x float>* %axis, align 16
|
||||
store float %7, ptr %y, align 4
|
||||
%8 = load <3 x float>, ptr %axis, align 16
|
||||
%9 = extractelement <3 x float> %8, i64 2
|
||||
store float %9, float* %z, align 4
|
||||
%10 = bitcast [4 x <4 x float>]* %a to i8*
|
||||
call void @llvm.memset.p0i8.i64(i8* align 16 %10, i8 0, i64 64, i1 false)
|
||||
%11 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %a, i64 0, i64 0
|
||||
%12 = load float, float* %cosr, align 4
|
||||
%13 = load float, float* %x, align 4
|
||||
%14 = load float, float* %x, align 4
|
||||
%fmul = fmul float %13, %14
|
||||
%15 = load float, float* %cosr, align 4
|
||||
%fpfpext = fpext float %15 to double
|
||||
store float %9, ptr %z, align 4
|
||||
call void @llvm.memset.p0.i64(ptr align 16 %a, i8 0, i64 64, i1 false)
|
||||
%10 = getelementptr inbounds [4 x <4 x float>], ptr %a, i64 0, i64 0
|
||||
%11 = load float, ptr %cosr, align 4
|
||||
%12 = load float, ptr %x, align 4
|
||||
%13 = load float, ptr %x, align 4
|
||||
%fmul = fmul float %12, %13
|
||||
%14 = load float, ptr %cosr, align 4
|
||||
%fpfpext = fpext float %14 to double
|
||||
%fsub = fsub double 1.000000e+00, %fpfpext
|
||||
%fpfptrunc = fptrunc double %fsub to float
|
||||
%16 = call float @llvm.fmuladd.f32(float %fmul, float %fpfptrunc, float %12)
|
||||
%17 = insertelement <4 x float> undef, float %16, i64 0
|
||||
%18 = load float, float* %x, align 4
|
||||
%19 = load float, float* %y, align 4
|
||||
%fmul1 = fmul float %18, %19
|
||||
%20 = load float, float* %cosr, align 4
|
||||
%fpfpext2 = fpext float %20 to double
|
||||
%15 = call float @llvm.fmuladd.f32(float %fmul, float %fpfptrunc, float %11)
|
||||
%16 = insertelement <4 x float> undef, float %15, i64 0
|
||||
%17 = load float, ptr %x, align 4
|
||||
%18 = load float, ptr %y, align 4
|
||||
%fmul1 = fmul float %17, %18
|
||||
%19 = load float, ptr %cosr, align 4
|
||||
%fpfpext2 = fpext float %19 to double
|
||||
%fsub3 = fsub double 1.000000e+00, %fpfpext2
|
||||
%fpfptrunc4 = fptrunc double %fsub3 to float
|
||||
%21 = load float, float* %z, align 4
|
||||
%22 = load float, float* %sinr, align 4
|
||||
%fmul5 = fmul float %21, %22
|
||||
%23 = fneg float %fmul5
|
||||
%24 = call float @llvm.fmuladd.f32(float %fmul1, float %fpfptrunc4, float %23)
|
||||
%25 = insertelement <4 x float> %17, float %24, i64 1
|
||||
%26 = load float, float* %x, align 4
|
||||
%27 = load float, float* %z, align 4
|
||||
%fmul6 = fmul float %26, %27
|
||||
%28 = load float, float* %cosr, align 4
|
||||
%fpfpext7 = fpext float %28 to double
|
||||
%20 = load float, ptr %z, align 4
|
||||
%21 = load float, ptr %sinr, align 4
|
||||
%fmul5 = fmul float %20, %21
|
||||
%22 = fneg float %fmul5
|
||||
%23 = call float @llvm.fmuladd.f32(float %fmul1, float %fpfptrunc4, float %22)
|
||||
%24 = insertelement <4 x float> %16, float %23, i64 1
|
||||
%25 = load float, ptr %x, align 4
|
||||
%26 = load float, ptr %z, align 4
|
||||
%fmul6 = fmul float %25, %26
|
||||
%27 = load float, ptr %cosr, align 4
|
||||
%fpfpext7 = fpext float %27 to double
|
||||
%fsub8 = fsub double 1.000000e+00, %fpfpext7
|
||||
%fpfptrunc9 = fptrunc double %fsub8 to float
|
||||
%29 = load float, float* %y, align 4
|
||||
%30 = load float, float* %sinr, align 4
|
||||
%fmul10 = fmul float %29, %30
|
||||
%31 = call float @llvm.fmuladd.f32(float %fmul6, float %fpfptrunc9, float %fmul10)
|
||||
%32 = insertelement <4 x float> %25, float %31, i64 2
|
||||
%33 = insertelement <4 x float> %32, float 0.000000e+00, i64 3
|
||||
store <4 x float> %33, <4 x float>* %11, align 16
|
||||
%34 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %a, i64 0, i64 1
|
||||
%35 = load float, float* %y, align 4
|
||||
%36 = load float, float* %x, align 4
|
||||
%fmul11 = fmul float %35, %36
|
||||
%37 = load float, float* %cosr, align 4
|
||||
%fpfpext12 = fpext float %37 to double
|
||||
%28 = load float, ptr %y, align 4
|
||||
%29 = load float, ptr %sinr, align 4
|
||||
%fmul10 = fmul float %28, %29
|
||||
%30 = call float @llvm.fmuladd.f32(float %fmul6, float %fpfptrunc9, float %fmul10)
|
||||
%31 = insertelement <4 x float> %24, float %30, i64 2
|
||||
%32 = insertelement <4 x float> %31, float 0.000000e+00, i64 3
|
||||
store <4 x float> %32, ptr %10, align 16
|
||||
%33 = getelementptr inbounds [4 x <4 x float>], ptr %a, i64 0, i64 1
|
||||
%34 = load float, ptr %y, align 4
|
||||
%35 = load float, ptr %x, align 4
|
||||
%fmul11 = fmul float %34, %35
|
||||
%36 = load float, ptr %cosr, align 4
|
||||
%fpfpext12 = fpext float %36 to double
|
||||
%fsub13 = fsub double 1.000000e+00, %fpfpext12
|
||||
%fpfptrunc14 = fptrunc double %fsub13 to float
|
||||
%38 = load float, float* %z, align 4
|
||||
%39 = load float, float* %sinr, align 4
|
||||
%fmul15 = fmul float %38, %39
|
||||
%40 = call float @llvm.fmuladd.f32(float %fmul11, float %fpfptrunc14, float %fmul15)
|
||||
%41 = insertelement <4 x float> undef, float %40, i64 0
|
||||
%42 = load float, float* %cosr, align 4
|
||||
%43 = load float, float* %y, align 4
|
||||
%44 = load float, float* %y, align 4
|
||||
%fmul16 = fmul float %43, %44
|
||||
%45 = load float, float* %cosr, align 4
|
||||
%fpfpext17 = fpext float %45 to double
|
||||
%37 = load float, ptr %z, align 4
|
||||
%38 = load float, ptr %sinr, align 4
|
||||
%fmul15 = fmul float %37, %38
|
||||
%39 = call float @llvm.fmuladd.f32(float %fmul11, float %fpfptrunc14, float %fmul15)
|
||||
%40 = insertelement <4 x float> undef, float %39, i64 0
|
||||
%41 = load float, ptr %cosr, align 4
|
||||
%42 = load float, ptr %y, align 4
|
||||
%43 = load float, ptr %y, align 4
|
||||
%fmul16 = fmul float %42, %43
|
||||
%44 = load float, ptr %cosr, align 4
|
||||
%fpfpext17 = fpext float %44 to double
|
||||
%fsub18 = fsub double 1.000000e+00, %fpfpext17
|
||||
%fpfptrunc19 = fptrunc double %fsub18 to float
|
||||
%46 = call float @llvm.fmuladd.f32(float %fmul16, float %fpfptrunc19, float %42)
|
||||
%47 = insertelement <4 x float> %41, float %46, i64 1
|
||||
%48 = load float, float* %y, align 4
|
||||
%49 = load float, float* %z, align 4
|
||||
%fmul20 = fmul float %48, %49
|
||||
%50 = load float, float* %cosr, align 4
|
||||
%fpfpext21 = fpext float %50 to double
|
||||
%45 = call float @llvm.fmuladd.f32(float %fmul16, float %fpfptrunc19, float %41)
|
||||
%46 = insertelement <4 x float> %40, float %45, i64 1
|
||||
%47 = load float, ptr %y, align 4
|
||||
%48 = load float, ptr %z, align 4
|
||||
%fmul20 = fmul float %47, %48
|
||||
%49 = load float, ptr %cosr, align 4
|
||||
%fpfpext21 = fpext float %49 to double
|
||||
%fsub22 = fsub double 1.000000e+00, %fpfpext21
|
||||
%fpfptrunc23 = fptrunc double %fsub22 to float
|
||||
%51 = load float, float* %x, align 4
|
||||
%52 = load float, float* %sinr, align 4
|
||||
%fmul24 = fmul float %51, %52
|
||||
%53 = fneg float %fmul24
|
||||
%54 = call float @llvm.fmuladd.f32(float %fmul20, float %fpfptrunc23, float %53)
|
||||
%55 = insertelement <4 x float> %47, float %54, i64 2
|
||||
%56 = insertelement <4 x float> %55, float 0.000000e+00, i64 3
|
||||
store <4 x float> %56, <4 x float>* %34, align 16
|
||||
%57 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %a, i64 0, i64 2
|
||||
%58 = load float, float* %z, align 4
|
||||
%59 = load float, float* %x, align 4
|
||||
%fmul25 = fmul float %58, %59
|
||||
%60 = load float, float* %cosr, align 4
|
||||
%fpfpext26 = fpext float %60 to double
|
||||
%50 = load float, ptr %x, align 4
|
||||
%51 = load float, ptr %sinr, align 4
|
||||
%fmul24 = fmul float %50, %51
|
||||
%52 = fneg float %fmul24
|
||||
%53 = call float @llvm.fmuladd.f32(float %fmul20, float %fpfptrunc23, float %52)
|
||||
%54 = insertelement <4 x float> %46, float %53, i64 2
|
||||
%55 = insertelement <4 x float> %54, float 0.000000e+00, i64 3
|
||||
store <4 x float> %55, ptr %33, align 16
|
||||
%56 = getelementptr inbounds [4 x <4 x float>], ptr %a, i64 0, i64 2
|
||||
%57 = load float, ptr %z, align 4
|
||||
%58 = load float, ptr %x, align 4
|
||||
%fmul25 = fmul float %57, %58
|
||||
%59 = load float, ptr %cosr, align 4
|
||||
%fpfpext26 = fpext float %59 to double
|
||||
%fsub27 = fsub double 1.000000e+00, %fpfpext26
|
||||
%fpfptrunc28 = fptrunc double %fsub27 to float
|
||||
%61 = load float, float* %y, align 4
|
||||
%62 = load float, float* %sinr, align 4
|
||||
%fmul29 = fmul float %61, %62
|
||||
%63 = fneg float %fmul29
|
||||
%64 = call float @llvm.fmuladd.f32(float %fmul25, float %fpfptrunc28, float %63)
|
||||
%65 = insertelement <4 x float> undef, float %64, i64 0
|
||||
%66 = load float, float* %z, align 4
|
||||
%67 = load float, float* %y, align 4
|
||||
%fmul30 = fmul float %66, %67
|
||||
%68 = load float, float* %cosr, align 4
|
||||
%fpfpext31 = fpext float %68 to double
|
||||
%60 = load float, ptr %y, align 4
|
||||
%61 = load float, ptr %sinr, align 4
|
||||
%fmul29 = fmul float %60, %61
|
||||
%62 = fneg float %fmul29
|
||||
%63 = call float @llvm.fmuladd.f32(float %fmul25, float %fpfptrunc28, float %62)
|
||||
%64 = insertelement <4 x float> undef, float %63, i64 0
|
||||
%65 = load float, ptr %z, align 4
|
||||
%66 = load float, ptr %y, align 4
|
||||
%fmul30 = fmul float %65, %66
|
||||
%67 = load float, ptr %cosr, align 4
|
||||
%fpfpext31 = fpext float %67 to double
|
||||
%fsub32 = fsub double 1.000000e+00, %fpfpext31
|
||||
%fpfptrunc33 = fptrunc double %fsub32 to float
|
||||
%69 = load float, float* %x, align 4
|
||||
%70 = load float, float* %sinr, align 4
|
||||
%fmul34 = fmul float %69, %70
|
||||
%71 = call float @llvm.fmuladd.f32(float %fmul30, float %fpfptrunc33, float %fmul34)
|
||||
%72 = insertelement <4 x float> %65, float %71, i64 1
|
||||
%73 = load float, float* %cosr, align 4
|
||||
%74 = load float, float* %z, align 4
|
||||
%75 = load float, float* %z, align 4
|
||||
%fmul35 = fmul float %74, %75
|
||||
%76 = load float, float* %cosr, align 4
|
||||
%fpfpext36 = fpext float %76 to double
|
||||
%68 = load float, ptr %x, align 4
|
||||
%69 = load float, ptr %sinr, align 4
|
||||
%fmul34 = fmul float %68, %69
|
||||
%70 = call float @llvm.fmuladd.f32(float %fmul30, float %fpfptrunc33, float %fmul34)
|
||||
%71 = insertelement <4 x float> %64, float %70, i64 1
|
||||
%72 = load float, ptr %cosr, align 4
|
||||
%73 = load float, ptr %z, align 4
|
||||
%74 = load float, ptr %z, align 4
|
||||
%fmul35 = fmul float %73, %74
|
||||
%75 = load float, ptr %cosr, align 4
|
||||
%fpfpext36 = fpext float %75 to double
|
||||
%fsub37 = fsub double 1.000000e+00, %fpfpext36
|
||||
%fpfptrunc38 = fptrunc double %fsub37 to float
|
||||
%77 = call float @llvm.fmuladd.f32(float %fmul35, float %fpfptrunc38, float %73)
|
||||
%78 = insertelement <4 x float> %72, float %77, i64 2
|
||||
%79 = insertelement <4 x float> %78, float 0.000000e+00, i64 3
|
||||
store <4 x float> %79, <4 x float>* %57, align 16
|
||||
%80 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %a, i64 0, i64 3
|
||||
store <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 1.000000e+00>, <4 x float>* %80, align 16
|
||||
%81 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %b, i64 0, i64 0
|
||||
%82 = load float, float* %cosr, align 4
|
||||
%83 = load float, float* %x, align 4
|
||||
%84 = load float, float* %x, align 4
|
||||
%fmul39 = fmul float %83, %84
|
||||
%85 = load float, float* %cosr, align 4
|
||||
%fpfpext40 = fpext float %85 to double
|
||||
%76 = call float @llvm.fmuladd.f32(float %fmul35, float %fpfptrunc38, float %72)
|
||||
%77 = insertelement <4 x float> %71, float %76, i64 2
|
||||
%78 = insertelement <4 x float> %77, float 0.000000e+00, i64 3
|
||||
store <4 x float> %78, ptr %56, align 16
|
||||
%79 = getelementptr inbounds [4 x <4 x float>], ptr %a, i64 0, i64 3
|
||||
store <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 1.000000e+00>, ptr %79, align 16
|
||||
%80 = getelementptr inbounds [4 x <4 x float>], ptr %b, i64 0, i64 0
|
||||
%81 = load float, ptr %cosr, align 4
|
||||
%82 = load float, ptr %x, align 4
|
||||
%83 = load float, ptr %x, align 4
|
||||
%fmul39 = fmul float %82, %83
|
||||
%84 = load float, ptr %cosr, align 4
|
||||
%fpfpext40 = fpext float %84 to double
|
||||
%fsub41 = fsub double 1.000000e+00, %fpfpext40
|
||||
%fpfptrunc42 = fptrunc double %fsub41 to float
|
||||
%86 = call float @llvm.fmuladd.f32(float %fmul39, float %fpfptrunc42, float %82)
|
||||
%87 = insertelement <4 x float> undef, float %86, i64 0
|
||||
%88 = load float, float* %x, align 4
|
||||
%89 = load float, float* %y, align 4
|
||||
%fmul43 = fmul float %88, %89
|
||||
%90 = load float, float* %cosr, align 4
|
||||
%fpfpext44 = fpext float %90 to double
|
||||
%85 = call float @llvm.fmuladd.f32(float %fmul39, float %fpfptrunc42, float %81)
|
||||
%86 = insertelement <4 x float> undef, float %85, i64 0
|
||||
%87 = load float, ptr %x, align 4
|
||||
%88 = load float, ptr %y, align 4
|
||||
%fmul43 = fmul float %87, %88
|
||||
%89 = load float, ptr %cosr, align 4
|
||||
%fpfpext44 = fpext float %89 to double
|
||||
%fsub45 = fsub double 1.000000e+00, %fpfpext44
|
||||
%fpfptrunc46 = fptrunc double %fsub45 to float
|
||||
%91 = load float, float* %z, align 4
|
||||
%92 = load float, float* %sinr, align 4
|
||||
%fmul47 = fmul float %91, %92
|
||||
%93 = fneg float %fmul47
|
||||
%94 = call float @llvm.fmuladd.f32(float %fmul43, float %fpfptrunc46, float %93)
|
||||
%95 = insertelement <4 x float> %87, float %94, i64 1
|
||||
%96 = load float, float* %x, align 4
|
||||
%97 = load float, float* %z, align 4
|
||||
%fmul48 = fmul float %96, %97
|
||||
%98 = load float, float* %cosr, align 4
|
||||
%fpfpext49 = fpext float %98 to double
|
||||
%90 = load float, ptr %z, align 4
|
||||
%91 = load float, ptr %sinr, align 4
|
||||
%fmul47 = fmul float %90, %91
|
||||
%92 = fneg float %fmul47
|
||||
%93 = call float @llvm.fmuladd.f32(float %fmul43, float %fpfptrunc46, float %92)
|
||||
%94 = insertelement <4 x float> %86, float %93, i64 1
|
||||
%95 = load float, ptr %x, align 4
|
||||
%96 = load float, ptr %z, align 4
|
||||
%fmul48 = fmul float %95, %96
|
||||
%97 = load float, ptr %cosr, align 4
|
||||
%fpfpext49 = fpext float %97 to double
|
||||
%fsub50 = fsub double 1.000000e+00, %fpfpext49
|
||||
%fpfptrunc51 = fptrunc double %fsub50 to float
|
||||
%99 = load float, float* %y, align 4
|
||||
%100 = load float, float* %sinr, align 4
|
||||
%fmul52 = fmul float %99, %100
|
||||
%101 = call float @llvm.fmuladd.f32(float %fmul48, float %fpfptrunc51, float %fmul52)
|
||||
%102 = insertelement <4 x float> %95, float %101, i64 2
|
||||
%103 = insertelement <4 x float> %102, float 0.000000e+00, i64 3
|
||||
store <4 x float> %103, <4 x float>* %81, align 16
|
||||
%104 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %b, i64 0, i64 1
|
||||
%105 = load float, float* %y, align 4
|
||||
%106 = load float, float* %x, align 4
|
||||
%fmul53 = fmul float %105, %106
|
||||
%107 = load float, float* %cosr, align 4
|
||||
%fpfpext54 = fpext float %107 to double
|
||||
%98 = load float, ptr %y, align 4
|
||||
%99 = load float, ptr %sinr, align 4
|
||||
%fmul52 = fmul float %98, %99
|
||||
%100 = call float @llvm.fmuladd.f32(float %fmul48, float %fpfptrunc51, float %fmul52)
|
||||
%101 = insertelement <4 x float> %94, float %100, i64 2
|
||||
%102 = insertelement <4 x float> %101, float 0.000000e+00, i64 3
|
||||
store <4 x float> %102, ptr %80, align 16
|
||||
%103 = getelementptr inbounds [4 x <4 x float>], ptr %b, i64 0, i64 1
|
||||
%104 = load float, ptr %y, align 4
|
||||
%105 = load float, ptr %x, align 4
|
||||
%fmul53 = fmul float %104, %105
|
||||
%106 = load float, ptr %cosr, align 4
|
||||
%fpfpext54 = fpext float %106 to double
|
||||
%fsub55 = fsub double 1.000000e+00, %fpfpext54
|
||||
%fpfptrunc56 = fptrunc double %fsub55 to float
|
||||
%108 = load float, float* %z, align 4
|
||||
%109 = load float, float* %sinr, align 4
|
||||
%fmul57 = fmul float %108, %109
|
||||
%110 = call float @llvm.fmuladd.f32(float %fmul53, float %fpfptrunc56, float %fmul57)
|
||||
%111 = insertelement <4 x float> undef, float %110, i64 0
|
||||
%112 = load float, float* %cosr, align 4
|
||||
%113 = load float, float* %y, align 4
|
||||
%114 = load float, float* %y, align 4
|
||||
%fmul58 = fmul float %113, %114
|
||||
%115 = load float, float* %cosr, align 4
|
||||
%fpfpext59 = fpext float %115 to double
|
||||
%107 = load float, ptr %z, align 4
|
||||
%108 = load float, ptr %sinr, align 4
|
||||
%fmul57 = fmul float %107, %108
|
||||
%109 = call float @llvm.fmuladd.f32(float %fmul53, float %fpfptrunc56, float %fmul57)
|
||||
%110 = insertelement <4 x float> undef, float %109, i64 0
|
||||
%111 = load float, ptr %cosr, align 4
|
||||
%112 = load float, ptr %y, align 4
|
||||
%113 = load float, ptr %y, align 4
|
||||
%fmul58 = fmul float %112, %113
|
||||
%114 = load float, ptr %cosr, align 4
|
||||
%fpfpext59 = fpext float %114 to double
|
||||
%fsub60 = fsub double 1.000000e+00, %fpfpext59
|
||||
%fpfptrunc61 = fptrunc double %fsub60 to float
|
||||
%116 = call float @llvm.fmuladd.f32(float %fmul58, float %fpfptrunc61, float %112)
|
||||
%117 = insertelement <4 x float> %111, float %116, i64 1
|
||||
%118 = load float, float* %y, align 4
|
||||
%119 = load float, float* %z, align 4
|
||||
%fmul62 = fmul float %118, %119
|
||||
%120 = load float, float* %cosr, align 4
|
||||
%fpfpext63 = fpext float %120 to double
|
||||
%115 = call float @llvm.fmuladd.f32(float %fmul58, float %fpfptrunc61, float %111)
|
||||
%116 = insertelement <4 x float> %110, float %115, i64 1
|
||||
%117 = load float, ptr %y, align 4
|
||||
%118 = load float, ptr %z, align 4
|
||||
%fmul62 = fmul float %117, %118
|
||||
%119 = load float, ptr %cosr, align 4
|
||||
%fpfpext63 = fpext float %119 to double
|
||||
%fsub64 = fsub double 1.000000e+00, %fpfpext63
|
||||
%fpfptrunc65 = fptrunc double %fsub64 to float
|
||||
%121 = load float, float* %x, align 4
|
||||
%122 = load float, float* %sinr, align 4
|
||||
%fmul66 = fmul float %121, %122
|
||||
%123 = fneg float %fmul66
|
||||
%124 = call float @llvm.fmuladd.f32(float %fmul62, float %fpfptrunc65, float %123)
|
||||
%125 = insertelement <4 x float> %117, float %124, i64 2
|
||||
%126 = insertelement <4 x float> %125, float 0.000000e+00, i64 3
|
||||
store <4 x float> %126, <4 x float>* %104, align 16
|
||||
%127 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %b, i64 0, i64 2
|
||||
%128 = load float, float* %z, align 4
|
||||
%129 = load float, float* %x, align 4
|
||||
%fmul67 = fmul float %128, %129
|
||||
%130 = load float, float* %cosr, align 4
|
||||
%fpfpext68 = fpext float %130 to double
|
||||
%120 = load float, ptr %x, align 4
|
||||
%121 = load float, ptr %sinr, align 4
|
||||
%fmul66 = fmul float %120, %121
|
||||
%122 = fneg float %fmul66
|
||||
%123 = call float @llvm.fmuladd.f32(float %fmul62, float %fpfptrunc65, float %122)
|
||||
%124 = insertelement <4 x float> %116, float %123, i64 2
|
||||
%125 = insertelement <4 x float> %124, float 0.000000e+00, i64 3
|
||||
store <4 x float> %125, ptr %103, align 16
|
||||
%126 = getelementptr inbounds [4 x <4 x float>], ptr %b, i64 0, i64 2
|
||||
%127 = load float, ptr %z, align 4
|
||||
%128 = load float, ptr %x, align 4
|
||||
%fmul67 = fmul float %127, %128
|
||||
%129 = load float, ptr %cosr, align 4
|
||||
%fpfpext68 = fpext float %129 to double
|
||||
%fsub69 = fsub double 1.000000e+00, %fpfpext68
|
||||
%fpfptrunc70 = fptrunc double %fsub69 to float
|
||||
%131 = load float, float* %y, align 4
|
||||
%132 = load float, float* %sinr, align 4
|
||||
%fmul71 = fmul float %131, %132
|
||||
%133 = fneg float %fmul71
|
||||
%134 = call float @llvm.fmuladd.f32(float %fmul67, float %fpfptrunc70, float %133)
|
||||
%135 = insertelement <4 x float> undef, float %134, i64 0
|
||||
%136 = load float, float* %z, align 4
|
||||
%137 = load float, float* %y, align 4
|
||||
%fmul72 = fmul float %136, %137
|
||||
%138 = load float, float* %cosr, align 4
|
||||
%fpfpext73 = fpext float %138 to double
|
||||
%130 = load float, ptr %y, align 4
|
||||
%131 = load float, ptr %sinr, align 4
|
||||
%fmul71 = fmul float %130, %131
|
||||
%132 = fneg float %fmul71
|
||||
%133 = call float @llvm.fmuladd.f32(float %fmul67, float %fpfptrunc70, float %132)
|
||||
%134 = insertelement <4 x float> undef, float %133, i64 0
|
||||
%135 = load float, ptr %z, align 4
|
||||
%136 = load float, ptr %y, align 4
|
||||
%fmul72 = fmul float %135, %136
|
||||
%137 = load float, ptr %cosr, align 4
|
||||
%fpfpext73 = fpext float %137 to double
|
||||
%fsub74 = fsub double 1.000000e+00, %fpfpext73
|
||||
%fpfptrunc75 = fptrunc double %fsub74 to float
|
||||
%139 = load float, float* %x, align 4
|
||||
%140 = load float, float* %sinr, align 4
|
||||
%fmul76 = fmul float %139, %140
|
||||
%141 = call float @llvm.fmuladd.f32(float %fmul72, float %fpfptrunc75, float %fmul76)
|
||||
%142 = insertelement <4 x float> %135, float %141, i64 1
|
||||
%143 = load float, float* %cosr, align 4
|
||||
%144 = load float, float* %z, align 4
|
||||
%145 = load float, float* %z, align 4
|
||||
%fmul77 = fmul float %144, %145
|
||||
%146 = load float, float* %cosr, align 4
|
||||
%fpfpext78 = fpext float %146 to double
|
||||
%138 = load float, ptr %x, align 4
|
||||
%139 = load float, ptr %sinr, align 4
|
||||
%fmul76 = fmul float %138, %139
|
||||
%140 = call float @llvm.fmuladd.f32(float %fmul72, float %fpfptrunc75, float %fmul76)
|
||||
%141 = insertelement <4 x float> %134, float %140, i64 1
|
||||
%142 = load float, ptr %cosr, align 4
|
||||
%143 = load float, ptr %z, align 4
|
||||
%144 = load float, ptr %z, align 4
|
||||
%fmul77 = fmul float %143, %144
|
||||
%145 = load float, ptr %cosr, align 4
|
||||
%fpfpext78 = fpext float %145 to double
|
||||
%fsub79 = fsub double 1.000000e+00, %fpfpext78
|
||||
%fpfptrunc80 = fptrunc double %fsub79 to float
|
||||
%147 = call float @llvm.fmuladd.f32(float %fmul77, float %fpfptrunc80, float %143)
|
||||
%148 = insertelement <4 x float> %142, float %147, i64 2
|
||||
%149 = insertelement <4 x float> %148, float 0.000000e+00, i64 3
|
||||
store <4 x float> %149, <4 x float>* %127, align 16
|
||||
%150 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %b, i64 0, i64 3
|
||||
store <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 1.000000e+00>, <4 x float>* %150, align 16
|
||||
store i64 0, i64* %.anon, align 8
|
||||
%146 = call float @llvm.fmuladd.f32(float %fmul77, float %fpfptrunc80, float %142)
|
||||
%147 = insertelement <4 x float> %141, float %146, i64 2
|
||||
%148 = insertelement <4 x float> %147, float 0.000000e+00, i64 3
|
||||
store <4 x float> %148, ptr %126, align 16
|
||||
%149 = getelementptr inbounds [4 x <4 x float>], ptr %b, i64 0, i64 3
|
||||
store <4 x float> <float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 1.000000e+00>, ptr %149, align 16
|
||||
store i64 0, ptr %.anon, align 8
|
||||
br label %loop.cond
|
||||
|
||||
loop.cond: ; preds = %loop.body, %entry
|
||||
%151 = load i64, i64* %.anon, align 8
|
||||
%gt = icmp ugt i64 4, %151
|
||||
%150 = load i64, ptr %.anon, align 8
|
||||
%gt = icmp ugt i64 4, %150
|
||||
br i1 %gt, label %loop.body, label %loop.exit
|
||||
|
||||
loop.body: ; preds = %loop.cond
|
||||
%152 = load i64, i64* %.anon, align 8
|
||||
%153 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %a, i64 0, i64 %152
|
||||
%154 = load <4 x float>, <4 x float>* %153, align 16
|
||||
store <4 x float> %154, <4 x float>* %v, align 16
|
||||
%155 = load <4 x float>, <4 x float>* %v, align 16
|
||||
%156 = extractelement <4 x float> %155, i64 0
|
||||
%fpfpext81 = fpext float %156 to double
|
||||
%157 = load <4 x float>, <4 x float>* %v, align 16
|
||||
%158 = extractelement <4 x float> %157, i64 1
|
||||
%fpfpext82 = fpext float %158 to double
|
||||
%159 = load <4 x float>, <4 x float>* %v, align 16
|
||||
%160 = extractelement <4 x float> %159, i64 2
|
||||
%fpfpext83 = fpext float %160 to double
|
||||
%161 = load <4 x float>, <4 x float>* %v, align 16
|
||||
%162 = extractelement <4 x float> %161, i64 3
|
||||
%fpfpext84 = fpext float %162 to double
|
||||
%163 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str, i32 0, i32 0), double %fpfpext81, double %fpfpext82, double %fpfpext83, double %fpfpext84)
|
||||
%164 = load i64, i64* %.anon, align 8
|
||||
%add = add i64 %164, 1
|
||||
store i64 %add, i64* %.anon, align 8
|
||||
%151 = load i64, ptr %.anon, align 8
|
||||
%152 = getelementptr inbounds [4 x <4 x float>], ptr %a, i64 0, i64 %151
|
||||
%153 = load <4 x float>, ptr %152, align 16
|
||||
store <4 x float> %153, ptr %v, align 16
|
||||
%154 = load <4 x float>, ptr %v, align 16
|
||||
%155 = extractelement <4 x float> %154, i64 0
|
||||
%fpfpext81 = fpext float %155 to double
|
||||
%156 = load <4 x float>, ptr %v, align 16
|
||||
%157 = extractelement <4 x float> %156, i64 1
|
||||
%fpfpext82 = fpext float %157 to double
|
||||
%158 = load <4 x float>, ptr %v, align 16
|
||||
%159 = extractelement <4 x float> %158, i64 2
|
||||
%fpfpext83 = fpext float %159 to double
|
||||
%160 = load <4 x float>, ptr %v, align 16
|
||||
%161 = extractelement <4 x float> %160, i64 3
|
||||
%fpfpext84 = fpext float %161 to double
|
||||
%162 = call i32 (ptr, ...) @printf(ptr @.str, double %fpfpext81, double %fpfpext82, double %fpfpext83, double %fpfpext84)
|
||||
%163 = load i64, ptr %.anon, align 8
|
||||
%add = add i64 %163, 1
|
||||
store i64 %add, ptr %.anon, align 8
|
||||
br label %loop.cond
|
||||
|
||||
loop.exit: ; preds = %loop.cond
|
||||
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0))
|
||||
store i64 0, i64* %.anon85, align 8
|
||||
%164 = call i32 (ptr, ...) @printf(ptr @.str.1)
|
||||
store i64 0, ptr %.anon85, align 8
|
||||
br label %loop.cond86
|
||||
|
||||
loop.cond86: ; preds = %loop.body88, %loop.exit
|
||||
%166 = load i64, i64* %.anon85, align 8
|
||||
%gt87 = icmp ugt i64 4, %166
|
||||
%165 = load i64, ptr %.anon85, align 8
|
||||
%gt87 = icmp ugt i64 4, %165
|
||||
br i1 %gt87, label %loop.body88, label %loop.exit95
|
||||
|
||||
loop.body88: ; preds = %loop.cond86
|
||||
%167 = load i64, i64* %.anon85, align 8
|
||||
%168 = getelementptr inbounds [4 x <4 x float>], [4 x <4 x float>]* %b, i64 0, i64 %167
|
||||
%169 = load <4 x float>, <4 x float>* %168, align 16
|
||||
store <4 x float> %169, <4 x float>* %v89, align 16
|
||||
%170 = load <4 x float>, <4 x float>* %v89, align 16
|
||||
%171 = extractelement <4 x float> %170, i64 0
|
||||
%fpfpext90 = fpext float %171 to double
|
||||
%172 = load <4 x float>, <4 x float>* %v89, align 16
|
||||
%173 = extractelement <4 x float> %172, i64 1
|
||||
%fpfpext91 = fpext float %173 to double
|
||||
%174 = load <4 x float>, <4 x float>* %v89, align 16
|
||||
%175 = extractelement <4 x float> %174, i64 2
|
||||
%fpfpext92 = fpext float %175 to double
|
||||
%176 = load <4 x float>, <4 x float>* %v89, align 16
|
||||
%177 = extractelement <4 x float> %176, i64 3
|
||||
%fpfpext93 = fpext float %177 to double
|
||||
%178 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i32 0, i32 0), double %fpfpext90, double %fpfpext91, double %fpfpext92, double %fpfpext93)
|
||||
%179 = load i64, i64* %.anon85, align 8
|
||||
%add94 = add i64 %179, 1
|
||||
store i64 %add94, i64* %.anon85, align 8
|
||||
%166 = load i64, ptr %.anon85, align 8
|
||||
%167 = getelementptr inbounds [4 x <4 x float>], ptr %b, i64 0, i64 %166
|
||||
%168 = load <4 x float>, ptr %167, align 16
|
||||
store <4 x float> %168, ptr %v89, align 16
|
||||
%169 = load <4 x float>, ptr %v89, align 16
|
||||
%170 = extractelement <4 x float> %169, i64 0
|
||||
%fpfpext90 = fpext float %170 to double
|
||||
%171 = load <4 x float>, ptr %v89, align 16
|
||||
%172 = extractelement <4 x float> %171, i64 1
|
||||
%fpfpext91 = fpext float %172 to double
|
||||
%173 = load <4 x float>, ptr %v89, align 16
|
||||
%174 = extractelement <4 x float> %173, i64 2
|
||||
%fpfpext92 = fpext float %174 to double
|
||||
%175 = load <4 x float>, ptr %v89, align 16
|
||||
%176 = extractelement <4 x float> %175, i64 3
|
||||
%fpfpext93 = fpext float %176 to double
|
||||
%177 = call i32 (ptr, ...) @printf(ptr @.str.2, double %fpfpext90, double %fpfpext91, double %fpfpext92, double %fpfpext93)
|
||||
%178 = load i64, ptr %.anon85, align 8
|
||||
%add94 = add i64 %178, 1
|
||||
store i64 %add94, ptr %.anon85, align 8
|
||||
br label %loop.cond86
|
||||
|
||||
loop.exit95: ; preds = %loop.cond86
|
||||
|
||||
@@ -23,82 +23,32 @@ fn void testi()
|
||||
|
||||
/* #expect: test.ll
|
||||
|
||||
; Function Attrs: nounwind
|
||||
define void @test_testf() #0 {
|
||||
entry:
|
||||
%y = alloca <4 x float>, align 16
|
||||
%z = alloca <4 x float>, align 16
|
||||
%w = alloca <4 x float>, align 16
|
||||
store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, ptr %y, align 16
|
||||
store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float -1.000000e+02>, ptr %z, align 16
|
||||
%0 = load <4 x float>, ptr %y, align 16
|
||||
%1 = load <4 x float>, ptr %z, align 16
|
||||
%fadd = fadd <4 x float> %0, %1
|
||||
store <4 x float> %fadd, ptr %w, align 16
|
||||
%2 = load <4 x float>, ptr %y, align 16
|
||||
%3 = load <4 x float>, ptr %z, align 16
|
||||
%4 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %3)
|
||||
%5 = call float @llvm.vector.reduce.fmin.v4f32(<4 x float> %4)
|
||||
%zero = fcmp ueq float %5, 0.000000e+00
|
||||
br i1 %zero, label %panic, label %checkok
|
||||
|
||||
panic: ; preds = %entry
|
||||
%6 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8
|
||||
call void %6(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.panic_msg, i64 0, i64 0), i64 17, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func, i64 0, i64 0), i64 5, i32 9)
|
||||
%6 = load ptr, ptr @std_core_builtin_panic, align 8
|
||||
call void %6(ptr @.panic_msg, i64 17, ptr @.file, i64 14, ptr @.func, i64 5, i32 9)
|
||||
br label %checkok
|
||||
|
||||
checkok: ; preds = %panic, %entry
|
||||
%fdiv = fdiv <4 x float> %2, %3
|
||||
store <4 x float> %fdiv, <4 x float>* %w, align 16
|
||||
|
||||
%2 = call i32 @llvm.vector.reduce.umin.v4i32(<4 x i32> %1)
|
||||
%zero = icmp eq i32 %2, 0
|
||||
br i1 %zero, label %panic, label %checkok
|
||||
|
||||
panic: ; preds = %entry
|
||||
%3 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8
|
||||
call void %3(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.panic_msg.1, i64 0, i64 0), i64 17, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.2, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.3, i64 0, i64 0), i64 5, i32 17)
|
||||
br label %checkok
|
||||
|
||||
checkok: ; preds = %panic, %entry
|
||||
%sdiv = sdiv <4 x i32> %0, %1
|
||||
store <4 x i32> %sdiv, <4 x i32>* %w, align 16
|
||||
%4 = load <4 x i32>, <4 x i32>* %z, align 16
|
||||
%5 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%6 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %5)
|
||||
%shift_underflow = icmp slt i32 %6, 0
|
||||
br i1 %shift_underflow, label %panic1, label %checkok2
|
||||
|
||||
panic1: ; preds = %checkok
|
||||
%7 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8
|
||||
call void %7(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.4, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.5, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.6, i64 0, i64 0), i64 5, i32 18)
|
||||
br label %checkok2
|
||||
|
||||
checkok2: ; preds = %panic1, %checkok
|
||||
%8 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %5)
|
||||
%shift_exceeds = icmp sge i32 %8, 32
|
||||
br i1 %shift_exceeds, label %panic3, label %checkok4
|
||||
|
||||
panic3: ; preds = %checkok2
|
||||
%9 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8
|
||||
call void %9(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.7, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.8, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.9, i64 0, i64 0), i64 5, i32 18)
|
||||
br label %checkok4
|
||||
|
||||
checkok4: ; preds = %panic3, %checkok2
|
||||
%ashr = ashr <4 x i32> %4, %5
|
||||
%10 = freeze <4 x i32> %ashr
|
||||
store <4 x i32> %10, <4 x i32>* %w, align 16
|
||||
%11 = load <4 x i32>, <4 x i32>* %z, align 16
|
||||
%12 = load <4 x i32>, <4 x i32>* %y, align 16
|
||||
%13 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %12)
|
||||
%shift_underflow5 = icmp slt i32 %13, 0
|
||||
br i1 %shift_underflow5, label %panic6, label %checkok7
|
||||
|
||||
panic6: ; preds = %checkok4
|
||||
%14 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8
|
||||
call void %14(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.10, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.11, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.12, i64 0, i64 0), i64 5, i32 19)
|
||||
br label %checkok7
|
||||
|
||||
checkok7: ; preds = %panic6, %checkok4
|
||||
%15 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %12)
|
||||
%shift_exceeds8 = icmp sge i32 %15, 32
|
||||
br i1 %shift_exceeds8, label %panic9, label %checkok10
|
||||
|
||||
panic9: ; preds = %checkok7
|
||||
%16 = load void (i8*, i64, i8*, i64, i8*, i64, i32)*, void (i8*, i64, i8*, i64, i8*, i64, i32)** @std_core_builtin_panic, align 8
|
||||
call void %16(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.panic_msg.13, i64 0, i64 0), i64 26, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.file.14, i64 0, i64 0), i64 14, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.func.15, i64 0, i64 0), i64 5, i32 19)
|
||||
br label %checkok10
|
||||
|
||||
checkok10: ; preds = %panic9, %checkok7
|
||||
%shl = shl <4 x i32> %11, %12
|
||||
%17 = freeze <4 x i32> %shl
|
||||
store <4 x i32> %17, <4 x i32>* %w, align 16
|
||||
store <4 x float> %fdiv, ptr %w, align 16
|
||||
ret void
|
||||
}
|
||||
|
||||
|
||||
@@ -21,18 +21,18 @@ define void @test_tester() #0 {
|
||||
entry:
|
||||
%x = alloca <2 x i32>, align 8
|
||||
%y = alloca [2 x i32], align 4
|
||||
store <2 x i32> <i32 1, i32 2>, <2 x i32>* %x, align 8
|
||||
%0 = load <2 x i32>, <2 x i32>* %x, align 8
|
||||
store <2 x i32> <i32 1, i32 2>, ptr %x, align 8
|
||||
%0 = load <2 x i32>, ptr %x, align 8
|
||||
%1 = extractelement <2 x i32> %0, i64 0
|
||||
%2 = insertvalue [2 x i32] undef, i32 %1, 0
|
||||
%3 = extractelement <2 x i32> %0, i64 1
|
||||
%4 = insertvalue [2 x i32] %2, i32 %3, 1
|
||||
store [2 x i32] %4, [2 x i32]* %y, align 4
|
||||
%5 = load [2 x i32], [2 x i32]* %y, align 4
|
||||
store [2 x i32] %4, ptr %y, align 4
|
||||
%5 = load [2 x i32], ptr %y, align 4
|
||||
%6 = extractvalue [2 x i32] %5, 0
|
||||
%7 = insertelement <2 x i32> undef, i32 %6, i64 0
|
||||
%8 = extractvalue [2 x i32] %5, 1
|
||||
%9 = insertelement <2 x i32> %7, i32 %8, i64 1
|
||||
store <2 x i32> %9, <2 x i32>* %x, align 8
|
||||
store <2 x i32> %9, ptr %x, align 8
|
||||
ret void
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user