Skip to content

Instantly share code, notes, and snippets.

@andrewrk

andrewrk/c.ll

Last active July 8, 2019 21:12
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save andrewrk/44ede94d75a25057c2a5871a135d6c2d to your computer and use it in GitHub Desktop.
Save andrewrk/44ede94d75a25057c2a5871a135d6c2d to your computer and use it in GitHub Desktop.
Download ZIP
clang-8 -c c.ll -O3 -target wasm32-unknown-musl
Raw
c.ll
; ModuleID = 'c'
source_filename = "c"
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown-musl"
%"[]u8.0" = type { i8*, i32 }
%builtin.StackTrace.1 = type { i32, %"[]usize.2" }
%"[]usize.2" = type { i32*, i32 }
%"std.math.frexp.frexp_result(f64)" = type { double, i32 }
%std.math.fma.dd = type { double, double }
@0 = internal unnamed_addr constant [24 x i8] c"reached unreachable code", align 1
@1 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([24 x i8], [24 x i8]* @0, i32 0, i32 0), i32 24 }, align 4
@2 = internal unnamed_addr constant [16 x i8] c"integer overflow", align 1
@3 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([16 x i8], [16 x i8]* @2, i32 0, i32 0), i32 16 }, align 4
@4 = internal unnamed_addr constant [29 x i8] c"TODO strerror implementation\00", align 1
@5 = internal unnamed_addr constant [23 x i8] c"stack smashing detected", align 1
@6 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([23 x i8], [23 x i8]* @5, i32 0, i32 0), i32 23 }, align 4
@7 = internal unnamed_addr constant double 1.000000e-300, align 8
@8 = internal unnamed_addr constant i32 -2147483648, align 4
@9 = internal unnamed_addr constant [27 x i8] c"integer cast truncated bits", align 1
@10 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([27 x i8], [27 x i8]* @9, i32 0, i32 0), i32 27 }, align 4
@11 = internal unnamed_addr constant [50 x i8] c"attempt to cast negative value to unsigned integer", align 1
@12 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([50 x i8], [50 x i8]* @11, i32 0, i32 0), i32 50 }, align 4
@13 = internal unnamed_addr constant float 0x39B4484C00000000, align 4
@14 = internal unnamed_addr constant i32 -2147483648, align 4
@15 = internal unnamed_addr constant [50 x i8] c"integer part of floating point value out of bounds", align 1
@16 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([50 x i8], [50 x i8]* @15, i32 0, i32 0), i32 50 }, align 4
@17 = internal unnamed_addr constant [2 x double] [double 5.000000e-01, double -5.000000e-01], align 8
@18 = internal unnamed_addr constant double 0x3FE62E42FEE00000, align 8
@19 = internal unnamed_addr constant double 0x3DEA39EF35793C76, align 8
@20 = internal unnamed_addr constant double 0x3FF71547652B82FE, align 8
@21 = internal unnamed_addr constant double 0x3FC555555555553E, align 8
@22 = internal unnamed_addr constant double 0xBF66C16C16BEBD93, align 8
@23 = internal unnamed_addr constant double 0x3F11566AAF25DE2C, align 8
@24 = internal unnamed_addr constant double 0xBEBBBD41C5D26BF1, align 8
@25 = internal unnamed_addr constant double 0x3E66376972BEA4D0, align 8
@26 = internal unnamed_addr constant [19 x i8] c"index out of bounds", align 1
@27 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([19 x i8], [19 x i8]* @26, i32 0, i32 0), i32 19 }, align 4
@28 = internal unnamed_addr constant [2 x float] [float 5.000000e-01, float -5.000000e-01], align 4
@29 = internal unnamed_addr constant i32 256, align 4
@30 = internal unnamed_addr constant double 0x42B8000000000000, align 8
@31 = internal unnamed_addr constant double 0x3FE62E42FEFA39EF, align 8
@32 = internal unnamed_addr constant double 0x3FCEBFBDFF82C575, align 8
@33 = internal unnamed_addr constant double 0x3FAC6B08D704A0A6, align 8
@34 = internal unnamed_addr constant double 0x3F83B2AB88F70400, align 8
@35 = internal unnamed_addr constant double 0x3F55D88003875C74, align 8
@36 = internal unnamed_addr constant [16 x i8] c"division by zero", align 1
@37 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([16 x i8], [16 x i8]* @36, i32 0, i32 0), i32 16 }, align 4
@38 = internal unnamed_addr constant [44 x i8] c"remainder division by zero or negative value", align 1
@39 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([44 x i8], [44 x i8]* @38, i32 0, i32 0), i32 44 }, align 4
@40 = internal unnamed_addr constant i32 16, align 4
@41 = internal unnamed_addr constant float 7.864320e+05, align 4
@42 = internal unnamed_addr constant float 0x3FE62E4300000000, align 4
@43 = internal unnamed_addr constant float 0x3FCEBFBE00000000, align 4
@44 = internal unnamed_addr constant float 0x3FAC6B3480000000, align 4
@45 = internal unnamed_addr constant float 0x3F83B2C9C0000000, align 4
@46 = internal unnamed_addr constant double 0x3FE62E42FEE00000, align 8
@47 = internal unnamed_addr constant double 0x3DEA39EF35793C76, align 8
@48 = internal unnamed_addr constant double 0x3FE5555555555593, align 8
@49 = internal unnamed_addr constant double 0x3FD999999997FA04, align 8
@50 = internal unnamed_addr constant double 0x3FD2492494229359, align 8
@51 = internal unnamed_addr constant double 0x3FCC71C51D8E78AF, align 8
@52 = internal unnamed_addr constant double 0x3FC7466496CB03DE, align 8
@53 = internal unnamed_addr constant double 0x3FC39A09D078C69F, align 8
@54 = internal unnamed_addr constant double 0x3FC2F112DF3E5244, align 8
@55 = internal unnamed_addr constant float 0x3FE62E3000000000, align 4
@56 = internal unnamed_addr constant float 0x3EE2FEFA20000000, align 4
@57 = internal unnamed_addr constant float 0x3FE5555540000000, align 4
@58 = internal unnamed_addr constant float 0x3FD999C260000000, align 4
@59 = internal unnamed_addr constant float 0x3FD23D3DC0000000, align 4
@60 = internal unnamed_addr constant float 0x3FCF13C4C0000000, align 4
@61 = internal unnamed_addr constant double 0x3FF7154765200000, align 8
@62 = internal unnamed_addr constant double 0x3DE705FC2EEFA200, align 8
@63 = internal unnamed_addr constant double 0x3FE5555555555593, align 8
@64 = internal unnamed_addr constant double 0x3FD999999997FA04, align 8
@65 = internal unnamed_addr constant double 0x3FD2492494229359, align 8
@66 = internal unnamed_addr constant double 0x3FCC71C51D8E78AF, align 8
@67 = internal unnamed_addr constant double 0x3FC7466496CB03DE, align 8
@68 = internal unnamed_addr constant double 0x3FC39A09D078C69F, align 8
@69 = internal unnamed_addr constant double 0x3FC2F112DF3E5244, align 8
@70 = internal unnamed_addr constant float 0x3FF7160000000000, align 4
@71 = internal unnamed_addr constant float 0xBF27135A80000000, align 4
@72 = internal unnamed_addr constant float 0x3FE5555540000000, align 4
@73 = internal unnamed_addr constant float 0x3FD999C260000000, align 4
@74 = internal unnamed_addr constant float 0x3FD23D3DC0000000, align 4
@75 = internal unnamed_addr constant float 0x3FCF13C4C0000000, align 4
@76 = internal unnamed_addr constant double 0x3FDBCB7B15200000, align 8
@77 = internal unnamed_addr constant double 0x3DBB9438CA9AADD5, align 8
@78 = internal unnamed_addr constant double 0x3FD34413509F6000, align 8
@79 = internal unnamed_addr constant double 0x3D59FEF311F12B36, align 8
@80 = internal unnamed_addr constant double 0x3FE5555555555593, align 8
@81 = internal unnamed_addr constant double 0x3FD999999997FA04, align 8
@82 = internal unnamed_addr constant double 0x3FD2492494229359, align 8
@83 = internal unnamed_addr constant double 0x3FCC71C51D8E78AF, align 8
@84 = internal unnamed_addr constant double 0x3FC7466496CB03DE, align 8
@85 = internal unnamed_addr constant double 0x3FC39A09D078C69F, align 8
@86 = internal unnamed_addr constant double 0x3FC2F112DF3E5244, align 8
@87 = internal unnamed_addr constant float 0x3FDBCC0000000000, align 4
@88 = internal unnamed_addr constant float 0xBF009D5B20000000, align 4
@89 = internal unnamed_addr constant float 0x3FD3441000000000, align 4
@90 = internal unnamed_addr constant float 0x3EAA84FB60000000, align 4
@91 = internal unnamed_addr constant float 0x3FE5555540000000, align 4
@92 = internal unnamed_addr constant float 0x3FD999C260000000, align 4
@93 = internal unnamed_addr constant float 0x3FD23D3DC0000000, align 4
@94 = internal unnamed_addr constant float 0x3FCF13C4C0000000, align 4
@95 = internal unnamed_addr constant [30 x i8] c"cast causes pointer to be null", align 1
@96 = internal unnamed_addr constant %"[]u8.0" { i8* getelementptr inbounds ([30 x i8], [30 x i8]* @95, i32 0, i32 0), i32 30 }, align 4
@97 = internal unnamed_addr constant double 0x41A0000002000000, align 8
; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32) #3
; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32) #3
; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32) #3
; Function Attrs: argmemonly nounwind
declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i1) #4
; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32) #3
; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.sadd.with.overflow.i64(i64, i64) #3
; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.ssub.with.overflow.i64(i64, i64) #3
; Function Attrs: nounwind readnone speculatable
declare { i32, i1 } @llvm.umul.with.overflow.i32(i32, i32) #3
; Function Attrs: argmemonly nounwind
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i1) #4
; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.usub.with.overflow.i64(i64, i64) #3
; Function Attrs: nounwind readnone speculatable
declare { i64, i1 } @llvm.uadd.with.overflow.i64(i64, i64) #3
; Function Attrs: nobuiltin noreturn nounwind sspstrong
define internal fastcc void @panic(%"[]u8.0"* nonnull readonly align 4, %builtin.StackTrace.1* align 4) unnamed_addr #0 {
unreachable
}
; Function Attrs: nobuiltin nounwind sspstrong
define double @fma(double, double, double) #1 {
Entry:
%a = alloca double, align 8
%b = alloca double, align 8
%c = alloca double, align 8
store double %0, double* %a, align 8
store double %1, double* %b, align 8
store double %2, double* %c, align 8
%3 = load double, double* %a, align 8
%4 = load double, double* %b, align 8
%5 = load double, double* %c, align 8
%6 = call fastcc double @std.math.fma.fma(double %3, double %4, double %5)
ret double %6
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.fma(double, double, double) unnamed_addr #1 {
Entry:
%x = alloca double, align 8
%y = alloca double, align 8
%z = alloca double, align 8
store double %0, double* %x, align 8
store double %1, double* %y, align 8
store double %2, double* %z, align 8
%3 = load double, double* %x, align 8
%4 = load double, double* %y, align 8
%5 = load double, double* %z, align 8
%6 = call fastcc double @std.math.fma.fma64(double %3, double %4, double %5)
ret double %6
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.fma64(double, double, double) unnamed_addr #1 {
Entry:
%x1 = alloca %"std.math.frexp.frexp_result(f64)", align 8
%ex = alloca i32, align 4
%xs = alloca double, align 8
%x2 = alloca %"std.math.frexp.frexp_result(f64)", align 8
%ey = alloca i32, align 4
%ys = alloca double, align 8
%x3 = alloca %"std.math.frexp.frexp_result(f64)", align 8
%ez = alloca i32, align 4
%zs = alloca double, align 8
%spread = alloca i32, align 4
%xy = alloca %std.math.fma.dd, align 8
%r = alloca %std.math.fma.dd, align 8
%adj = alloca double, align 8
%x = alloca double, align 8
%y = alloca double, align 8
%z = alloca double, align 8
store double %0, double* %x, align 8
store double %1, double* %y, align 8
store double %2, double* %z, align 8
%3 = load double, double* %x, align 8
%4 = call fastcc i1 @std.math.isfinite.isFinite(double %3)
%5 = icmp eq i1 %4, false
br i1 %5, label %BoolOrTrue, label %BoolOrFalse
BoolOrFalse: ; preds = %Entry
%6 = load double, double* %y, align 8
%7 = call fastcc i1 @std.math.isfinite.isFinite(double %6)
%8 = icmp eq i1 %7, false
br label %BoolOrTrue
BoolOrTrue: ; preds = %BoolOrFalse, %Entry
%9 = phi i1 [ %5, %Entry ], [ %8, %BoolOrFalse ]
br i1 %9, label %Then, label %Else
Then: ; preds = %BoolOrTrue
%10 = load double, double* %x, align 8
%11 = load double, double* %y, align 8
%12 = fmul double %10, %11
%13 = load double, double* %z, align 8
%14 = fadd double %12, %13
ret double %14
Else: ; preds = %BoolOrTrue
br label %EndIf
EndIf: ; preds = %Else
%15 = load double, double* %z, align 8
%16 = call fastcc i1 @std.math.isfinite.isFinite(double %15)
%17 = icmp eq i1 %16, false
br i1 %17, label %Then1, label %Else2
Then1: ; preds = %EndIf
%18 = load double, double* %z, align 8
ret double %18
Else2: ; preds = %EndIf
br label %EndIf3
EndIf3: ; preds = %Else2
%19 = load double, double* %x, align 8
%20 = fcmp oeq double %19, 0.000000e+00
br i1 %20, label %BoolOrTrue5, label %BoolOrFalse4
BoolOrFalse4: ; preds = %EndIf3
%21 = load double, double* %y, align 8
%22 = fcmp oeq double %21, 0.000000e+00
br label %BoolOrTrue5
BoolOrTrue5: ; preds = %BoolOrFalse4, %EndIf3
%23 = phi i1 [ %20, %EndIf3 ], [ %22, %BoolOrFalse4 ]
br i1 %23, label %Then6, label %Else7
Then6: ; preds = %BoolOrTrue5
%24 = load double, double* %x, align 8
%25 = load double, double* %y, align 8
%26 = fmul double %24, %25
%27 = load double, double* %z, align 8
%28 = fadd double %26, %27
ret double %28
Else7: ; preds = %BoolOrTrue5
br label %EndIf8
EndIf8: ; preds = %Else7
%29 = load double, double* %z, align 8
%30 = fcmp oeq double %29, 0.000000e+00
br i1 %30, label %Then9, label %Else10
Then9: ; preds = %EndIf8
%31 = load double, double* %x, align 8
%32 = load double, double* %y, align 8
%33 = fmul double %31, %32
ret double %33
Else10: ; preds = %EndIf8
br label %EndIf11
EndIf11: ; preds = %Else10
%34 = load double, double* %x, align 8
call fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* sret %x1, double %34)
%35 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x1, i32 0, i32 1
%36 = load i32, i32* %35, align 4
store i32 %36, i32* %ex, align 4
%37 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x1, i32 0, i32 0
%38 = load double, double* %37, align 8
store double %38, double* %xs, align 8
%39 = load double, double* %y, align 8
call fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* sret %x2, double %39)
%40 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x2, i32 0, i32 1
%41 = load i32, i32* %40, align 4
store i32 %41, i32* %ey, align 4
%42 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x2, i32 0, i32 0
%43 = load double, double* %42, align 8
store double %43, double* %ys, align 8
%44 = load double, double* %z, align 8
call fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* sret %x3, double %44)
%45 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x3, i32 0, i32 1
%46 = load i32, i32* %45, align 4
store i32 %46, i32* %ez, align 4
%47 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %x3, i32 0, i32 0
%48 = load double, double* %47, align 8
store double %48, double* %zs, align 8
%49 = load i32, i32* %ex, align 4
%50 = load i32, i32* %ey, align 4
%51 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %49, i32 %50)
%52 = extractvalue { i32, i1 } %51, 0
%53 = extractvalue { i32, i1 } %51, 1
br i1 %53, label %OverflowFail, label %OverflowOk
Then12: ; preds = %OverflowOk21
%54 = load double, double* %zs, align 8
%55 = load i32, i32* %spread, align 4
%56 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 0, i32 %55)
%57 = extractvalue { i32, i1 } %56, 0
%58 = extractvalue { i32, i1 } %56, 1
br i1 %58, label %OverflowFail22, label %OverflowOk23
Else13: ; preds = %OverflowOk21
%59 = load double, double* %zs, align 8
%60 = call fastcc double @std.math.copysign.copysign(double 0x10000000000000, double %59)
store double %60, double* %zs, align 8
br label %EndIf14
EndIf14: ; preds = %Else13, %OverflowOk23
%61 = load double, double* %xs, align 8
%62 = load double, double* %ys, align 8
%63 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 0
%64 = load double, double* %63, align 8
%65 = load double, double* %zs, align 8
%66 = load i32, i32* %ex, align 4
%67 = load i32, i32* %ey, align 4
%68 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %66, i32 %67)
%69 = extractvalue { i32, i1 } %68, 0
%70 = extractvalue { i32, i1 } %68, 1
br i1 %70, label %OverflowFail24, label %OverflowOk25
Then15: ; preds = %OverflowOk25
%71 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 0
%72 = load double, double* %71, align 8
%73 = load double, double* %zs, align 8
%74 = fadd double %72, %73
%75 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 1
%76 = load double, double* %75, align 8
%77 = load i32, i32* %spread, align 4
%78 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
%79 = fadd double %74, %78
ret double %79
Else16: ; preds = %OverflowOk25
br label %EndIf17
EndIf17: ; preds = %Else16
%80 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 1
%81 = load double, double* %80, align 8
%82 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %xy, i32 0, i32 1
%83 = load double, double* %82, align 8
%84 = call fastcc double @std.math.fma.add_adjusted(double %81, double %83)
store double %84, double* %adj, align 8
%85 = load i32, i32* %spread, align 4
%86 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
%87 = load double, double* %86, align 8
%88 = add i32 0, 0
%89 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %85, i32 %88)
%90 = extractvalue { i32, i1 } %89, 0
%91 = extractvalue { i32, i1 } %89, 1
br i1 %91, label %OverflowFail26, label %OverflowOk27
Then18: ; preds = %OverflowOk27
%92 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
%93 = load double, double* %92, align 8
%94 = load double, double* %adj, align 8
%95 = fadd double %93, %94
%96 = load i32, i32* %spread, align 4
%97 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
ret double %97
Else19: ; preds = %OverflowOk27
%98 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
%99 = load double, double* %98, align 8
%100 = load double, double* %adj, align 8
%101 = load i32, i32* %spread, align 4
%102 = call fastcc double @std.math.fma.add_and_denorm(double %99, double %100, i32 %101)
ret double %102
OverflowFail: ; preds = %EndIf11
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk: ; preds = %EndIf11
%103 = load i32, i32* %ez, align 4
%104 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %52, i32 %103)
%105 = extractvalue { i32, i1 } %104, 0
%106 = extractvalue { i32, i1 } %104, 1
br i1 %106, label %OverflowFail20, label %OverflowOk21
OverflowFail20: ; preds = %OverflowOk
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk21: ; preds = %OverflowOk
store i32 %105, i32* %spread, align 4
%107 = load i32, i32* %spread, align 4
%108 = icmp sle i32 %107, 106
br i1 %108, label %Then12, label %Else13
OverflowFail22: ; preds = %Then12
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk23: ; preds = %Then12
%109 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
store double %109, double* %zs, align 8
br label %EndIf14
OverflowFail24: ; preds = %EndIf14
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk25: ; preds = %EndIf14
store i32 %69, i32* %spread, align 4
%110 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %r, i32 0, i32 0
%111 = load double, double* %110, align 8
%112 = fcmp oeq double %111, 0.000000e+00
br i1 %112, label %Then15, label %Else16
OverflowFail26: ; preds = %EndIf17
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk27: ; preds = %EndIf17
%113 = icmp sgt i32 %90, -1023
br i1 %113, label %Then18, label %Else19
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.copysign.copysign(double, double) unnamed_addr #1 {
Entry:
%x = alloca double, align 8
%y = alloca double, align 8
store double %0, double* %x, align 8
store double %1, double* %y, align 8
%2 = load double, double* %x, align 8
%3 = load double, double* %y, align 8
%4 = call fastcc double @std.math.copysign.copysign64(double %2, double %3)
ret double %4
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.copysign.copysign64(double, double) unnamed_addr #1 {
Entry:
%ux = alloca i64, align 8
%uy = alloca i64, align 8
%h1 = alloca i64, align 8
%h2 = alloca i64, align 8
%x = alloca double, align 8
%y = alloca double, align 8
store double %0, double* %x, align 8
store double %1, double* %y, align 8
%2 = load double, double* %x, align 8
%3 = bitcast i64* %ux to double*
store double %2, double* %3, align 8
%4 = load double, double* %y, align 8
%5 = bitcast i64* %uy to double*
store double %4, double* %5, align 8
%6 = load i64, i64* %ux, align 8
%7 = and i64 %6, 9223372036854775807
store i64 %7, i64* %h1, align 8
%8 = load i64, i64* %uy, align 8
%9 = and i64 %8, -9223372036854775808
store i64 %9, i64* %h2, align 8
%10 = load i64, i64* %h1, align 8
%11 = load i64, i64* %h2, align 8
%12 = or i64 %10, %11
%13 = bitcast i64 %12 to double
ret double %13
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.add_adjusted(double, double) unnamed_addr #1 {
Entry:
%sum = alloca %std.math.fma.dd, align 8
%uhii = alloca i64, align 8
%uloi = alloca i64, align 8
%a = alloca double, align 8
%b = alloca double, align 8
store double %0, double* %a, align 8
store double %1, double* %b, align 8
%2 = load double, double* %a, align 8
%3 = load double, double* %b, align 8
%4 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
%5 = load double, double* %4, align 8
%6 = fcmp une double %5, 0.000000e+00
br i1 %6, label %Then, label %Else2
Then: ; preds = %Entry
%7 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
%8 = load double, double* %7, align 8
%9 = bitcast i64* %uhii to double*
store double %8, double* %9, align 8
%10 = load i64, i64* %uhii, align 8
%11 = and i64 %10, 1
%12 = icmp eq i64 %11, 0
br i1 %12, label %Then1, label %Else
Then1: ; preds = %Then
%13 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
%14 = load double, double* %13, align 8
%15 = bitcast i64* %uloi to double*
store double %14, double* %15, align 8
%16 = load i64, i64* %uhii, align 8
%17 = load i64, i64* %uhii, align 8
%18 = load i64, i64* %uloi, align 8
%19 = xor i64 %17, %18
%20 = lshr i64 %19, 62
%21 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 1, i64 %20)
%22 = extractvalue { i64, i1 } %21, 0
%23 = extractvalue { i64, i1 } %21, 1
br i1 %23, label %OverflowFail, label %OverflowOk
Else: ; preds = %Then
br label %EndIf
EndIf: ; preds = %Else, %OverflowOk5
br label %EndIf3
Else2: ; preds = %Entry
br label %EndIf3
EndIf3: ; preds = %Else2, %EndIf
%24 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
%25 = load double, double* %24, align 8
ret double %25
OverflowFail: ; preds = %Then1
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk: ; preds = %Then1
%26 = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %16, i64 %22)
%27 = extractvalue { i64, i1 } %26, 0
%28 = extractvalue { i64, i1 } %26, 1
br i1 %28, label %OverflowFail4, label %OverflowOk5
OverflowFail4: ; preds = %OverflowOk
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk5: ; preds = %OverflowOk
store i64 %27, i64* %uhii, align 8
%29 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
%30 = load i64, i64* %uhii, align 8
%31 = bitcast i64 %30 to double
store double %31, double* %29, align 8
br label %EndIf
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc double @std.math.fma.add_and_denorm(double, double, i32) unnamed_addr #1 {
Entry:
%sum = alloca %std.math.fma.dd, align 8
%uhii = alloca i64, align 8
%bits_lost = alloca i32, align 4
%uloi = alloca i64, align 8
%a = alloca double, align 8
%b = alloca double, align 8
%scale = alloca i32, align 4
store double %0, double* %a, align 8
store double %1, double* %b, align 8
store i32 %2, i32* %scale, align 4
%3 = load double, double* %a, align 8
%4 = load double, double* %b, align 8
%5 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
%6 = load double, double* %5, align 8
%7 = fcmp une double %6, 0.000000e+00
br i1 %7, label %Then, label %Else2
Then: ; preds = %Entry
%8 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
%9 = load double, double* %8, align 8
%10 = bitcast i64* %uhii to double*
store double %9, double* %10, align 8
%11 = load i64, i64* %uhii, align 8
%12 = lshr i64 %11, 52
%13 = and i64 %12, 2047
%14 = trunc i64 %13 to i32
%15 = sext i32 %14 to i64
%16 = icmp eq i64 %13, %15
br i1 %16, label %CastShortenOk, label %CastShortenFail
Then1: ; preds = %OverflowOk7
%17 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 1
%18 = load double, double* %17, align 8
%19 = bitcast i64* %uloi to double*
store double %18, double* %19, align 8
%20 = load i64, i64* %uhii, align 8
%21 = load i64, i64* %uhii, align 8
%22 = load i64, i64* %uloi, align 8
%23 = xor i64 %21, %22
%24 = lshr i64 %23, 62
%25 = and i64 %24, 2
%26 = call { i64, i1 } @llvm.usub.with.overflow.i64(i64 1, i64 %25)
%27 = extractvalue { i64, i1 } %26, 0
%28 = extractvalue { i64, i1 } %26, 1
br i1 %28, label %OverflowFail8, label %OverflowOk9
Else: ; preds = %OverflowOk7
br label %EndIf
EndIf: ; preds = %Else, %OverflowOk11
br label %EndIf3
Else2: ; preds = %Entry
br label %EndIf3
EndIf3: ; preds = %Else2, %EndIf
%29 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
%30 = load double, double* %29, align 8
%31 = load i32, i32* %scale, align 4
%32 = fadd double 0x7FE0000000000000, 0x7FE0000000000000
ret double %32
CastShortenOk: ; preds = %Then
%33 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 0, i32 %14)
%34 = extractvalue { i32, i1 } %33, 0
%35 = extractvalue { i32, i1 } %33, 1
br i1 %35, label %OverflowFail, label %OverflowOk
CastShortenFail: ; preds = %Then
tail call fastcc void @panic(%"[]u8.0"* @10, %builtin.StackTrace.1* null)
unreachable
OverflowFail: ; preds = %CastShortenOk
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk: ; preds = %CastShortenOk
%36 = load i32, i32* %scale, align 4
%37 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %34, i32 %36)
%38 = extractvalue { i32, i1 } %37, 0
%39 = extractvalue { i32, i1 } %37, 1
br i1 %39, label %OverflowFail4, label %OverflowOk5
OverflowFail4: ; preds = %OverflowOk
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk5: ; preds = %OverflowOk
%40 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %38, i32 1)
%41 = extractvalue { i32, i1 } %40, 0
%42 = extractvalue { i32, i1 } %40, 1
br i1 %42, label %OverflowFail6, label %OverflowOk7
OverflowFail6: ; preds = %OverflowOk5
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk7: ; preds = %OverflowOk5
store i32 %41, i32* %bits_lost, align 4
%43 = load i32, i32* %bits_lost, align 4
%44 = icmp ne i32 %43, 1
%45 = load i64, i64* %uhii, align 8
%46 = and i64 %45, 1
%47 = icmp ne i64 %46, 0
%48 = icmp eq i1 %44, %47
br i1 %48, label %Then1, label %Else
OverflowFail8: ; preds = %Then1
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk9: ; preds = %Then1
%49 = call { i64, i1 } @llvm.uadd.with.overflow.i64(i64 %20, i64 %27)
%50 = extractvalue { i64, i1 } %49, 0
%51 = extractvalue { i64, i1 } %49, 1
br i1 %51, label %OverflowFail10, label %OverflowOk11
OverflowFail10: ; preds = %OverflowOk9
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk11: ; preds = %OverflowOk9
store i64 %50, i64* %uhii, align 8
%52 = getelementptr inbounds %std.math.fma.dd, %std.math.fma.dd* %sum, i32 0, i32 0
%53 = load i64, i64* %uhii, align 8
%54 = bitcast i64 %53 to double
store double %54, double* %52, align 8
br label %EndIf
}
define internal fastcc void @std.math.frexp.frexp(%"std.math.frexp.frexp_result(f64)"* nonnull sret, double) unnamed_addr #1 {
Entry:
%x = alloca double, align 8
store double %1, double* %x, align 8
%2 = load double, double* %x, align 8
call fastcc void @std.math.frexp.frexp64(%"std.math.frexp.frexp_result(f64)"* sret %0, double %2)
ret void
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc void @std.math.frexp.frexp64(%"std.math.frexp.frexp_result(f64)"* nonnull sret, double) unnamed_addr #1 {
Entry:
%result = alloca %"std.math.frexp.frexp_result(f64)", align 8
%y = alloca i64, align 8
%e = alloca i32, align 4
%2 = alloca %"std.math.frexp.frexp_result(f64)", align 8
%x = alloca double, align 8
store double %1, double* %x, align 8
%3 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
call void @llvm.memset.p0i8.i32(i8* align 8 %3, i8 -86, i32 16, i1 false)
%4 = load double, double* %x, align 8
%5 = bitcast i64* %y to double*
store double %4, double* %5, align 8
%6 = load i64, i64* %y, align 8
%7 = lshr i64 %6, 52
%8 = trunc i64 %7 to i32
%9 = sext i32 %8 to i64
%10 = icmp eq i64 %7, %9
br i1 %10, label %CastShortenOk, label %CastShortenFail
Then: ; preds = %CastShortenOk
%11 = load double, double* %x, align 8
%12 = fcmp une double %11, 0.000000e+00
br i1 %12, label %Then1, label %Else
Then1: ; preds = %Then
%13 = load double, double* %x, align 8
%14 = fmul double %13, 0x43F0000000000000
call fastcc void @std.math.frexp.frexp64(%"std.math.frexp.frexp_result(f64)"* sret %2, double %14)
%15 = bitcast %"std.math.frexp.frexp_result(f64)"* %2 to i8*
%16 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %16, i8* align 8 %15, i32 16, i1 false)
%17 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
%18 = load i32, i32* %17, align 4
%19 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %18, i32 64)
%20 = extractvalue { i32, i1 } %19, 0
%21 = extractvalue { i32, i1 } %19, 1
br i1 %21, label %OverflowFail, label %OverflowOk
Else: ; preds = %Then
%22 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 0
%23 = load double, double* %x, align 8
store double %23, double* %22, align 8
%24 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
store i32 0, i32* %24, align 4
br label %EndIf
EndIf: ; preds = %Else, %OverflowOk
%25 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
%26 = bitcast %"std.math.frexp.frexp_result(f64)"* %0 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %26, i8* align 8 %25, i32 16, i1 false)
ret void
Else2: ; preds = %CastShortenOk
%27 = load i32, i32* %e, align 4
%28 = icmp eq i32 %27, 2047
br i1 %28, label %Then3, label %Else7
Then3: ; preds = %Else2
%29 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 0
%30 = load double, double* %x, align 8
store double %30, double* %29, align 8
%31 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
%32 = bitcast i32* %31 to i8*
call void @llvm.memset.p0i8.i32(i8* align 4 %32, i8 -86, i32 4, i1 false)
%33 = load double, double* %x, align 8
%34 = add i1 0, 0
br i1 %34, label %Then4, label %Else5
Then4: ; preds = %Then3
%35 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
store i32 0, i32* %35, align 4
br label %EndIf6
Else5: ; preds = %Then3
br label %EndIf6
EndIf6: ; preds = %Else5, %Then4
%36 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
%37 = bitcast %"std.math.frexp.frexp_result(f64)"* %0 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %37, i8* align 8 %36, i32 16, i1 false)
ret void
Else7: ; preds = %Else2
br label %EndIf8
EndIf8: ; preds = %Else7
br label %EndIf9
EndIf9: ; preds = %EndIf8
%38 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 1
%39 = load i32, i32* %e, align 4
%40 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %39, i32 1022)
%41 = extractvalue { i32, i1 } %40, 0
%42 = extractvalue { i32, i1 } %40, 1
br i1 %42, label %OverflowFail10, label %OverflowOk11
CastShortenOk: ; preds = %Entry
%43 = and i32 %8, 2047
store i32 %43, i32* %e, align 4
%44 = load i32, i32* %e, align 4
%45 = icmp eq i32 %44, 0
br i1 %45, label %Then, label %Else2
CastShortenFail: ; preds = %Entry
tail call fastcc void @panic(%"[]u8.0"* @10, %builtin.StackTrace.1* null)
unreachable
OverflowFail: ; preds = %Then1
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk: ; preds = %Then1
store i32 %20, i32* %17, align 4
br label %EndIf
OverflowFail10: ; preds = %EndIf9
tail call fastcc void @panic(%"[]u8.0"* @3, %builtin.StackTrace.1* null)
unreachable
OverflowOk11: ; preds = %EndIf9
store i32 %41, i32* %38, align 4
%46 = load i64, i64* %y, align 8
%47 = and i64 %46, -9218868437227405313
store i64 %47, i64* %y, align 8
%48 = load i64, i64* %y, align 8
%49 = or i64 %48, 4602678819172646912
store i64 %49, i64* %y, align 8
%50 = getelementptr inbounds %"std.math.frexp.frexp_result(f64)", %"std.math.frexp.frexp_result(f64)"* %result, i32 0, i32 0
%51 = load i64, i64* %y, align 8
%52 = bitcast i64 %51 to double
store double %52, double* %50, align 8
%53 = bitcast %"std.math.frexp.frexp_result(f64)"* %result to i8*
%54 = bitcast %"std.math.frexp.frexp_result(f64)"* %0 to i8*
call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %54, i8* align 8 %53, i32 16, i1 false)
ret void
}
; Function Attrs: nobuiltin nounwind sspstrong
define internal fastcc i1 @std.math.isfinite.isFinite(double) unnamed_addr #1 {
Entry:
%bits = alloca i64, align 8
%x = alloca double, align 8
store double %0, double* %x, align 8
%1 = load double, double* %x, align 8
%2 = bitcast i64* %bits to double*
store double %1, double* %2, align 8
%3 = load i64, i64* %bits, align 8
%4 = and i64 %3, 9223372036854775807
%5 = icmp ult i64 %4, 9218868437227405312
ret i1 %5
}
attributes #0 = { nobuiltin noreturn nounwind sspstrong "stack-protector-buffer-size"="4" }
attributes #1 = { nobuiltin nounwind sspstrong "stack-protector-buffer-size"="4" }
attributes #2 = { nobuiltin nounwind }
attributes #3 = { nounwind readnone speculatable }
attributes #4 = { argmemonly nounwind }
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment