Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
; ModuleID = 'test.c'
source_filename = "test.c"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-linux-gnu"
@.str = private unnamed_addr constant [8 x i8] c"HELLO!\0A\00", align 1
; Function Attrs: noinline nounwind optnone uwtable
define i32 @main() #0 {
%1 = alloca i32, align 4
store i32 0, i32* %1, align 4
%2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0))
ret i32 0
}
declare i32 @printf(i8*, ...) #1
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
!llvm.module.flags = !{!0}
!llvm.ident = !{!1}
!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{!"clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)"}
This file has been truncated, but you can view the full file.
; ModuleID = 'main_module'
source_filename = "main_module"
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
%String = type { i32, i32, i32, i8 }
%"Slice(UInt8)" = type { i32, i1, i8* }
%"Array(String)" = type { i32, i32, i32, %String** }
%"->" = type { i8*, i8* }
%"Thread::LinkedList(Fiber)" = type { %Fiber*, %Fiber*, %"Thread::Mutex"* }
%Fiber = type { i32, %"struct.Fiber::Context", i8*, %"(Crystal::Event | Nil)", i8*, %String*, %Fiber*, %Fiber*, i1, %"Atomic(Thread | Nil)", %"->" }
%"struct.Fiber::Context" = type { i8*, i64 }
%"(Crystal::Event | Nil)" = type { i32, [2 x i64] }
%"Atomic(Thread | Nil)" = type { %Thread* }
%Thread = type { i32, i64, i32*, %Fiber*, %Thread*, %Thread*, %"Atomic(UInt8)", %"->", %"Crystal::Scheduler"* }
%"Atomic(UInt8)" = type { i8 }
%"Crystal::Scheduler" = type { i32, %Fiber*, %Fiber*, %"Deque(Fiber)"* }
%"Deque(Fiber)" = type { i32, i32, i32, i32, %Fiber** }
%"Thread::Mutex" = type { i32, %"union.LibC::PthreadMutexT" }
%"union.LibC::PthreadMutexT" = type { i8*, [32 x i8] }
%"Fiber::StackPool" = type { i32, %"Deque(Pointer(Void))"* }
%"Deque(Pointer(Void))" = type { i32, i32, i32, i32, i8** }
%"Crystal::Event::Base" = type { i8* }
%"Thread::LinkedList(Thread)" = type { %Thread*, %Thread*, %"Thread::Mutex"* }
%"(UInt32 | UInt64 | Nil)" = type { i32, [1 x i64] }
%"(Debug::DWARF::LineNumbers | Nil)" = type { i32, [4 x i64] }
%"IO::FileDescriptor" = type { i32, %"(IO::EncodingOptions | Nil)", %"IO::Encoder"*, %"IO::Decoder"*, i32, i1, %"Slice(UInt8)", i32, i1, i1, i8*, i8*, %"(Time::Span | Nil)", %"(Time::Span | Nil)", %"Deque(Fiber)"*, %"Deque(Fiber)"*, %"(Crystal::Event | Nil)", %"(Crystal::Event | Nil)", i1, i1 }
%"(IO::EncodingOptions | Nil)" = type { i32, [3 x i64] }
%"IO::Encoder" = type { i32, %"IO::EncodingOptions", %Iconv, i1 }
%"IO::EncodingOptions" = type { %String*, %"(Symbol | Nil)" }
%"(Symbol | Nil)" = type { i32, [1 x i64] }
%Iconv = type { i1, i8* }
%"IO::Decoder" = type { i32, %"Slice(UInt8)", i8*, %"IO::EncodingOptions", %Iconv, %"Slice(UInt8)", i64, %"Slice(UInt8)", i1 }
%"(Time::Span | Nil)" = type { i32, [2 x i64] }
%"Array(Tuple(Int32, Int32, Int32))" = type { i32, i32, i32, %"Tuple(Int32, Int32, Int32)"* }
%"Tuple(Int32, Int32, Int32)" = type { i32, i32, i32 }
%"Hash(Int32, Tuple(Int32, Int32, Int32, Int32))" = type { i32, i32, i32, %"Hash::Entry(Int32, Tuple(Int32, Int32, Int32, Int32))"*, %"Hash::Entry(Int32, Tuple(Int32, Int32, Int32, Int32))"*, %"->", %"Hash::Entry(Int32, Tuple(Int32, Int32, Int32, Int32))"** }
%"Hash::Entry(Int32, Tuple(Int32, Int32, Int32, Int32))" = type { i32, i32, %"Tuple(Int32, Int32, Int32, Int32)", %"Hash::Entry(Int32, Tuple(Int32, Int32, Int32, Int32))"*, %"Hash::Entry(Int32, Tuple(Int32, Int32, Int32, Int32))"*, %"Hash::Entry(Int32, Tuple(Int32, Int32, Int32, Int32))"* }
%"Tuple(Int32, Int32, Int32, Int32)" = type { i32, i32, i32, i32 }
%"Array(Int32)" = type { i32, i32, i32, i32* }
%"Array(Tuple(Int32, Int32))" = type { i32, i32, i32, %"Tuple(Int32, Int32)"* }
%"Tuple(Int32, Int32)" = type { i32, i32 }
%"Array(Tuple(UInt64, UInt64, String))" = type { i32, i32, i32, %"Tuple(UInt64, UInt64, String)"* }
%"Tuple(UInt64, UInt64, String)" = type { i64, i64, %String* }
%"Array(Proc(Int32, (Exception+ | Nil), Nil))" = type { i32, i32, i32, %"->"* }
%File = type { i32, %"(IO::EncodingOptions | Nil)", %"IO::Encoder"*, %"IO::Decoder"*, i32, i1, %"Slice(UInt8)", i32, i1, i1, i8*, i8*, %"(Time::Span | Nil)", %"(Time::Span | Nil)", %"Deque(Fiber)"*, %"Deque(Fiber)"*, %"(Crystal::Event | Nil)", %"(Crystal::Event | Nil)", i1, i1, %String* }
%"Atomic(Int32)" = type { i32 }
%"struct.LibC::SigsetT" = type { [16 x i64] }
%"Tuple(IO::FileDescriptor+, IO::FileDescriptor+)" = type { i32*, i32* }
%"Hash(Signal, Proc(Signal, Nil))" = type { i32, i32, i32, %"Hash::Entry(Signal, Proc(Signal, Nil))"*, %"Hash::Entry(Signal, Proc(Signal, Nil))"*, %"->", %"Hash::Entry(Signal, Proc(Signal, Nil))"** }
%"Hash::Entry(Signal, Proc(Signal, Nil))" = type { i32, i32, %"->", %"Hash::Entry(Signal, Proc(Signal, Nil))"*, %"Hash::Entry(Signal, Proc(Signal, Nil))"*, %"Hash::Entry(Signal, Proc(Signal, Nil))"* }
%Mutex = type { i32, %Fiber*, i32, %"Deque(Fiber)"* }
%"Hash(Int32, Channel::Buffered(Int32))" = type { i32, i32, i32, %"Hash::Entry(Int32, Channel::Buffered(Int32))"*, %"Hash::Entry(Int32, Channel::Buffered(Int32))"*, %"->", %"Hash::Entry(Int32, Channel::Buffered(Int32))"** }
%"Hash::Entry(Int32, Channel::Buffered(Int32))" = type { i32, i32, %"Channel::Buffered(Int32)"*, %"Hash::Entry(Int32, Channel::Buffered(Int32))"*, %"Hash::Entry(Int32, Channel::Buffered(Int32))"*, %"Hash::Entry(Int32, Channel::Buffered(Int32))"* }
%"Channel::Buffered(Int32)" = type { i32, i1, %"Deque(Fiber)"*, %"Deque(Fiber)"*, i32, %"Deque(Int32)"* }
%"Deque(Int32)" = type { i32, i32, i32, i32, i32* }
%"Hash(Int32, Int32)" = type { i32, i32, i32, %"Hash::Entry(Int32, Int32)"*, %"Hash::Entry(Int32, Int32)"*, %"->", %"Hash::Entry(Int32, Int32)"** }
%"Hash::Entry(Int32, Int32)" = type { i32, i32, i32, %"Hash::Entry(Int32, Int32)"*, %"Hash::Entry(Int32, Int32)"*, %"Hash::Entry(Int32, Int32)"* }
%Nil = type {}
%"Hash(String, NamedTuple(time: Time, location: Time::Location))" = type { i32, i32, i32, %"Hash::Entry(String, NamedTuple(time: Time, location: Time::Location))"*, %"Hash::Entry(String, NamedTuple(time: Time, location: Time::Location))"*, %"->", %"Hash::Entry(String, NamedTuple(time: Time, location: Time::Location))"** }
%"Hash::Entry(String, NamedTuple(time: Time, location: Time::Location))" = type { i32, %String*, %"NamedTuple(time: Time, location: Time::Location)", %"Hash::Entry(String, NamedTuple(time: Time, location: Time::Location))"*, %"Hash::Entry(String, NamedTuple(time: Time, location: Time::Location))"*, %"Hash::Entry(String, NamedTuple(time: Time, location: Time::Location))"* }
%"NamedTuple(time: Time, location: Time::Location)" = type { %Time, %"Time::Location"* }
%Time = type { i64, i32, %"Time::Location"* }
%"Time::Location" = type { i32, %String*, %"Array(Time::Location::Zone)"*, %"Tuple(Int64, Int64)", %"Time::Location::Zone", %"Array(Time::Location::ZoneTransition)"* }
%"Array(Time::Location::Zone)" = type { i32, i32, i32, %"Time::Location::Zone"* }
%"Tuple(Int64, Int64)" = type { i64, i64 }
%"Time::Location::Zone" = type { i32, i1, %String* }
%"Array(Time::Location::ZoneTransition)" = type { i32, i32, i32, %"Time::Location::ZoneTransition"* }
%"Time::Location::ZoneTransition" = type { i64, i8, i1, i1 }
%"struct.LibUnwind::Exception" = type { i64, i64, i64, i64, i64, i32 }
%"/usr/share/crystal/src/raise.cr::LEBReader" = type { i8* }
%OverflowError = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"(CallStack | Nil)" = type { i32, [2 x i64] }
%ArgumentError = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%CallStack = type { %"Array(Pointer(Void))"*, %"Array(String)"* }
%"Array(Pointer(Void))" = type { i32, i32, i32, i8** }
%Exception = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%Errno = type { i32, %String*, i32*, %"(CallStack | Nil)", i32, %String* }
%"String::Builder" = type { i32, %"(IO::EncodingOptions | Nil)", %"IO::Encoder"*, %"IO::Decoder"*, i32, i32, i8*, i1 }
%"Tuple(UInt64, Int32)" = type { i64, i32 }
%"(UInt64 | Nil)" = type { i32, [1 x i64] }
%IndexError = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"Tuple(StaticArray(UInt8, 4), Int32)" = type { [4 x i8], i32 }
%InvalidByteSequenceError = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%DivisionByZeroError = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"Tuple(Pointer(Void), Pointer(Void))" = type { i8*, i8* }
%"union.LibC::PthreadMutexattrT" = type { i32 }
%"union.LibC::PthreadAttrT" = type { i64, [48 x i8] }
%landing_pad = type { i8*, i32 }
%"(Int32 | Nil)" = type { i32, [1 x i64] }
%"(Bool | File | Nil)" = type { i32, [1 x i64] }
%"(Bool | File)" = type { i32, [1 x i64] }
%"Crystal::System::FileInfo" = type { %"struct.LibC::Stat" }
%"struct.LibC::Stat" = type { i64, i64, i64, i32, i32, i32, i32, i64, i64, i64, i64, %"struct.LibC::Timespec", %"struct.LibC::Timespec", %"struct.LibC::Timespec", [3 x i64] }
%"struct.LibC::Timespec" = type { i64, i64 }
%NilAssertionError = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"Time::Span" = type { i64, i32 }
%"(Int64 | Nil)" = type { i32, [1 x i64] }
%"Crystal::Event" = type { i8*, i1 }
%"Tuple(String, Int32, Int32)" = type { %String*, i32, i32 }
%"(Int32 | String)" = type { i32, [1 x i64] }
%"(Tuple(Int64, Pointer(UInt8)) | Nil)" = type { i32, [2 x i64] }
%"Tuple(Int64, Pointer(UInt8))" = type { i64, i8* }
%"(Bool | String)" = type { i32, [1 x i64] }
%"(Bool | Tuple(Int64, Pointer(UInt8)) | Nil)" = type { i32, [2 x i64] }
%"struct.LibC::DlInfo" = type { i8*, i8*, i8*, i8* }
%"(UInt32 | UInt64)" = type { i32, [1 x i64] }
%"(Debug::DWARF::LineNumbers::Row | Nil)" = type { i32, [6 x i64] }
%"Debug::DWARF::LineNumbers" = type { %"Array(Array(Debug::DWARF::LineNumbers::Row))"*, i64, %"Array(Debug::DWARF::LineNumbers::Row)"*, i32* }
%"Array(Array(Debug::DWARF::LineNumbers::Row))" = type { i32, i32, i32, %"Array(Debug::DWARF::LineNumbers::Row)"** }
%"Array(Debug::DWARF::LineNumbers::Row)" = type { i32, i32, i32, %"Debug::DWARF::LineNumbers::Row"* }
%"Debug::DWARF::LineNumbers::Row" = type { i64, i32, %String*, %String*, i32, i32, i1 }
%"Debug::ELF" = type { %"(Debug::ELF::Ident | Nil)", %"(Debug::ELF::Type | Nil)", %"(Debug::ELF::Machine | Nil)", %"(UInt32 | Nil)", %"(UInt32 | UInt64 | Nil)", %"(UInt32 | UInt64 | Nil)", %"(UInt32 | UInt64 | Nil)", %"(UInt32 | Nil)", %"(UInt16 | Nil)", %"(UInt16 | Nil)", %"(UInt16 | Nil)", %"(UInt16 | Nil)", %"(UInt16 | Nil)", %"(UInt16 | Nil)", i32*, %"Array(Debug::ELF::SectionHeader)"* }
%"(Debug::ELF::Ident | Nil)" = type { i32, [2 x i64] }
%"(Debug::ELF::Type | Nil)" = type { i32, [1 x i64] }
%"(Debug::ELF::Machine | Nil)" = type { i32, [1 x i64] }
%"(UInt32 | Nil)" = type { i32, [1 x i64] }
%"(UInt16 | Nil)" = type { i32, [1 x i64] }
%"Array(Debug::ELF::SectionHeader)" = type { i32, i32, i32, %"Debug::ELF::SectionHeader"* }
%"Debug::ELF::SectionHeader" = type { %"(UInt32 | Nil)", %"(Debug::ELF::SectionHeader::Type | Nil)", %"(Debug::ELF::SectionHeader::Flags | Nil)", %"(UInt32 | UInt64 | Nil)", %"(UInt32 | UInt64 | Nil)", %"(UInt32 | UInt64 | Nil)", %"(UInt32 | Nil)", %"(UInt32 | Nil)", %"(UInt32 | UInt64 | Nil)", %"(UInt32 | UInt64 | Nil)" }
%"(Debug::ELF::SectionHeader::Type | Nil)" = type { i32, [1 x i64] }
%"(Debug::ELF::SectionHeader::Flags | Nil)" = type { i32, [1 x i64] }
%"(Debug::DWARF::Strings | Nil)" = type { i32, [5 x i64] }
%"(Debug::ELF::SectionHeader | Nil)" = type { i32, [20 x i64] }
%"Debug::DWARF::Strings" = type { i32*, %"(UInt32 | UInt64)", %"Slice(UInt8)" }
%"Debug::DWARF::Info" = type { %"(UInt32 | UInt64)", i16, %"(UInt32 | UInt64)", i8, %"Array(Debug::DWARF::Abbrev)"*, i1, i64, i64, i32* }
%"Array(Debug::DWARF::Abbrev)" = type { i32, i32, i32, %"Debug::DWARF::Abbrev"* }
%"Debug::DWARF::Abbrev" = type { i32, i32, %"Array(Debug::DWARF::Abbrev::Attribute)"*, i1 }
%"Array(Debug::DWARF::Abbrev::Attribute)" = type { i32, i32, i32, %"Debug::DWARF::Abbrev::Attribute"* }
%"Debug::DWARF::Abbrev::Attribute" = type { i32, i32 }
%"(Debug::DWARF::Abbrev | Nil)" = type { i32, [3 x i64] }
%"Array(Tuple(Debug::DWARF::AT, Debug::DWARF::FORM, Bool | Int32 | Int64 | Slice(UInt8) | String | UInt16 | UInt32 | UInt64 | UInt8))" = type { i32, i32, i32, %"Tuple(Debug::DWARF::AT, Debug::DWARF::FORM, Bool | Int32 | Int64 | Slice(UInt8) | String | UInt16 | UInt32 | UInt64 | UInt8)"* }
%"Tuple(Debug::DWARF::AT, Debug::DWARF::FORM, Bool | Int32 | Int64 | Slice(UInt8) | String | UInt16 | UInt32 | UInt64 | UInt8)" = type { i32, i32, %"(Bool | Int32 | Int64 | Slice(UInt8) | String | UInt16 | UInt32 | UInt64 | UInt8)" }
%"(Bool | Int32 | Int64 | Slice(UInt8) | String | UInt16 | UInt32 | UInt64 | UInt8)" = type { i32, [2 x i64] }
%"(Bool | Nil)" = type { i32, [1 x i64] }
%"(Bool | Int32 | Int64 | Slice(UInt8) | String | UInt16 | UInt32 | UInt64 | UInt8 | Nil)" = type { i32, [2 x i64] }
%"(Bool.class | Int32.class | Int64.class | Slice(UInt8).class | String.class | UInt16.class | UInt32.class | UInt64.class | UInt8.class)" = type { i32, [1 x i64] }
%"(Bool.class | Int32.class | Int64.class | Nil.class | Slice(UInt8).class | String.class | UInt16.class | UInt32.class | UInt64.class | UInt8.class)" = type { i32, [1 x i64] }
%"(String | UInt64 | Nil)" = type { i32, [1 x i64] }
%"(Nil.class | UInt64.class)" = type { i32, [1 x i64] }
%TypeCastError = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"(Int32 | Int64 | String | UInt16 | UInt32 | UInt64 | UInt8)" = type { i32, [1 x i64] }
%"(UInt8 | Nil)" = type { i32, [1 x i64] }
%"Char::Reader" = type { %String*, i32, i32, i32, %"(UInt8 | Nil)", i1 }
%"(Int32 | UInt32)" = type { i32, [1 x i64] }
%"IO::Error" = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"(Bool | Deque(Fiber) | Nil)" = type { i32, [1 x i64] }
%"struct.LibC::Timeval" = type { i64, i64 }
%"IO::Timeout" = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"(Pointer(Pointer(Void)) | Pointer(Void))" = type { i32, [1 x i64] }
%"Range(Int32, Int32)" = type { i32, i32, i1 }
%"Debug::ELF::Ident" = type { i8, i32, i8, i8, i8 }
%"Debug::ELF::Error" = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"(Debug::ELF::Endianness | Nil)" = type { i32, [1 x i64] }
%"(Debug::ELF::OSABI | Nil)" = type { i32, [1 x i64] }
%"IO::EOFError" = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"(IO::ByteFormat::BigEndian:Module | IO::ByteFormat::LittleEndian:Module)" = type { i32, [1 x i64] }
%"(Bool | IO::Decoder | Nil)" = type { i32, [1 x i64] }
%"(Bool | Slice(UInt8))" = type { i32, [2 x i64] }
%"(Tuple(Char, Int32) | Nil)" = type { i32, [1 x i64] }
%"Tuple(Char, Int32)" = type { i32, i32 }
%"(UInt32 | UInt8 | Nil)" = type { i32, [1 x i64] }
%"Debug::DWARF::LineNumbers::Sequence" = type { %"(Int64 | Nil)", %"(UInt32 | Nil)", %"(UInt16 | Nil)", %"(UInt32 | Nil)", %"(UInt8 | Nil)", i8, %"(Bool | Nil)", %"(Int8 | Nil)", %"(UInt8 | Nil)", %"(UInt8 | Nil)", %"Array(String)"*, %"Array(Tuple(String, Int32, Int32, Int32))"*, %"Array(UInt8)"* }
%"(Int8 | Nil)" = type { i32, [1 x i64] }
%"Array(Tuple(String, Int32, Int32, Int32))" = type { i32, i32, i32, %"Tuple(String, Int32, Int32, Int32)"* }
%"Tuple(String, Int32, Int32, Int32)" = type { %String*, i32, i32, i32 }
%"Array(UInt8)" = type { i32, i32, i32, i8* }
%"Debug::DWARF::LineNumbers::Register" = type { i64, i32, i32, i32, i32, i1, i1, i1, i1, i1, i32, i32 }
%"(Int32 | UInt8)" = type { i32, [1 x i64] }
%"(Int32 | UInt32 | UInt8)" = type { i32, [1 x i64] }
%"(Bool | Debug::DWARF::LineNumbers::Register | Int32 | UInt32 | UInt64 | Nil)" = type { i32, [5 x i64] }
%"(Debug::DWARF::LineNumbers::Register | Int32 | UInt32)" = type { i32, [5 x i64] }
%"(Bool | UInt32 | UInt64 | Nil)" = type { i32, [1 x i64] }
%"(Bool | UInt32 | Nil)" = type { i32, [1 x i64] }
%"(Int32 | UInt32 | UInt64)" = type { i32, [1 x i64] }
%"(UInt16 | UInt32 | UInt8)" = type { i32, [1 x i64] }
%"(Char | Nil)" = type { i32, [1 x i64] }
%"(Tuple(Int32, Int32, Int32) | Nil)" = type { i32, [2 x i64] }
%"(Tuple(Int32) | Tuple(Int32, Int32, Int32, Int32) | Nil)" = type { i32, [2 x i64] }
%"(Tuple(Int32) | Tuple(Int32, Int32, Int32, Int32))" = type { i32, [2 x i64] }
%"Tuple(Int32)" = type { i32 }
%"(Tuple(Int32, Int32, Int32, Int32) | Nil)" = type { i32, [2 x i64] }
%"Crystal::Hasher" = type { i64, i64 }
%"(Tuple(Int32, Int32) | Nil)" = type { i32, [1 x i64] }
%"(Int32 | UInt32 | UInt64 | Nil)" = type { i32, [1 x i64] }
%"String::ToU64Info" = type { i64, i1, i1 }
%"Tuple(Int32, Bool)" = type { i32, i1 }
%"Tuple(IO::FileDescriptor, IO::FileDescriptor)" = type { %"IO::FileDescriptor"*, %"IO::FileDescriptor"* }
%closure_1 = type { i32, %"->" }
%"Channel::ClosedError" = type { i32, %String*, i32*, %"(CallStack | Nil)" }
%"Tuple(String)" = type { %String* }
%"CallStack::RepeatedFrame" = type { i8*, i32 }
@"'skip'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"skip\00" }
@"'sequentially_consis...'" = private constant { i32, i32, i32, [24 x i8] } { i32 1, i32 23, i32 23, [24 x i8] c"sequentially_consistent\00" }
@":symbol_table" = global [2 x %String*] [%String* bitcast ({ i32, i32, i32, [5 x i8] }* @"'skip'" to %String*), %String* bitcast ({ i32, i32, i32, [24 x i8] }* @"'sequentially_consis...'" to %String*)]
@ARGC_UNSAFE = internal global i32 0
@ARGV_UNSAFE = internal global i8** null
@"AtExitHandlers::running" = internal global i1 false
@"AtExitHandlers::running:init" = internal global i1 false
@"Crystal::System::Random::initialized" = internal global i1 false
@"Crystal::System::Random::initialized:init" = internal global i1 false
@"Crystal::System::Random::getrandom_available" = internal global i1 false
@"Crystal::System::Random::getrandom_available:init" = internal global i1 false
@"Int::DIGITS_BASE62" = internal constant %String* bitcast ({ i32, i32, i32, [63 x i8] }* @"'0123456789abcdefghi...'" to %String*)
@"'0123456789abcdefghi...'" = private constant { i32, i32, i32, [63 x i8] } { i32 1, i32 62, i32 62, [63 x i8] c"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\00" }
@"Int::DIGITS_UPCASE" = internal constant %String* bitcast ({ i32, i32, i32, [37 x i8] }* @"'0123456789ABCDEFGHI...'" to %String*)
@"'0123456789ABCDEFGHI...'" = private constant { i32, i32, i32, [37 x i8] } { i32 1, i32 36, i32 36, [37 x i8] c"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\00" }
@"Int::DIGITS_DOWNCASE" = internal constant %String* bitcast ({ i32, i32, i32, [37 x i8] }* @"'0123456789abcdefghi...'.1" to %String*)
@"'0123456789abcdefghi...'.1" = private constant { i32, i32, i32, [37 x i8] } { i32 1, i32 36, i32 36, [37 x i8] c"0123456789abcdefghijklmnopqrstuvwxyz\00" }
@"Debug::ELF::MAGIC" = internal global %"Slice(UInt8)" zeroinitializer
@"Debug::ELF::MAGIC:init" = internal global i1 false
@"'Negative Pointer#ma...'" = private constant { i32, i32, i32, [29 x i8] } { i32 1, i32 28, i32 28, [29 x i8] c"Negative Pointer#malloc size\00" }
@"'Negative size'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"Negative size\00" }
@"'passing a closure t...'" = private constant { i32, i32, i32, [38 x i8] } { i32 1, i32 37, i32 37, [38 x i8] c"passing a closure to C is not allowed\00" }
@"CallStack::CURRENT_DIR" = internal global %String* null
@"CallStack::CURRENT_DIR:init" = internal global i1 false
@"Process::INITIAL_PWD" = internal global %String* null
@"Process::INITIAL_PWD:init" = internal global i1 false
@"'getcwd'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"getcwd\00" }
@"''" = private constant { i32, i32, i32, [1 x i8] } { i32 1, i32 0, i32 0, [1 x i8] zeroinitializer }
@"'Negative capacity'" = private constant { i32, i32, i32, [18 x i8] } { i32 1, i32 17, i32 17, [18 x i8] c"Negative capacity\00" }
@"'Capacity too big'" = private constant { i32, i32, i32, [17 x i8] } { i32 1, i32 16, i32 16, [17 x i8] c"Capacity too big\00" }
@"'Negative count'" = private constant { i32, i32, i32, [15 x i8] } { i32 1, i32 14, i32 14, [15 x i8] c"Negative count\00" }
@"'Bytesize out of cap...'" = private constant { i32, i32, i32, [32 x i8] } { i32 1, i32 31, i32 31, [32 x i8] c"Bytesize out of capacity bounds\00" }
@"String::TYPE_ID" = internal constant i32 1
@"String::TYPE_ID:init" = internal global i1 false
@"'UTF-8'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"UTF-8\00" }
@"'//IGNORE'" = private constant { i32, i32, i32, [9 x i8] } { i32 1, i32 8, i32 8, [9 x i8] c"//IGNORE\00" }
@"'Can only invoke 'to...'" = private constant { i32, i32, i32, [47 x i8] } { i32 1, i32 46, i32 46, [47 x i8] c"Can only invoke 'to_s' once on String::Builder\00" }
@"'Invalid encoding: '" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"Invalid encoding: \00" }
@"' -> '" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c" -> \00" }
@"'iconv_open'" = private constant { i32, i32, i32, [11 x i8] } { i32 1, i32 10, i32 10, [11 x i8] c"iconv_open\00" }
@"'iconv_close'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"iconv_close\00" }
@"'Incomplete multibyt...'" = private constant { i32, i32, i32, [30 x i8] } { i32 1, i32 29, i32 29, [30 x i8] c"Incomplete multibyte sequence\00" }
@"'Invalid multibyte s...'" = private constant { i32, i32, i32, [27 x i8] } { i32 1, i32 26, i32 26, [27 x i8] c"Invalid multibyte sequence\00" }
@"'Index out of bounds...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"Index out of bounds\00" }
@"': '" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c": \00" }
@"'Invalid char value ...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"Invalid char value \00" }
@"''\5C'''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5C''\00" }
@"''\5C\5C''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5C\5C'\00" }
@"''\5Ca''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Ca'\00" }
@"''\5Cb''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Cb'\00" }
@"''\5Ce''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Ce'\00" }
@"''\5Cf''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Cf'\00" }
@"''\5Cn''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Cn'\00" }
@"''\5Cr''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Cr'\00" }
@"''\5Ct''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Ct'\00" }
@"''\5Cv''" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"'\5Cv'\00" }
@"'\5Cu{'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"\5Cu{\00" }
@"'Invalid base '" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"Invalid base \00" }
@"'upcase must be fals...'" = private constant { i32, i32, i32, [33 x i8] } { i32 1, i32 32, i32 32, [33 x i8] c"upcase must be false for base 62\00" }
@"Int::DIGITS_BASE62:init" = internal global i1 false
@"Int::DIGITS_UPCASE:init" = internal global i1 false
@"Int::DIGITS_DOWNCASE:init" = internal global i1 false
@"'Division by 0'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"Division by 0\00" }
@"'Overflow: Int32::MI...'" = private constant { i32, i32, i32, [26 x i8] } { i32 1, i32 25, i32 25, [26 x i8] c"Overflow: Int32::MIN / -1\00" }
@"CallStack::skip" = internal global %"Array(String)"* null
@"CallStack::skip:init" = internal global i1 false
@"'/usr/share/crystal/...'" = private constant { i32, i32, i32, [36 x i8] } { i32 1, i32 35, i32 35, [36 x i8] c"/usr/share/crystal/src/callstack.cr\00" }
@"'/usr/share/crystal/...'.2" = private constant { i32, i32, i32, [36 x i8] } { i32 1, i32 35, i32 35, [36 x i8] c"/usr/share/crystal/src/exception.cr\00" }
@"LibC::SIG_DFL" = internal global %"->" zeroinitializer
@"LibC::SIG_DFL:init" = internal global i1 false
@"LibC::SIG_IGN" = internal global %"->" zeroinitializer
@"LibC::SIG_IGN:init" = internal global i1 false
@"String::CHAR_TO_DIGIT" = internal global [256 x i8] zeroinitializer
@"String::CHAR_TO_DIGIT:init" = internal global i1 false
@"String::CHAR_TO_DIGIT62" = internal global [256 x i8] zeroinitializer
@"String::CHAR_TO_DIGIT62:init" = internal global i1 false
@"LibC::MAP_FAILED" = internal global i8* null
@"LibC::MAP_FAILED:init" = internal global i1 false
@"Fiber::fibers" = internal global %"Thread::LinkedList(Fiber)" zeroinitializer
@"Fiber::fibers:init" = internal global i1 false
@"'pthread_mutex_init'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"pthread_mutex_init\00" }
@"'pthread_mutex_destr...'" = private constant { i32, i32, i32, [22 x i8] } { i32 1, i32 21, i32 21, [22 x i8] c"pthread_mutex_destroy\00" }
@"Fiber::stack_pool" = internal global %"Fiber::StackPool"* null
@"Fiber::stack_pool:init" = internal global i1 false
@"Crystal::EventLoop::eb" = internal global %"Crystal::Event::Base" zeroinitializer
@"Crystal::EventLoop::eb:init" = internal global i1 false
@"Thread::threads" = internal global %"Thread::LinkedList(Thread)" zeroinitializer
@"Thread::threads:init" = internal global i1 false
@"'pthread_attr_destro...'" = private constant { i32, i32, i32, [21 x i8] } { i32 1, i32 20, i32 20, [21 x i8] c"pthread_attr_destroy\00" }
@GC_stackbottom = external global i8*
@"'main'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"main\00" }
@"'pthread_mutex_lock'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"pthread_mutex_lock\00" }
@"'pthread_mutex_unloc...'" = private constant { i32, i32, i32, [21 x i8] } { i32 1, i32 20, i32 20, [21 x i8] c"pthread_mutex_unlock\00" }
@"Thread::current" = thread_local global %Thread* null
@"File::DEFAULT_CREATE_PERMISSIONS" = internal global i16 0
@"File::DEFAULT_CREATE_PERMISSIONS:init" = internal global i1 false
@"GC::curr_push_other_roots" = global %"->" zeroinitializer
@"GC::prev_push_other_roots" = global %"->" zeroinitializer
@"Crystal::Hasher::seed" = global [2 x i64] zeroinitializer
@"'BUG: Thread.current...'" = private constant { i32, i32, i32, [34 x i8] } { i32 1, i32 33, i32 33, [34 x i8] c"BUG: Thread.current returned NULL\00" }
@"'Nil assertion faile...'" = private constant { i32, i32, i32, [21 x i8] } { i32 1, i32 20, i32 20, [21 x i8] c"Nil assertion failed\00" }
@"'Time::Span too big ...'" = private constant { i32, i32, i32, [32 x i8] } { i32 1, i32 31, i32 31, [32 x i8] c"Time::Span too big or too small\00" }
@"'Overflow: Int64::MI...'" = private constant { i32, i32, i32, [26 x i8] } { i32 1, i32 25, i32 25, [26 x i8] c"Overflow: Int64::MIN / -1\00" }
@"'tried to resume a d...'" = private constant { i32, i32, i32, [29 x i8] } { i32 1, i32 28, i32 28, [29 x i8] c"tried to resume a dead fiber\00" }
@"'\0A'" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c"\0A\00" }
@"'FATAL: '" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"FATAL: \00" }
@"'#<'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"#<\00" }
@"'Fiber'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Fiber\00" }
@"':0x'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c":0x\00" }
@"'Overflow: UInt64::M...'" = private constant { i32, i32, i32, [27 x i8] } { i32 1, i32 26, i32 26, [27 x i8] c"Overflow: UInt64::MIN / -1\00" }
@"'CRYSTAL_CALLSTACK_F...'" = private constant { i32, i32, i32, [28 x i8] } { i32 1, i32 27, i32 27, [28 x i8] c"CRYSTAL_CALLSTACK_FULL_INFO\00" }
@"'key'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"key\00" }
@"'`'" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c"`\00" }
@"'` '" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"` \00" }
@"'String '" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"String \00" }
@"'contains null byte'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"contains null byte\00" }
@"'1'" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c"1\00" }
@"CallStack::base_address" = global %"(UInt32 | UInt64 | Nil)" zeroinitializer
@"CallStack::dwarf_line_numbers" = global %"(Debug::DWARF::LineNumbers | Nil)" zeroinitializer
@PROGRAM_NAME = internal global %String* null
@"PROGRAM_NAME:init" = internal global i1 false
@"'r'" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c"r\00" }
@"'No file open mode s...'" = private constant { i32, i32, i32, [28 x i8] } { i32 1, i32 27, i32 27, [28 x i8] c"No file open mode specified\00" }
@"'Invalid file open m...'" = private constant { i32, i32, i32, [26 x i8] } { i32 1, i32 25, i32 25, [26 x i8] c"Invalid file open mode: '\00" }
@"'''" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c"'\00" }
@"'Error opening file ...'" = private constant { i32, i32, i32, [21 x i8] } { i32 1, i32 20, i32 20, [21 x i8] c"Error opening file '\00" }
@"'\5C\22'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5C\22\00" }
@"'\5C\5C'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5C\5C\00" }
@"'\5Ca'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Ca\00" }
@"'\5Cb'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Cb\00" }
@"'\5Ce'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Ce\00" }
@"'\5Cf'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Cf\00" }
@"'\5Cn'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Cn\00" }
@"'\5Cr'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Cr\00" }
@"'\5Ct'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Ct\00" }
@"'\5Cv'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Cv\00" }
@"'\5C#{'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"\5C#{\00" }
@"'\5Cx'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Cx\00" }
@"'Overflow: UInt8::MI...'" = private constant { i32, i32, i32, [26 x i8] } { i32 1, i32 25, i32 25, [26 x i8] c"Overflow: UInt8::MIN / -1\00" }
@"'\5Cu'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"\5Cu\00" }
@"'' with mode ''" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"' with mode '\00" }
@"'fcntl() failed'" = private constant { i32, i32, i32, [15 x i8] } { i32 1, i32 14, i32 14, [15 x i8] c"fcntl() failed\00" }
@"'Error writing file'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"Error writing file\00" }
@"'File not open for w...'" = private constant { i32, i32, i32, [26 x i8] } { i32 1, i32 25, i32 25, [26 x i8] c"File not open for writing\00" }
@"Crystal::EventLoop::loop_fiber" = global %Fiber* null
@"'Cannot allocate new...'" = private constant { i32, i32, i32, [32 x i8] } { i32 1, i32 31, i32 31, [32 x i8] c"Cannot allocate new fiber stack\00" }
@STDERR = internal global %"IO::FileDescriptor"* null
@"STDERR:init" = internal global i1 false
@"'Write timed out'" = private constant { i32, i32, i32, [16 x i8] } { i32 1, i32 15, i32 15, [16 x i8] c"Write timed out\00" }
@"'Error closing file'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"Error closing file\00" }
@"'Unhandled exception...'" = private constant { i32, i32, i32, [36 x i8] } { i32 1, i32 35, i32 35, [36 x i8] c"Unhandled exception in spawn(name: \00" }
@"'): '" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"): \00" }
@"'Closed stream'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"Closed stream\00" }
@"'Unhandled exception...'.3" = private constant { i32, i32, i32, [31 x i8] } { i32 1, i32 30, i32 30, [31 x i8] c"Unhandled exception in spawn: \00" }
@"' ('" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c" (\00" }
@"'Time::Location::Inv...'" = private constant { i32, i32, i32, [43 x i8] } { i32 1, i32 42, i32 42, [43 x i8] c"Time::Location::InvalidTimezoneOffsetError\00" }
@"'Time::Location::Inv...'.4" = private constant { i32, i32, i32, [41 x i8] } { i32 1, i32 40, i32 40, [41 x i8] c"Time::Location::InvalidLocationNameError\00" }
@"'Time::Location::Inv...'.5" = private constant { i32, i32, i32, [35 x i8] } { i32 1, i32 34, i32 34, [35 x i8] c"Time::Location::InvalidTZDataError\00" }
@"'Time::Format::Error...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"Time::Format::Error\00" }
@"'Time::FloatingTimeC...'" = private constant { i32, i32, i32, [34 x i8] } { i32 1, i32 33, i32 33, [34 x i8] c"Time::FloatingTimeConversionError\00" }
@"'Base64::Error'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"Base64::Error\00" }
@"'Path::Error'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"Path::Error\00" }
@"'File::BadPatternErr...'" = private constant { i32, i32, i32, [22 x i8] } { i32 1, i32 21, i32 21, [22 x i8] c"File::BadPatternError\00" }
@"'Errno'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Errno\00" }
@"'ConcurrentExecution...'" = private constant { i32, i32, i32, [29 x i8] } { i32 1, i32 28, i32 28, [29 x i8] c"ConcurrentExecutionException\00" }
@"'Concurrent::Cancele...'" = private constant { i32, i32, i32, [26 x i8] } { i32 1, i32 25, i32 25, [26 x i8] c"Concurrent::CanceledError\00" }
@"'Channel::ClosedErro...'" = private constant { i32, i32, i32, [21 x i8] } { i32 1, i32 20, i32 20, [21 x i8] c"Channel::ClosedError\00" }
@"'IO::EOFError'" = private constant { i32, i32, i32, [13 x i8] } { i32 1, i32 12, i32 12, [13 x i8] c"IO::EOFError\00" }
@"'IO::Error'" = private constant { i32, i32, i32, [10 x i8] } { i32 1, i32 9, i32 9, [10 x i8] c"IO::Error\00" }
@"'IO::Timeout'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"IO::Timeout\00" }
@"'Enumerable::EmptyEr...'" = private constant { i32, i32, i32, [23 x i8] } { i32 1, i32 22, i32 22, [23 x i8] c"Enumerable::EmptyError\00" }
@"'NilAssertionError'" = private constant { i32, i32, i32, [18 x i8] } { i32 1, i32 17, i32 17, [18 x i8] c"NilAssertionError\00" }
@"'NotImplementedError...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"NotImplementedError\00" }
@"'OverflowError'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"OverflowError\00" }
@"'DivisionByZeroError...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"DivisionByZeroError\00" }
@"'KeyError'" = private constant { i32, i32, i32, [9 x i8] } { i32 1, i32 8, i32 8, [9 x i8] c"KeyError\00" }
@"'InvalidByteSequence...'" = private constant { i32, i32, i32, [25 x i8] } { i32 1, i32 24, i32 24, [25 x i8] c"InvalidByteSequenceError\00" }
@"'TypeCastError'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"TypeCastError\00" }
@"'ArgumentError'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"ArgumentError\00" }
@"'IndexError'" = private constant { i32, i32, i32, [11 x i8] } { i32 1, i32 10, i32 10, [11 x i8] c"IndexError\00" }
@"'Debug::ELF::Error'" = private constant { i32, i32, i32, [18 x i8] } { i32 1, i32 17, i32 17, [18 x i8] c"Debug::ELF::Error\00" }
@"'Exception'" = private constant { i32, i32, i32, [10 x i8] } { i32 1, i32 9, i32 9, [10 x i8] c"Exception\00" }
@"')\0A'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c")\0A\00" }
@"' from '" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c" from \00" }
@"'Caused by: '" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"Caused by: \00" }
@"'Error reading file'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"Error reading file\00" }
@"'Read timed out'" = private constant { i32, i32, i32, [15 x i8] } { i32 1, i32 14, i32 14, [15 x i8] c"Read timed out\00" }
@"'Can't write to read...'" = private constant { i32, i32, i32, [31 x i8] } { i32 1, i32 30, i32 30, [31 x i8] c"Can't write to read-only Slice\00" }
@"'Invalid magic numbe...'" = private constant { i32, i32, i32, [21 x i8] } { i32 1, i32 20, i32 20, [21 x i8] c"Invalid magic number\00" }
@"'Unknown enum '" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"Unknown enum \00" }
@"'Debug::ELF::Endiann...'" = private constant { i32, i32, i32, [23 x i8] } { i32 1, i32 22, i32 22, [23 x i8] c"Debug::ELF::Endianness\00" }
@"' value: '" = private constant { i32, i32, i32, [9 x i8] } { i32 1, i32 8, i32 8, [9 x i8] c" value: \00" }
@"'Unsupported version...'" = private constant { i32, i32, i32, [27 x i8] } { i32 1, i32 26, i32 26, [27 x i8] c"Unsupported version number\00" }
@"'Debug::ELF::OSABI'" = private constant { i32, i32, i32, [18 x i8] } { i32 1, i32 17, i32 17, [18 x i8] c"Debug::ELF::OSABI\00" }
@"'End of file reached...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"End of file reached\00" }
@"'Unsupported'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"Unsupported\00" }
@"'Header should be 52...'" = private constant { i32, i32, i32, [36 x i8] } { i32 1, i32 35, i32 35, [36 x i8] c"Header should be 52 bytes for ELF32\00" }
@"'Header should be 64...'" = private constant { i32, i32, i32, [36 x i8] } { i32 1, i32 35, i32 35, [36 x i8] c"Header should be 64 bytes for ELF64\00" }
@"'.text'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c".text\00" }
@"'Negative array size...'" = private constant { i32, i32, i32, [22 x i8] } { i32 1, i32 21, i32 21, [22 x i8] c"Negative array size: \00" }
@"'Unable to seek'" = private constant { i32, i32, i32, [15 x i8] } { i32 1, i32 14, i32 14, [15 x i8] c"Unable to seek\00" }
@"'Unable to tell'" = private constant { i32, i32, i32, [15 x i8] } { i32 1, i32 14, i32 14, [15 x i8] c"Unable to tell\00" }
@"'Negative limit'" = private constant { i32, i32, i32, [15 x i8] } { i32 1, i32 14, i32 14, [15 x i8] c"Negative limit\00" }
@"'Invalid back amount...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"Invalid back amount\00" }
@"'Incomplete UTF-8 by...'" = private constant { i32, i32, i32, [31 x i8] } { i32 1, i32 30, i32 30, [31 x i8] c"Incomplete UTF-8 byte sequence\00" }
@"'Unexpected byte 0x'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"Unexpected byte 0x\00" }
@"'0'" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c"0\00" }
@"'Overflow: UInt32::M...'" = private constant { i32, i32, i32, [27 x i8] } { i32 1, i32 26, i32 26, [27 x i8] c"Overflow: UInt32::MIN / -1\00" }
@"' in UTF-8 byte sequ...'" = private constant { i32, i32, i32, [24 x i8] } { i32 1, i32 23, i32 23, [24 x i8] c" in UTF-8 byte sequence\00" }
@"'.debug_line'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c".debug_line\00" }
@"'.debug_str'" = private constant { i32, i32, i32, [11 x i8] } { i32 1, i32 10, i32 10, [11 x i8] c".debug_str\00" }
@"'.debug_info'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c".debug_info\00" }
@"'.debug_abbrev'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c".debug_abbrev\00" }
@"'Invalid address siz...'" = private constant { i32, i32, i32, [23 x i8] } { i32 1, i32 22, i32 22, [23 x i8] c"Invalid address size: \00" }
@"'Unknown DW_FORM_'" = private constant { i32, i32, i32, [17 x i8] } { i32 1, i32 16, i32 16, [17 x i8] c"Unknown DW_FORM_\00" }
@"'Addr'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Addr\00" }
@"'Block2'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"Block2\00" }
@"'Block4'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"Block4\00" }
@"'Data2'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Data2\00" }
@"'Data4'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Data4\00" }
@"'Data8'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Data8\00" }
@"'String'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"String\00" }
@"'Block'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Block\00" }
@"'Block1'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"Block1\00" }
@"'Data1'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Data1\00" }
@"'Flag'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Flag\00" }
@"'Sdata'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Sdata\00" }
@"'Strp'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Strp\00" }
@"'Udata'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Udata\00" }
@"'RefAddr'" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"RefAddr\00" }
@"'Ref1'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Ref1\00" }
@"'Ref2'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Ref2\00" }
@"'Ref4'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Ref4\00" }
@"'Ref8'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Ref8\00" }
@"'RefUdata'" = private constant { i32, i32, i32, [9 x i8] } { i32 1, i32 8, i32 8, [9 x i8] c"RefUdata\00" }
@"'Indirect'" = private constant { i32, i32, i32, [9 x i8] } { i32 1, i32 8, i32 8, [9 x i8] c"Indirect\00" }
@"'SecOffset'" = private constant { i32, i32, i32, [10 x i8] } { i32 1, i32 9, i32 9, [10 x i8] c"SecOffset\00" }
@"'Exprloc'" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"Exprloc\00" }
@"'FlagPresent'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"FlagPresent\00" }
@"'RefSig8'" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"RefSig8\00" }
@"', expected 2 to 36'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c", expected 2 to 36\00" }
@"Unicode::category_Ll" = global %"Array(Tuple(Int32, Int32, Int32))"* null
@"Unicode::category_Lu" = global %"Array(Tuple(Int32, Int32, Int32))"* null
@"Unicode::casefold_ranges" = global %"Array(Tuple(Int32, Int32, Int32))"* null
@"Unicode::fold_cases" = global %"Hash(Int32, Tuple(Int32, Int32, Int32, Int32))"* null
@"Hash::HASH_PRIMES" = internal global %"Array(Int32)"* null
@"Hash::HASH_PRIMES:init" = internal global i1 false
@"'Hash table too big'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"Hash table too big\00" }
@"Unicode::downcase_ranges" = global %"Array(Tuple(Int32, Int32, Int32))"* null
@"' out of char range'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c" out of char range\00" }
@"Unicode::alternate_ranges" = global %"Array(Tuple(Int32, Int32))"* null
@"'cast from '" = private constant { i32, i32, i32, [11 x i8] } { i32 1, i32 10, i32 10, [11 x i8] c"cast from \00" }
@"'Bool'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"Bool\00" }
@"'Int32'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Int32\00" }
@"'Int64'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"Int64\00" }
@"'Slice(UInt8)'" = private constant { i32, i32, i32, [13 x i8] } { i32 1, i32 12, i32 12, [13 x i8] c"Slice(UInt8)\00" }
@"'UInt16'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"UInt16\00" }
@"'UInt32'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"UInt32\00" }
@"'UInt64'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"UInt64\00" }
@"'UInt8'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"UInt8\00" }
@"' to (UInt32 | UInt6...'" = private constant { i32, i32, i32, [29 x i8] } { i32 1, i32 28, i32 28, [29 x i8] c" to (UInt32 | UInt64) failed\00" }
@"', at /usr/share/cry...'" = private constant { i32, i32, i32, [50 x i8] } { i32 1, i32 49, i32 49, [50 x i8] c", at /usr/share/crystal/src/callstack.cr:218:3:33\00" }
@"'Nil'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"Nil\00" }
@"' to String failed'" = private constant { i32, i32, i32, [18 x i8] } { i32 1, i32 17, i32 17, [18 x i8] c" to String failed\00" }
@"', at /usr/share/cry...'.6" = private constant { i32, i32, i32, [50 x i8] } { i32 1, i32 49, i32 49, [50 x i8] c", at /usr/share/crystal/src/callstack.cr:218:3:34\00" }
@"' to UInt64 failed'" = private constant { i32, i32, i32, [18 x i8] } { i32 1, i32 17, i32 17, [18 x i8] c" to UInt64 failed\00" }
@"', at /usr/share/cry...'.7" = private constant { i32, i32, i32, [50 x i8] } { i32 1, i32 49, i32 49, [50 x i8] c", at /usr/share/crystal/src/callstack.cr:218:3:36\00" }
@"', at /usr/share/cry...'.8" = private constant { i32, i32, i32, [50 x i8] } { i32 1, i32 49, i32 49, [50 x i8] c", at /usr/share/crystal/src/callstack.cr:218:3:39\00" }
@"', at /usr/share/cry...'.9" = private constant { i32, i32, i32, [50 x i8] } { i32 1, i32 49, i32 49, [50 x i8] c", at /usr/share/crystal/src/callstack.cr:218:3:41\00" }
@"'Invalid Int32: '" = private constant { i32, i32, i32, [16 x i8] } { i32 1, i32 15, i32 15, [16 x i8] c"Invalid Int32: \00" }
@"CallStack::dwarf_function_names" = global %"Array(Tuple(UInt64, UInt64, String))"* null
@"'/'" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c"/\00" }
@"'??'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"??\00" }
@"':'" = private constant { i32, i32, i32, [2 x i8] } { i32 1, i32 1, i32 1, [2 x i8] c":\00" }
@"'*raise<'" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"*raise<\00" }
@"'*CallStack::'" = private constant { i32, i32, i32, [13 x i8] } { i32 1, i32 12, i32 12, [13 x i8] c"*CallStack::\00" }
@"'*CallStack#'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"*CallStack#\00" }
@"'???'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"???\00" }
@"' in ''" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c" in '\00" }
@"' at 0x'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c" at 0x\00" }
@"AtExitHandlers::handlers" = global %"Array(Proc(Int32, (Exception+ | Nil), Nil))"* null
@"AtExitHandlers::exception" = global i32* null
@"'Error running at_ex...'" = private constant { i32, i32, i32, [32 x i8] } { i32 1, i32 31, i32 31, [32 x i8] c"Error running at_exit handler: \00" }
@"'Unhandled exception...'.10" = private constant { i32, i32, i32, [22 x i8] } { i32 1, i32 21, i32 21, [22 x i8] c"Unhandled exception: \00" }
@STDOUT = internal global %"IO::FileDescriptor"* null
@"STDOUT:init" = internal global i1 false
@"'can't resume a runn...'" = private constant { i32, i32, i32, [29 x i8] } { i32 1, i32 28, i32 28, [29 x i8] c"can't resume a running fiber\00" }
@"'/dev/urandom'" = private constant { i32, i32, i32, [13 x i8] } { i32 1, i32 12, i32 12, [13 x i8] c"/dev/urandom\00" }
@"'Unable to get info'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"Unable to get info\00" }
@"Crystal::System::Random::urandom" = global %File* null
@"'getrandom'" = private constant { i32, i32, i32, [10 x i8] } { i32 1, i32 9, i32 9, [10 x i8] c"getrandom\00" }
@"'Failed to access se...'" = private constant { i32, i32, i32, [57 x i8] } { i32 1, i32 56, i32 56, [57 x i8] c"Failed to access secure source to generate random bytes!\00" }
@"'Sleep seconds must ...'" = private constant { i32, i32, i32, [31 x i8] } { i32 1, i32 30, i32 30, [31 x i8] c"Sleep seconds must be positive\00" }
@"Signal::setup_default_handlers" = internal global %"Atomic(Int32)" zeroinitializer
@"Signal::setup_default_handlers:init" = internal global i1 false
@"Signal::sigset" = internal global %"struct.LibC::SigsetT" zeroinitializer
@"Signal::sigset:init" = internal global i1 false
@"Crystal::Signal::pipe" = internal global %"Tuple(IO::FileDescriptor+, IO::FileDescriptor+)" zeroinitializer
@"Crystal::Signal::pipe:init" = internal global i1 false
@"'Could not create pi...'" = private constant { i32, i32, i32, [22 x i8] } { i32 1, i32 21, i32 21, [22 x i8] c"Could not create pipe\00" }
@"Crystal::Signal::handlers" = internal global %"Hash(Signal, Proc(Signal, Nil))"* null
@"Crystal::Signal::handlers:init" = internal global i1 false
@"'uncaught exception ...'" = private constant { i32, i32, i32, [49 x i8] } { i32 1, i32 48, i32 48, [49 x i8] c"uncaught exception while processing handler for \00" }
@"'HUP'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"HUP\00" }
@"'INT'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"INT\00" }
@"'QUIT'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"QUIT\00" }
@"'ILL'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"ILL\00" }
@"'TRAP'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"TRAP\00" }
@"'IOT'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"IOT\00" }
@"'ABRT'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"ABRT\00" }
@"'FPE'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"FPE\00" }
@"'KILL'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"KILL\00" }
@"'BUS'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"BUS\00" }
@"'SEGV'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"SEGV\00" }
@"'SYS'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"SYS\00" }
@"'PIPE'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"PIPE\00" }
@"'ALRM'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"ALRM\00" }
@"'TERM'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"TERM\00" }
@"'URG'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"URG\00" }
@"'STOP'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"STOP\00" }
@"'TSTP'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"TSTP\00" }
@"'CONT'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"CONT\00" }
@"'CHLD'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"CHLD\00" }
@"'TTIN'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"TTIN\00" }
@"'TTOU'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"TTOU\00" }
@"'IO'" = private constant { i32, i32, i32, [3 x i8] } { i32 1, i32 2, i32 2, [3 x i8] c"IO\00" }
@"'XCPU'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"XCPU\00" }
@"'XFSZ'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"XFSZ\00" }
@"'VTALRM'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"VTALRM\00" }
@"'USR1'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"USR1\00" }
@"'USR2'" = private constant { i32, i32, i32, [5 x i8] } { i32 1, i32 4, i32 4, [5 x i8] c"USR2\00" }
@"'WINCH'" = private constant { i32, i32, i32, [6 x i8] } { i32 1, i32 5, i32 5, [6 x i8] c"WINCH\00" }
@"'PWR'" = private constant { i32, i32, i32, [4 x i8] } { i32 1, i32 3, i32 3, [4 x i8] c"PWR\00" }
@"'STKFLT'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"STKFLT\00" }
@"'UNUSED'" = private constant { i32, i32, i32, [7 x i8] } { i32 1, i32 6, i32 6, [7 x i8] c"UNUSED\00" }
@"', exiting'" = private constant { i32, i32, i32, [10 x i8] } { i32 1, i32 9, i32 9, [10 x i8] c", exiting\00" }
@"'missing handler for...'" = private constant { i32, i32, i32, [21 x i8] } { i32 1, i32 20, i32 20, [21 x i8] c"missing handler for \00" }
@"Crystal::Signal::child_handler" = global %"->" zeroinitializer
@"'waitpid'" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"waitpid\00" }
@"Crystal::SignalChildHandler::mutex" = internal global %Mutex* null
@"Crystal::SignalChildHandler::mutex:init" = internal global i1 false
@"Crystal::SignalChildHandler::waiting" = internal global %"Hash(Int32, Channel::Buffered(Int32))"* null
@"Crystal::SignalChildHandler::waiting:init" = internal global i1 false
@"'Attempt to unlock a...'" = private constant { i32, i32, i32, [46 x i8] } { i32 1, i32 45, i32 45, [46 x i8] c"Attempt to unlock a mutex which is not locked\00" }
@"'Channel is closed'" = private constant { i32, i32, i32, [18 x i8] } { i32 1, i32 17, i32 17, [18 x i8] c"Channel is closed\00" }
@"Crystal::SignalChildHandler::pending" = internal global %"Hash(Int32, Int32)"* null
@"Crystal::SignalChildHandler::pending:init" = internal global i1 false
@"Crystal::Signal::mutex" = internal global %Mutex* null
@"Crystal::Signal::mutex:init" = internal global i1 false
@"'/usr/share/crystal/...'.11" = private constant { i32, i32, i32, [32 x i8] } { i32 1, i32 31, i32 31, [32 x i8] c"/usr/share/crystal/src/raise.cr\00" }
@pcre_malloc = external global i8* (i64)*
@pcre_free = external global %Nil (i8*)*
@"Time::Location::location_cache" = internal global %"Hash(String, NamedTuple(time: Time, location: Time::Location))"* null
@"Time::Location::location_cache:init" = internal global i1 false
@"'HELLO!\0A'" = private constant { i32, i32, i32, [8 x i8] } { i32 1, i32 7, i32 7, [8 x i8] c"HELLO!\0A\00" }
@"'Failed to raise an ...'" = private constant { i32, i32, i32, [34 x i8] } { i32 1, i32 33, i32 33, [34 x i8] c"Failed to raise an exception: %s\0A\00" }
@"'NO_REASON'" = private constant { i32, i32, i32, [10 x i8] } { i32 1, i32 9, i32 9, [10 x i8] c"NO_REASON\00" }
@"'FOREIGN_EXCEPTION_C...'" = private constant { i32, i32, i32, [25 x i8] } { i32 1, i32 24, i32 24, [25 x i8] c"FOREIGN_EXCEPTION_CAUGHT\00" }
@"'FATAL_PHASE2_ERROR'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"FATAL_PHASE2_ERROR\00" }
@"'FATAL_PHASE1_ERROR'" = private constant { i32, i32, i32, [19 x i8] } { i32 1, i32 18, i32 18, [19 x i8] c"FATAL_PHASE1_ERROR\00" }
@"'NORMAL_STOP'" = private constant { i32, i32, i32, [12 x i8] } { i32 1, i32 11, i32 11, [12 x i8] c"NORMAL_STOP\00" }
@"'END_OF_STACK'" = private constant { i32, i32, i32, [13 x i8] } { i32 1, i32 12, i32 12, [13 x i8] c"END_OF_STACK\00" }
@"'HANDLER_FOUND'" = private constant { i32, i32, i32, [14 x i8] } { i32 1, i32 13, i32 13, [14 x i8] c"HANDLER_FOUND\00" }
@"'INSTALL_CONTEXT'" = private constant { i32, i32, i32, [16 x i8] } { i32 1, i32 15, i32 15, [16 x i8] c"INSTALL_CONTEXT\00" }
@"'CONTINUE_UNWIND'" = private constant { i32, i32, i32, [16 x i8] } { i32 1, i32 15, i32 15, [16 x i8] c"CONTINUE_UNWIND\00" }
@"'[0x%lx] %s +%ld\0A'" = private constant { i32, i32, i32, [17 x i8] } { i32 1, i32 16, i32 16, [17 x i8] c"[0x%lx] %s +%ld\0A\00" }
@"'[0x%lx] %s +%ld (%l...'" = private constant { i32, i32, i32, [29 x i8] } { i32 1, i32 28, i32 28, [29 x i8] c"[0x%lx] %s +%ld (%ld times)\0A\00" }
@"'[0x%lx] ???\0A'" = private constant { i32, i32, i32, [13 x i8] } { i32 1, i32 12, i32 12, [13 x i8] c"[0x%lx] ???\0A\00" }
@"'[0x%lx] ??? (%ld ti...'" = private constant { i32, i32, i32, [25 x i8] } { i32 1, i32 24, i32 24, [25 x i8] c"[0x%lx] ??? (%ld times)\0A\00" }
@"'Arithmetic overflow...'" = private constant { i32, i32, i32, [20 x i8] } { i32 1, i32 19, i32 19, [20 x i8] c"Arithmetic overflow\00" }
@"'Stack overflow (e.g...'" = private constant { i32, i32, i32, [56 x i8] } { i32 1, i32 55, i32 55, [56 x i8] c"Stack overflow (e.g., infinite or very deep recursion)\0A\00" }
@"'Invalid memory acce...'" = private constant { i32, i32, i32, [52 x i8] } { i32 1, i32 51, i32 51, [52 x i8] c"Invalid memory access (signal %d) at address 0x%lx\0A\00" }
define void @__crystal_main(i32 %argc, i8** %argv) !dbg !4 {
alloca:
%0 = alloca %"->", !dbg !9
%1 = alloca %"Slice(UInt8)", !dbg !12
%2 = alloca %"->", !dbg !15
%3 = alloca %"->", !dbg !18
%4 = alloca %"->", !dbg !18
%5 = alloca %"->", !dbg !21
%6 = alloca %"->", !dbg !21
br label %entry
entry: ; preds = %alloca
store i32 %argc, i32* @ARGC_UNSAFE
store i8** %argv, i8*** @ARGV_UNSAFE
%7 = load i1, i1* @"AtExitHandlers::running:init"
br i1 %7, label %initialized, label %not_initialized
initialized: ; preds = %not_initialized, %entry
%8 = load i1, i1* @"Crystal::System::Random::initialized:init"
br i1 %8, label %initialized1, label %not_initialized2
not_initialized: ; preds = %entry
store i1 true, i1* @"AtExitHandlers::running:init"
call void @"~AtExitHandlers::running:init"()
br label %initialized
initialized1: ; preds = %not_initialized2, %initialized
%9 = load i1, i1* @"Crystal::System::Random::getrandom_available:init"
br i1 %9, label %initialized3, label %not_initialized4
not_initialized2: ; preds = %initialized
store i1 true, i1* @"Crystal::System::Random::initialized:init"
call void @"~Crystal::System::Random::initialized:init"()
br label %initialized1
initialized3: ; preds = %not_initialized4, %initialized1
%10 = load i1, i1* @"Debug::ELF::MAGIC:init", !dbg !22
br i1 %10, label %initialized5, label %not_initialized6, !dbg !22
not_initialized4: ; preds = %initialized1
store i1 true, i1* @"Crystal::System::Random::getrandom_available:init"
call void @"~Crystal::System::Random::getrandom_available:init"()
br label %initialized3
initialized5: ; preds = %not_initialized6, %initialized3
%11 = load i1, i1* @"CallStack::CURRENT_DIR:init", !dbg !25
br i1 %11, label %initialized7, label %not_initialized8, !dbg !25
not_initialized6: ; preds = %initialized3
store i1 true, i1* @"Debug::ELF::MAGIC:init", !dbg !22
call void @"~Debug::ELF::MAGIC:init"()
br label %initialized5
initialized7: ; preds = %not_initialized8, %initialized5
%12 = load i1, i1* @"CallStack::skip:init"
br i1 %12, label %initialized9, label %not_initialized10
not_initialized8: ; preds = %initialized5
store i1 true, i1* @"CallStack::CURRENT_DIR:init", !dbg !25
call void @"~CallStack::CURRENT_DIR:init"()
br label %initialized7
initialized9: ; preds = %not_initialized10, %initialized7
%13 = call %"Array(String)"* @"*CallStack::skip<String>:Array(String)"(%String* bitcast ({ i32, i32, i32, [36 x i8] }* @"'/usr/share/crystal/...'" to %String*)), !dbg !28
%14 = call %"Array(String)"* @"*CallStack::skip<String>:Array(String)"(%String* bitcast ({ i32, i32, i32, [36 x i8] }* @"'/usr/share/crystal/...'.2" to %String*)), !dbg !31
%15 = load i1, i1* @"LibC::SIG_DFL:init", !dbg !34
br i1 %15, label %initialized11, label %not_initialized12, !dbg !34
not_initialized10: ; preds = %initialized7
store i1 true, i1* @"CallStack::skip:init"
call void @"~CallStack::skip:init"()
br label %initialized9
initialized11: ; preds = %not_initialized12, %initialized9
%16 = load i1, i1* @"LibC::SIG_IGN:init"
br i1 %16, label %initialized13, label %not_initialized14
not_initialized12: ; preds = %initialized9
store i1 true, i1* @"LibC::SIG_DFL:init", !dbg !34
call void @"~LibC::SIG_DFL:init"()
br label %initialized11
initialized13: ; preds = %not_initialized14, %initialized11
%17 = load i1, i1* @"String::CHAR_TO_DIGIT:init"
br i1 %17, label %initialized15, label %not_initialized16
not_initialized14: ; preds = %initialized11
store i1 true, i1* @"LibC::SIG_IGN:init"
call void @"~LibC::SIG_IGN:init"()
br label %initialized13
initialized15: ; preds = %not_initialized16, %initialized13
%18 = load i1, i1* @"String::CHAR_TO_DIGIT62:init"
br i1 %18, label %initialized17, label %not_initialized18
not_initialized16: ; preds = %initialized13
store i1 true, i1* @"String::CHAR_TO_DIGIT:init"
call void @"~String::CHAR_TO_DIGIT:init"()
br label %initialized15
initialized17: ; preds = %not_initialized18, %initialized15
%19 = load i1, i1* @"LibC::MAP_FAILED:init", !dbg !37
br i1 %19, label %initialized19, label %not_initialized20, !dbg !37
not_initialized18: ; preds = %initialized15
store i1 true, i1* @"String::CHAR_TO_DIGIT62:init"
call void @"~String::CHAR_TO_DIGIT62:init"()
br label %initialized17
initialized19: ; preds = %not_initialized20, %initialized17
%20 = load i1, i1* @"Fiber::fibers:init", !dbg !40
br i1 %20, label %initialized21, label %not_initialized22, !dbg !40
not_initialized20: ; preds = %initialized17
store i1 true, i1* @"LibC::MAP_FAILED:init", !dbg !37
call void @"~LibC::MAP_FAILED:init"()
br label %initialized19
initialized21: ; preds = %not_initialized22, %initialized19
%21 = load i1, i1* @"Fiber::stack_pool:init"
br i1 %21, label %initialized23, label %not_initialized24
not_initialized22: ; preds = %initialized19
store i1 true, i1* @"Fiber::fibers:init", !dbg !40
call void @"~Fiber::fibers:init"()
br label %initialized21
initialized23: ; preds = %not_initialized24, %initialized21
%22 = load i1, i1* @"Crystal::EventLoop::eb:init", !dbg !43
br i1 %22, label %initialized25, label %not_initialized26, !dbg !43
not_initialized24: ; preds = %initialized21
store i1 true, i1* @"Fiber::stack_pool:init"
call void @"~Fiber::stack_pool:init"()
br label %initialized23
initialized25: ; preds = %not_initialized26, %initialized23
%23 = load i1, i1* @"Thread::threads:init", !dbg !46
br i1 %23, label %initialized27, label %not_initialized28, !dbg !46
not_initialized26: ; preds = %initialized23
store i1 true, i1* @"Crystal::EventLoop::eb:init", !dbg !43
call void @"~Crystal::EventLoop::eb:init"()
br label %initialized25
initialized27: ; preds = %not_initialized28, %initialized25
%24 = call %Thread* @"*Thread::new:Thread"(), !dbg !49
%25 = call %Thread* @"*Thread::current=<Thread>:Thread"(%Thread* %24), !dbg !52
%26 = load i1, i1* @"File::DEFAULT_CREATE_PERMISSIONS:init", !dbg !53
br i1 %26, label %initialized29, label %not_initialized30, !dbg !53
not_initialized28: ; preds = %initialized25
store i1 true, i1* @"Thread::threads:init", !dbg !46
call void @"~Thread::threads:init"()
br label %initialized27
initialized29: ; preds = %not_initialized30, %initialized27
%27 = getelementptr inbounds %"->", %"->"* %0, i32 0, i32 0, !dbg !9
store i8* bitcast (void ()* @"~procProc(Nil)@/usr/share/crystal/src/gc/boehm.cr:243" to i8*), i8** %27, !dbg !9
%28 = getelementptr inbounds %"->", %"->"* %0, i32 0, i32 1, !dbg !9
store i8* null, i8** %28, !dbg !9
%29 = load %"->", %"->"* %0, !dbg !9
call void @"*GC::before_collect<&Proc(Nil)>:Nil"(%"->" %29), !dbg !56
%30 = call %"Slice(UInt8)" @"*Slice(T)::new<Pointer(UInt8), Int32>:Slice(UInt8)"(i8* bitcast ([2 x i64]* @"Crystal::Hasher::seed" to i8*), i32 trunc (i64 mul nuw (i64 ptrtoint (i64* getelementptr (i64, i64* null, i32 1) to i64), i64 2) to i32)), !dbg !12
store %"Slice(UInt8)" %30, %"Slice(UInt8)"* %1, !dbg !12
%31 = load %"Slice(UInt8)", %"Slice(UInt8)"* %1, !dbg !12
call void @"*Crystal::System::Random::random_bytes<Slice(UInt8)>:Nil"(%"Slice(UInt8)" %31), !dbg !57
%32 = load i1, i1* @"Hash::HASH_PRIMES:init", !dbg !57
br i1 %32, label %initialized31, label %not_initialized32, !dbg !57
not_initialized30: ; preds = %initialized27
store i1 true, i1* @"File::DEFAULT_CREATE_PERMISSIONS:init", !dbg !53
call void @"~File::DEFAULT_CREATE_PERMISSIONS:init"()
br label %initialized29
initialized31: ; preds = %not_initialized32, %initialized29
%33 = load i1, i1* @"STDOUT:init", !dbg !15
br i1 %33, label %initialized33, label %not_initialized34, !dbg !15
not_initialized32: ; preds = %initialized29
store i1 true, i1* @"Hash::HASH_PRIMES:init", !dbg !57
call void @"~Hash::HASH_PRIMES:init"(), !dbg !57
br label %initialized31, !dbg !57
initialized33: ; preds = %not_initialized34, %initialized31
%34 = load i1, i1* @"STDERR:init", !dbg !15
br i1 %34, label %initialized35, label %not_initialized36, !dbg !15
not_initialized34: ; preds = %initialized31
store i1 true, i1* @"STDOUT:init", !dbg !15
call void @"~STDOUT:init"(), !dbg !15
br label %initialized33, !dbg !15
initialized35: ; preds = %not_initialized36, %initialized33
%35 = load i1, i1* @"PROGRAM_NAME:init", !dbg !15
br i1 %35, label %initialized37, label %not_initialized38, !dbg !15
not_initialized36: ; preds = %initialized33
store i1 true, i1* @"STDERR:init", !dbg !15
call void @"~STDERR:init"(), !dbg !15
br label %initialized35, !dbg !15
initialized37: ; preds = %not_initialized38, %initialized35
%36 = load i1, i1* @"AtExitHandlers::running:init", !dbg !15
br i1 %36, label %initialized39, label %not_initialized40, !dbg !15
not_initialized38: ; preds = %initialized35
store i1 true, i1* @"PROGRAM_NAME:init", !dbg !15
call void @"~PROGRAM_NAME:init"(), !dbg !15
br label %initialized37, !dbg !15
initialized39: ; preds = %not_initialized40, %initialized37
%37 = getelementptr inbounds %"->", %"->"* %2, i32 0, i32 0, !dbg !15
store i8* bitcast (void ()* @"~procProc(Nil)@/usr/share/crystal/src/kernel.cr:540" to i8*), i8** %37, !dbg !15
%38 = getelementptr inbounds %"->", %"->"* %2, i32 0, i32 1, !dbg !15
store i8* null, i8** %38, !dbg !15
%39 = load %"->", %"->"* %2, !dbg !15
%40 = call %Fiber* @"*spawn<&Proc(Nil)>:Fiber"(%"->" %39), !dbg !58
call void @"*Signal::setup_default_handlers:Nil"(), !dbg !58
call void @setup_sigfault_handler(), !dbg !58
%41 = load i1, i1* @"Process::INITIAL_PWD:init", !dbg !59
br i1 %41, label %initialized41, label %not_initialized42, !dbg !59
not_initialized40: ; preds = %initialized37
store i1 true, i1* @"AtExitHandlers::running:init", !dbg !15
call void @"~AtExitHandlers::running:init"(), !dbg !15
br label %initialized39, !dbg !15
initialized41: ; preds = %not_initialized42, %initialized39
%42 = call %"Array(String)"* @"*CallStack::skip<String>:Array(String)"(%String* bitcast ({ i32, i32, i32, [32 x i8] }* @"'/usr/share/crystal/...'.11" to %String*)), !dbg !62
%43 = load i1, i1* @"Crystal::System::Random::initialized:init", !dbg !65
br i1 %43, label %initialized43, label %not_initialized44, !dbg !65
not_initialized42: ; preds = %initialized39
store i1 true, i1* @"Process::INITIAL_PWD:init", !dbg !59
call void @"~Process::INITIAL_PWD:init"(), !dbg !59
br label %initialized41, !dbg !59
initialized43: ; preds = %not_initialized44, %initialized41
%44 = load i1, i1* @"Crystal::System::Random::getrandom_available:init", !dbg !65
br i1 %44, label %initialized45, label %not_initialized46, !dbg !65
not_initialized44: ; preds = %initialized41
store i1 true, i1* @"Crystal::System::Random::initialized:init", !dbg !65
call void @"~Crystal::System::Random::initialized:init"(), !dbg !65
br label %initialized43, !dbg !65
initialized45: ; preds = %not_initialized46, %initialized43
%45 = getelementptr inbounds %"->", %"->"* %3, i32 0, i32 0, !dbg !18
store i8* bitcast (i8* (i64)* @"*GC::malloc<UInt64>:Pointer(Void)" to i8*), i8** %45, !dbg !18
%46 = getelementptr inbounds %"->", %"->"* %3, i32 0, i32 1, !dbg !18
store i8* null, i8** %46, !dbg !18
%47 = load %"->", %"->"* %3, !dbg !18
%48 = call i8* @"~check_proc_is_not_closure"(%"->" %47), !dbg !18
%49 = bitcast i8* %48 to i8* (i64)*, !dbg !18
store i8* (i64)* %49, i8* (i64)** @pcre_malloc, !dbg !18
%50 = bitcast i8* (i64)* %49 to i8*, !dbg !18
%51 = getelementptr inbounds %"->", %"->"* %4, i32 0, i32 0, !dbg !18
store i8* %50, i8** %51, !dbg !18
%52 = getelementptr inbounds %"->", %"->"* %4, i32 0, i32 1, !dbg !18
store i8* null, i8** %52, !dbg !18
%53 = load %"->", %"->"* %4, !dbg !18
%54 = getelementptr inbounds %"->", %"->"* %5, i32 0, i32 0, !dbg !21
store i8* bitcast (void (i8*)* @"*GC::free<Pointer(Void)>:Nil" to i8*), i8** %54, !dbg !21
%55 = getelementptr inbounds %"->", %"->"* %5, i32 0, i32 1, !dbg !21
store i8* null, i8** %55, !dbg !21
%56 = load %"->", %"->"* %5, !dbg !21
%57 = call i8* @"~check_proc_is_not_closure"(%"->" %56), !dbg !21
%58 = bitcast i8* %57 to %Nil (i8*)*, !dbg !21
store %Nil (i8*)* %58, %Nil (i8*)** @pcre_free, !dbg !21
%59 = bitcast %Nil (i8*)* %58 to i8*, !dbg !21
%60 = getelementptr inbounds %"->", %"->"* %6, i32 0, i32 0, !dbg !21
store i8* %59, i8** %60, !dbg !21
%61 = getelementptr inbounds %"->", %"->"* %6, i32 0, i32 1, !dbg !21
store i8* null, i8** %61, !dbg !21
%62 = load %"->", %"->"* %6, !dbg !21
%63 = load i1, i1* @"Signal::sigset:init", !dbg !68
br i1 %63, label %initialized47, label %not_initialized48, !dbg !68
not_initialized46: ; preds = %initialized43
store i1 true, i1* @"Crystal::System::Random::getrandom_available:init", !dbg !65
call void @"~Crystal::System::Random::getrandom_available:init"(), !dbg !65
br label %initialized45, !dbg !65
initialized47: ; preds = %not_initialized48, %initialized45
%64 = load i1, i1* @"Signal::setup_default_handlers:init", !dbg !68
br i1 %64, label %initialized49, label %not_initialized50, !dbg !68
not_initialized48: ; preds = %initialized45
store i1 true, i1* @"Signal::sigset:init", !dbg !68
call void @"~Signal::sigset:init"(), !dbg !68
br label %initialized47, !dbg !68
initialized49: ; preds = %not_initialized50, %initialized47
%65 = load i1, i1* @"Crystal::Signal::pipe:init", !dbg !68
br i1 %65, label %initialized51, label %not_initialized52, !dbg !68
not_initialized50: ; preds = %initialized47
store i1 true, i1* @"Signal::setup_default_handlers:init", !dbg !68
call void @"~Signal::setup_default_handlers:init"(), !dbg !68
br label %initialized49, !dbg !68
initialized51: ; preds = %not_initialized52, %initialized49
%66 = load i1, i1* @"Crystal::Signal::handlers:init", !dbg !68
br i1 %66, label %initialized53, label %not_initialized54, !dbg !68
not_initialized52: ; preds = %initialized49
store i1 true, i1* @"Crystal::Signal::pipe:init", !dbg !68
call void @"~Crystal::Signal::pipe:init"(), !dbg !68
br label %initialized51, !dbg !68
initialized53: ; preds = %not_initialized54, %initialized51
%67 = load i1, i1* @"Crystal::Signal::mutex:init", !dbg !68
br i1 %67, label %initialized55, label %not_initialized56, !dbg !68
not_initialized54: ; preds = %initialized51
store i1 true, i1* @"Crystal::Signal::handlers:init", !dbg !68
call void @"~Crystal::Signal::handlers:init"(), !dbg !68
br label %initialized53, !dbg !68
initialized55: ; preds = %not_initialized56, %initialized53
%68 = load i1, i1* @"Crystal::SignalChildHandler::pending:init", !dbg !68
br i1 %68, label %initialized57, label %not_initialized58, !dbg !68
not_initialized56: ; preds = %initialized53
store i1 true, i1* @"Crystal::Signal::mutex:init", !dbg !68
call void @"~Crystal::Signal::mutex:init"(), !dbg !68
br label %initialized55, !dbg !68
initialized57: ; preds = %not_initialized58, %initialized55
%69 = load i1, i1* @"Crystal::SignalChildHandler::waiting:init", !dbg !68
br i1 %69, label %initialized59, label %not_initialized60, !dbg !68
not_initialized58: ; preds = %initialized55
store i1 true, i1* @"Crystal::SignalChildHandler::pending:init", !dbg !68
call void @"~Crystal::SignalChildHandler::pending:init"(), !dbg !68
br label %initialized57, !dbg !68
initialized59: ; preds = %not_initialized60, %initialized57
%70 = load i1, i1* @"Crystal::SignalChildHandler::mutex:init", !dbg !68
br i1 %70, label %initialized61, label %not_initialized62, !dbg !68
not_initialized60: ; preds = %initialized57
store i1 true, i1* @"Crystal::SignalChildHandler::waiting:init", !dbg !68
call void @"~Crystal::SignalChildHandler::waiting:init"(), !dbg !68
br label %initialized59, !dbg !68
initialized61: ; preds = %not_initialized62, %initialized59
%71 = load i1, i1* @"Time::Location::location_cache:init", !dbg !71
br i1 %71, label %initialized63, label %not_initialized64, !dbg !71
not_initialized62: ; preds = %initialized59
store i1 true, i1* @"Crystal::SignalChildHandler::mutex:init", !dbg !68
call void @"~Crystal::SignalChildHandler::mutex:init"(), !dbg !68
br label %initialized61, !dbg !68
initialized63: ; preds = %not_initialized64, %initialized61
call void @"*print<String>:Nil"(%String* bitcast ({ i32, i32, i32, [8 x i8] }* @"'HELLO!\0A'" to %String*)), !dbg !74
ret void, !dbg !74
not_initialized64: ; preds = %initialized61
store i1 true, i1* @"Time::Location::location_cache:init", !dbg !71
call void @"~Time::Location::location_cache:init"()
br label %initialized63
}
declare i32 @printf(i8*, ...)
; Function Attrs: uwtable
define i8* @__crystal_malloc64(i64 %size) #0 !dbg !77 {
entry:
%0 = call i64 @"*UInt64::new<UInt64>:UInt64"(i64 %size), !dbg !79
%1 = call i8* @"*GC::malloc<UInt64>:Pointer(Void)"(i64 %0), !dbg !80
ret i8* %1, !dbg !80
}
; Function Attrs: uwtable
define i8* @__crystal_malloc_atomic64(i64 %size) #0 !dbg !81 {
entry:
%0 = call i64 @"*UInt64::new<UInt64>:UInt64"(i64 %size), !dbg !82
%1 = call i8* @"*GC::malloc_atomic<UInt64>:Pointer(Void)"(i64 %0), !dbg !83
ret i8* %1, !dbg !83
}
; Function Attrs: uwtable
define i8* @__crystal_realloc64(i8* %ptr, i64 %size) #0 !dbg !84 {
entry:
%0 = call i64 @"*UInt64::new<UInt64>:UInt64"(i64 %size), !dbg !85
%1 = call i8* @"*GC::realloc<Pointer(Void), UInt64>:Pointer(Void)"(i8* %ptr, i64 %0), !dbg !86
ret i8* %1, !dbg !86
}
; Function Attrs: uwtable
define i32 @__crystal_personality(i32 %version, i32 %actions, i64 %exception_class, %"struct.LibUnwind::Exception"* %exception_object, i8* %context) #0 !dbg !87 {
alloca:
%start = alloca i64, !dbg !88
%ip = alloca i64, !dbg !88
%throw_offset = alloca i64, !dbg !88
%lsd = alloca i8*, !dbg !88
%leb = alloca %"/usr/share/crystal/src/raise.cr::LEBReader", !dbg !88
%cs_table_length = alloca i64, !dbg !88
%cs_table_end = alloca i8*, !dbg !88
%cs_offset = alloca i32, !dbg !88
%cs_length = alloca i32, !dbg !88
%cs_addr = alloca i32, !dbg !88
%action = alloca i64, !dbg !88
%__temp_286 = alloca i1, !dbg !88
%0 = alloca %"/usr/share/crystal/src/raise.cr::LEBReader", !dbg !88
br label %entry
entry: ; preds = %alloca
%1 = call i64 @_Unwind_GetRegionStart(i8* %context), !dbg !88
store i64 %1, i64* %start, !dbg !88
%2 = call i64 @_Unwind_GetIP(i8* %context), !dbg !88
store i64 %2, i64* %ip, !dbg !88
%3 = load i64, i64* %ip, !dbg !88
%4 = sub i64 %3, 1, !dbg !88
%5 = load i64, i64* %start, !dbg !88
%6 = sub i64 %4, %5, !dbg !88
store i64 %6, i64* %throw_offset, !dbg !88
%7 = call i8* @_Unwind_GetLanguageSpecificData(i8* %context), !dbg !88
store i8* %7, i8** %lsd, !dbg !88
%8 = load i8*, i8** %lsd, !dbg !88
%9 = call %"/usr/share/crystal/src/raise.cr::LEBReader" @"*/usr/share/crystal/src/raise.cr::LEBReader::new<Pointer(UInt8)>:/usr/share/crystal/src/raise.cr::LEBReader"(i8* %8), !dbg !88
store %"/usr/share/crystal/src/raise.cr::LEBReader" %9, %"/usr/share/crystal/src/raise.cr::LEBReader"* %0, !dbg !88
%10 = load %"/usr/share/crystal/src/raise.cr::LEBReader", %"/usr/share/crystal/src/raise.cr::LEBReader"* %0, !dbg !88
store %"/usr/share/crystal/src/raise.cr::LEBReader" %10, %"/usr/share/crystal/src/raise.cr::LEBReader"* %leb, !dbg !88
%11 = call i8 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uint8:UInt8"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
%12 = call i8 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uint8:UInt8"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
%13 = icmp ne i8 %12, -1, !dbg !88
br i1 %13, label %then, label %else, !dbg !88
then: ; preds = %entry
%14 = call i64 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uleb128:UInt64"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
br label %exit, !dbg !88
else: ; preds = %entry
br label %exit, !dbg !88
exit: ; preds = %else, %then
%15 = call i8 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uint8:UInt8"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
%16 = call i64 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uleb128:UInt64"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
store i64 %16, i64* %cs_table_length, !dbg !88
%17 = getelementptr inbounds %"/usr/share/crystal/src/raise.cr::LEBReader", %"/usr/share/crystal/src/raise.cr::LEBReader"* %leb, i32 0, i32 0, !dbg !88
%18 = load i8*, i8** %17, !dbg !88
%19 = load i64, i64* %cs_table_length, !dbg !88
%20 = call i8* @"*Pointer(UInt8)@Pointer(T)#+<UInt64>:Pointer(UInt8)"(i8* %18, i64 %19), !dbg !88
store i8* %20, i8** %cs_table_end, !dbg !88
br label %while, !dbg !88
while: ; preds = %exit14, %exit
%21 = getelementptr inbounds %"/usr/share/crystal/src/raise.cr::LEBReader", %"/usr/share/crystal/src/raise.cr::LEBReader"* %leb, i32 0, i32 0, !dbg !88
%22 = load i8*, i8** %21, !dbg !88
%23 = load i8*, i8** %cs_table_end, !dbg !88
%24 = call i1 @"*Pointer(UInt8)@Comparable(T)#<<Pointer(UInt8)>:Bool"(i8* %22, i8* %23), !dbg !88
br i1 %24, label %body, label %exit1, !dbg !88
body: ; preds = %while
%25 = call i32 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uint32:UInt32"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
store i32 %25, i32* %cs_offset, !dbg !88
%26 = call i32 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uint32:UInt32"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
store i32 %26, i32* %cs_length, !dbg !88
%27 = call i32 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uint32:UInt32"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
store i32 %27, i32* %cs_addr, !dbg !88
%28 = call i64 @"*/usr/share/crystal/src/raise.cr::LEBReader#read_uleb128:UInt64"(%"/usr/share/crystal/src/raise.cr::LEBReader"* %leb), !dbg !88
store i64 %28, i64* %action, !dbg !88
%29 = load i32, i32* %cs_addr, !dbg !88
%30 = icmp ne i32 %29, 0, !dbg !88
%31 = or i1 false, %30, !dbg !88
br i1 %31, label %then2, label %else3, !dbg !88
exit1: ; preds = %while
ret i32 8, !dbg !88
then2: ; preds = %body
%32 = load i32, i32* %cs_offset, !dbg !88
%33 = load i64, i64* %throw_offset, !dbg !88
%34 = zext i32 %32 to i64, !dbg !88
%35 = icmp ule i64 %34, %33, !dbg !88
store i1 %35, i1* %__temp_286, !dbg !88
br i1 %35, label %then6, label %else7, !dbg !88
else3: ; preds = %body
br label %exit14, !dbg !88
then4: ; preds = %exit8
%36 = call i1 @"*LibUnwind::Action@Enum#includes?<LibUnwind::Action>:Bool"(i32 %actions, i32 1), !dbg !88
br i1 %36, label %then9, label %else10, !dbg !88
else5: ; preds = %exit8
br label %exit13, !dbg !88
then6: ; preds = %then2
%37 = load i64, i64* %throw_offset, !dbg !88
%38 = load i32, i32* %cs_offset, !dbg !88
%39 = load i32, i32* %cs_length, !dbg !88
%40 = add i32 %38, %39, !dbg !88
%41 = zext i32 %40 to i64, !dbg !88
%42 = icmp ule i64 %37, %41, !dbg !88
br label %exit8, !dbg !88
else7: ; preds = %then2
%43 = load i1, i1* %__temp_286, !dbg !88
br label %exit8, !dbg !88
exit8: ; preds = %else7, %then6
%44 = phi i1 [ %42, %then6 ], [ %43, %else7 ], !dbg !88
br i1 %44, label %then4, label %else5, !dbg !88
then9: ; preds = %then4
ret i32 6, !dbg !88
else10: ; preds = %then4
%45 = call i1 @"*LibUnwind::Action@Enum#includes?<LibUnwind::Action>:Bool"(i32 %actions, i32 4), !dbg !88
br i1 %45, label %then11, label %else12, !dbg !88
then11: ; preds = %else10
%46 = ptrtoint %"struct.LibUnwind::Exception"* %exception_object to i64, !dbg !88
call void @_Unwind_SetGR(i8* %context, i32 0, i64 %46), !dbg !88
%47 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %exception_object, i32 0, i32 5, !dbg !88
%48 = load i32, i32* %47, !dbg !88
%49 = sext i32 %48 to i64, !dbg !88
call void @_Unwind_SetGR(i8* %context, i32 1, i64 %49), !dbg !88
%50 = load i64, i64* %start, !dbg !88
%51 = load i32, i32* %cs_addr, !dbg !88
%52 = zext i32 %51 to i64, !dbg !88
%53 = add i64 %50, %52, !dbg !88
%54 = call i64 @_Unwind_SetIP(i8* %context, i64 %53), !dbg !88
ret i32 7, !dbg !88
else12: ; preds = %else10
br label %exit13, !dbg !88
exit13: ; preds = %else5, %else12
br label %exit14, !dbg !88
exit14: ; preds = %else3, %exit13
br label %while, !dbg !88
}
; Function Attrs: noreturn uwtable
define void @__crystal_raise(%"struct.LibUnwind::Exception"* %unwind_ex) #1 !dbg !89 {
alloca:
%ret = alloca i32, !dbg !90
br label %entry
entry: ; preds = %alloca
%0 = call i32 @_Unwind_RaiseException(%"struct.LibUnwind::Exception"* %unwind_ex), !dbg !90
store i32 %0, i32* %ret, !dbg !90
%1 = call i8* @"*String#to_unsafe:Pointer(UInt8)"(%String* bitcast ({ i32, i32, i32, [34 x i8] }* @"'Failed to raise an ...'" to %String*)), !dbg !90
%2 = load i32, i32* %ret, !dbg !90
%3 = call %String* @"*LibUnwind::ReasonCode@Enum#to_s:String"(i32 %2), !dbg !90
%4 = call i8* @"*String#to_unsafe:Pointer(UInt8)"(%String* %3), !dbg !90
%5 = call i32 (i32, i8*, ...) @dprintf(i32 2, i8* %1, i8* %4), !dbg !90
%6 = call i32 @"*CallStack::print_backtrace:Int32"(), !dbg !90
%7 = load i32, i32* %ret, !dbg !90
%8 = call i32 @"*LibUnwind::ReasonCode@Enum#to_i32!:Int32"(i32 %7), !dbg !90
call void @exit(i32 %8), !dbg !90
unreachable, !dbg !90
}
; Function Attrs: uwtable
define i64 @__crystal_get_exception(%"struct.LibUnwind::Exception"* %unwind_ex) #0 !dbg !91 {
entry:
%0 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %unwind_ex, i32 0, i32 4, !dbg !92
%1 = load i64, i64* %0, !dbg !92
ret i64 %1, !dbg !92
}
; Function Attrs: noreturn uwtable
define void @__crystal_raise_overflow() #1 !dbg !93 {
entry:
%0 = call %OverflowError* @"*OverflowError::new:OverflowError"(), !dbg !94
call void @"*raise<OverflowError>:NoReturn"(%OverflowError* %0), !dbg !95
unreachable, !dbg !95
}
define internal void @"~AtExitHandlers::running:init"() {
entry:
ret void
}
define internal void @"~Crystal::System::Random::initialized:init"() {
entry:
ret void
}
define internal void @"~Crystal::System::Random::getrandom_available:init"() {
entry:
ret void
}
define internal void @"~Debug::ELF::MAGIC:init"() {
alloca:
%__temp_111 = alloca %"Slice(UInt8)", !dbg !22
%0 = alloca %"Slice(UInt8)"
br label %entry
entry: ; preds = %alloca
%1 = call %"Slice(UInt8)" @"*Slice(UInt8)@Slice(T)::new:read_only<Int32, Bool>:Slice(UInt8)"(i32 1092, i32 4, i1 false)
store %"Slice(UInt8)" %1, %"Slice(UInt8)"* %0
%2 = load %"Slice(UInt8)", %"Slice(UInt8)"* %0
store %"Slice(UInt8)" %2, %"Slice(UInt8)"* %__temp_111
%3 = getelementptr inbounds %"Slice(UInt8)", %"Slice(UInt8)"* %__temp_111, i32 0, i32 2
%4 = load i8*, i8** %3
%5 = call i8 @"*UInt8::new!<Int32>:UInt8"(i32 127)
%6 = call i8 @"*Pointer(UInt8)@Pointer(T)#[]=<Int32, UInt8>:UInt8"(i8* %4, i32 0, i8 %5)
%7 = getelementptr inbounds %"Slice(UInt8)", %"Slice(UInt8)"* %__temp_111, i32 0, i32 2
%8 = load i8*, i8** %7
%9 = call i8 @"*UInt8::new!<Int32>:UInt8"(i32 69)
%10 = call i8 @"*Pointer(UInt8)@Pointer(T)#[]=<Int32, UInt8>:UInt8"(i8* %8, i32 1, i8 %9)
%11 = getelementptr inbounds %"Slice(UInt8)", %"Slice(UInt8)"* %__temp_111, i32 0, i32 2
%12 = load i8*, i8** %11
%13 = call i8 @"*UInt8::new!<Int32>:UInt8"(i32 76)
%14 = call i8 @"*Pointer(UInt8)@Pointer(T)#[]=<Int32, UInt8>:UInt8"(i8* %12, i32 2, i8 %13)
%15 = getelementptr inbounds %"Slice(UInt8)", %"Slice(UInt8)"* %__temp_111, i32 0, i32 2
%16 = load i8*, i8** %15
%17 = call i8 @"*UInt8::new!<Int32>:UInt8"(i32 70)
%18 = call i8 @"*Pointer(UInt8)@Pointer(T)#[]=<Int32, UInt8>:UInt8"(i8* %16, i32 3, i8 %17)
%19 = load %"Slice(UInt8)", %"Slice(UInt8)"* %__temp_111
store %"Slice(UInt8)" %19, %"Slice(UInt8)"* @"Debug::ELF::MAGIC"
ret void
}
; Function Attrs: uwtable
define internal %"Slice(UInt8)" @"*Slice(UInt8)@Slice(T)::new:read_only<Int32, Bool>:Slice(UInt8)"(i32 %self, i32 %size, i1 %read_only) #0 !dbg !96 {
alloca:
%pointer = alloca i8*, !dbg !98
%0 = alloca %"Slice(UInt8)", !dbg !99
br label %entry
entry: ; preds = %alloca
%1 = call i8* @"*Pointer(UInt8)@Pointer(T)::malloc<Int32>:Pointer(UInt8)"(i32 722, i32 %size), !dbg !100
store i8* %1, i8** %pointer, !dbg !101
%2 = load i8*, i8** %pointer, !dbg !101
%3 = call %"Slice(UInt8)" @"*Slice(UInt8)@Slice(T)::new:read_only<Pointer(UInt8), Int32, Bool>:Slice(UInt8)"(i32 %self, i8* %2, i32 %size, i1 %read_only), !dbg !99
store %"Slice(UInt8)" %3, %"Slice(UInt8)"* %0, !dbg !99
%4 = load %"Slice(UInt8)", %"Slice(UInt8)"* %0, !dbg !99
ret %"Slice(UInt8)" %4, !dbg !99
}
; Function Attrs: uwtable
define internal i8* @"*Pointer(UInt8)@Pointer(T)::malloc<Int32>:Pointer(UInt8)"(i32 %self, i32 %size) #0 !dbg !102 {
entry:
%0 = icmp slt i32 %size, 0, !dbg !104
br i1 %0, label %then, label %else, !dbg !104
then: ; preds = %entry
%1 = call %ArgumentError* @"*ArgumentError::new<String>:ArgumentError"(%String* bitcast ({ i32, i32, i32, [29 x i8] }* @"'Negative Pointer#ma...'" to %String*)), !dbg !105
call void @"*raise<ArgumentError>:NoReturn"(%ArgumentError* %1), !dbg !106
unreachable, !dbg !106
else: ; preds = %entry
%2 = sext i32 %size to i64, !dbg !106
%3 = mul i64 ptrtoint (i8* getelementptr (i8, i8* null, i32 1) to i64), %2, !dbg !107
%4 = call i8* @__crystal_malloc_atomic64(i64 %3), !dbg !107
%5 = trunc i64 %3 to i32, !dbg !107
call void @llvm.memset.p0i8.i32(i8* %4, i8 0, i32 %5, i32 4, i1 false), !dbg !107
ret i8* %4, !dbg !106
}
; Function Attrs: uwtable
define internal %ArgumentError* @"*ArgumentError::new<String>:ArgumentError"(%String* %message) #0 !dbg !108 {
alloca:
%_ = alloca %ArgumentError*, !dbg !109
br label %entry
entry: ; preds = %alloca
%0 = call i8* @__crystal_malloc64(i64 ptrtoint (%ArgumentError* getelementptr (%ArgumentError, %ArgumentError* null, i32 1) to i64)), !dbg !109
%1 = bitcast i8* %0 to %ArgumentError*, !dbg !109
%2 = bitcast %ArgumentError* %1 to i8*, !dbg !109
call void @llvm.memset.p0i8.i32(i8* %2, i8 0, i32 ptrtoint (%ArgumentError* getelementptr (%ArgumentError, %ArgumentError* null, i32 1) to i32), i32 4, i1 false), !dbg !109
%3 = getelementptr inbounds %ArgumentError, %ArgumentError* %1, i32 0, i32 0, !dbg !109
store i32 39, i32* %3, !dbg !109
store %ArgumentError* %1, %ArgumentError** %_, !dbg !109
%4 = load %ArgumentError*, %ArgumentError** %_, !dbg !109
call void @"*ArgumentError#initialize<String>:Nil"(%ArgumentError* %4, %String* %message), !dbg !109
%5 = load %ArgumentError*, %ArgumentError** %_, !dbg !109
ret %ArgumentError* %5, !dbg !109
}
; Function Attrs: argmemonly nounwind
declare void @llvm.memset.p0i8.i32(i8* nocapture writeonly, i8, i32, i32, i1) #2
; Function Attrs: uwtable
define internal void @"*ArgumentError#initialize<String>:Nil"(%ArgumentError* %self, %String* %message) #0 !dbg !110 {
entry:
call void @"*ArgumentError@Exception#initialize<String>:Nil"(%ArgumentError* %self, %String* %message), !dbg !111
ret void, !dbg !111
}
; Function Attrs: uwtable
define internal void @"*ArgumentError@Exception#initialize<String>:Nil"(%ArgumentError* %self, %String* %message) #0 !dbg !112 {
alloca:
%cause = alloca %Nil, !dbg !113
br label %entry
entry: ; preds = %alloca
%0 = getelementptr inbounds %ArgumentError, %ArgumentError* %self, i32 0, i32 1, !dbg !114
store %String* %message, %String** %0, !dbg !114
%1 = load %Nil, %Nil* %cause, !dbg !114
%2 = getelementptr inbounds %ArgumentError, %ArgumentError* %self, i32 0, i32 2, !dbg !115
store i32* null, i32** %2, !dbg !115
ret void, !dbg !115
}
; Function Attrs: noreturn uwtable
define internal void @"*raise<ArgumentError>:NoReturn"(%ArgumentError* %exception) #1 !dbg !116 {
alloca:
%__temp_24 = alloca %"(CallStack | Nil)", !dbg !117
%unwind_ex = alloca %"struct.LibUnwind::Exception"*, !dbg !117
%0 = alloca %CallStack, !dbg !117
br label %entry
entry: ; preds = %alloca
%1 = getelementptr inbounds %ArgumentError, %ArgumentError* %exception, i32 0, i32 3, !dbg !117
%2 = load %"(CallStack | Nil)", %"(CallStack | Nil)"* %1, !dbg !117
store %"(CallStack | Nil)" %2, %"(CallStack | Nil)"* %__temp_24, !dbg !117
%3 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %1, i32 0, i32 0, !dbg !117
%4 = load i32, i32* %3, !dbg !117
%5 = icmp eq i32 %4, 0, !dbg !117
%6 = xor i1 %5, true, !dbg !117
%7 = and i1 true, %6, !dbg !117
br i1 %7, label %then, label %else, !dbg !117
then: ; preds = %entry
%8 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %__temp_24, i32 0, i32 1, !dbg !117
%9 = bitcast [2 x i64]* %8 to %CallStack*, !dbg !117
br label %exit, !dbg !117
else: ; preds = %entry
%10 = call %CallStack @"*CallStack::new:CallStack"(), !dbg !117
store %CallStack %10, %CallStack* %0, !dbg !117
%11 = load %CallStack, %CallStack* %0, !dbg !117
%12 = call %CallStack @"*ArgumentError@Exception#callstack=<CallStack>:CallStack"(%ArgumentError* %exception, %CallStack %11), !dbg !117
br label %exit, !dbg !117
exit: ; preds = %else, %then
%13 = call %"struct.LibUnwind::Exception"* @"*Pointer(LibUnwind::Exception)@Pointer(T)::malloc:Pointer(LibUnwind::Exception)"(i32 728), !dbg !117
store %"struct.LibUnwind::Exception"* %13, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !117
%14 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !117
%15 = call i64 @"*UInt64@Number::zero:UInt64"(), !dbg !117
%16 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %14, i32 0, i32 0, !dbg !117
store i64 %15, i64* %16, !dbg !117
%17 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !117
%18 = call i64 @"*UInt64@Number::zero:UInt64"(), !dbg !117
%19 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %17, i32 0, i32 1, !dbg !117
store i64 %18, i64* %19, !dbg !117
%20 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !117
%21 = ptrtoint %ArgumentError* %exception to i64, !dbg !117
%22 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %20, i32 0, i32 4, !dbg !117
store i64 %21, i64* %22, !dbg !117
%23 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !117
%24 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %23, i32 0, i32 5, !dbg !117
store i32 39, i32* %24, !dbg !117
%25 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !117
call void @__crystal_raise(%"struct.LibUnwind::Exception"* %25), !dbg !117
unreachable, !dbg !117
}
; Function Attrs: uwtable
define internal %CallStack @"*CallStack::new:CallStack"() #0 !dbg !118 {
alloca:
%_ = alloca %CallStack, !dbg !119
%0 = alloca %CallStack, !dbg !119
br label %entry
entry: ; preds = %alloca
%1 = bitcast %CallStack* %0 to i8*, !dbg !119
call void @llvm.memset.p0i8.i32(i8* %1, i8 0, i32 trunc (i64 mul nuw (i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), i64 2) to i32), i32 4, i1 false), !dbg !119
%2 = load %CallStack, %CallStack* %0, !dbg !119
store %CallStack %2, %CallStack* %_, !dbg !119
%3 = call %"Array(Pointer(Void))"* @"*CallStack#initialize:Array(Pointer(Void))"(%CallStack* %_), !dbg !119
%4 = load %CallStack, %CallStack* %_, !dbg !119
ret %CallStack %4, !dbg !119
}
; Function Attrs: uwtable
define internal %"Array(Pointer(Void))"* @"*CallStack#initialize:Array(Pointer(Void))"(%CallStack* %self) #0 !dbg !120 {
entry:
%0 = call %"Array(Pointer(Void))"* @"*CallStack::unwind:Array(Pointer(Void))"(), !dbg !121
%1 = getelementptr inbounds %CallStack, %CallStack* %self, i32 0, i32 0, !dbg !122
store %"Array(Pointer(Void))"* %0, %"Array(Pointer(Void))"** %1, !dbg !122
ret %"Array(Pointer(Void))"* %0, !dbg !122
}
; Function Attrs: uwtable
define internal %"Array(Pointer(Void))"* @"*CallStack::unwind:Array(Pointer(Void))"() #0 !dbg !123 {
alloca:
%callstack = alloca %"Array(Pointer(Void))"*, !dbg !124
%backtrace_fn = alloca %"->", !dbg !124
%0 = alloca %"->", !dbg !125
br label %entry
entry: ; preds = %alloca
%1 = call %"Array(Pointer(Void))"* @"*Array(Pointer(Void))@Array(T)::new:Array(Pointer(Void))"(i32 512), !dbg !126
store %"Array(Pointer(Void))"* %1, %"Array(Pointer(Void))"** %callstack, !dbg !125
%2 = getelementptr inbounds %"->", %"->"* %0, i32 0, i32 0, !dbg !125
store i8* bitcast (i32 (i8*, i8*)* @"~procProc(Pointer(Void), Pointer(Void), LibUnwind::ReasonCode)@/usr/share/crystal/src/callstack.cr:77" to i8*), i8** %2, !dbg !125
%3 = getelementptr inbounds %"->", %"->"* %0, i32 0, i32 1, !dbg !125
store i8* null, i8** %3, !dbg !125
%4 = load %"->", %"->"* %0, !dbg !125
store %"->" %4, %"->"* %backtrace_fn, !dbg !127
%5 = load %"->", %"->"* %backtrace_fn, !dbg !127
%6 = call i8* @"~check_proc_is_not_closure"(%"->" %5)
%7 = bitcast i8* %6 to i32 (i8*, i8*)*
%8 = load %"Array(Pointer(Void))"*, %"Array(Pointer(Void))"** %callstack
%9 = bitcast %"Array(Pointer(Void))"* %8 to i8*
%10 = call i32 @_Unwind_Backtrace(i32 (i8*, i8*)* %7, i8* %9), !dbg !128
%11 = load %"Array(Pointer(Void))"*, %"Array(Pointer(Void))"** %callstack, !dbg !128
ret %"Array(Pointer(Void))"* %11, !dbg !128
}
; Function Attrs: uwtable
define internal %"Array(Pointer(Void))"* @"*Array(Pointer(Void))@Array(T)::new:Array(Pointer(Void))"(i32 %self) #0 !dbg !129 {
alloca:
%_ = alloca %"Array(Pointer(Void))"*, !dbg !131
br label %entry
entry: ; preds = %alloca
%0 = call i8* @__crystal_malloc64(i64 ptrtoint (%"Array(Pointer(Void))"* getelementptr (%"Array(Pointer(Void))", %"Array(Pointer(Void))"* null, i32 1) to i64)), !dbg !131
%1 = bitcast i8* %0 to %"Array(Pointer(Void))"*, !dbg !131
%2 = bitcast %"Array(Pointer(Void))"* %1 to i8*, !dbg !131
call void @llvm.memset.p0i8.i32(i8* %2, i8 0, i32 ptrtoint (%"Array(Pointer(Void))"* getelementptr (%"Array(Pointer(Void))", %"Array(Pointer(Void))"* null, i32 1) to i32), i32 4, i1 false), !dbg !131
%3 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %1, i32 0, i32 0, !dbg !131
store i32 7, i32* %3, !dbg !131
store %"Array(Pointer(Void))"* %1, %"Array(Pointer(Void))"** %_, !dbg !131
%4 = load %"Array(Pointer(Void))"*, %"Array(Pointer(Void))"** %_, !dbg !131
%5 = call i8** @"*Array(Pointer(Void))@Array(T)#initialize:Pointer(Pointer(Void))"(%"Array(Pointer(Void))"* %4), !dbg !131
%6 = load %"Array(Pointer(Void))"*, %"Array(Pointer(Void))"** %_, !dbg !131
ret %"Array(Pointer(Void))"* %6, !dbg !131
}
; Function Attrs: uwtable
define internal i8** @"*Array(Pointer(Void))@Array(T)#initialize:Pointer(Pointer(Void))"(%"Array(Pointer(Void))"* %self) #0 !dbg !132 {
entry:
%0 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 1, !dbg !133
store i32 0, i32* %0, !dbg !133
%1 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 2, !dbg !134
store i32 0, i32* %1, !dbg !134
%2 = call i8** @"*Pointer(Pointer(Void))@Pointer(T)::null:Pointer(Pointer(Void))"(i32 737), !dbg !135
%3 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 3, !dbg !136
store i8** %2, i8*** %3, !dbg !136
ret i8** %2, !dbg !136
}
; Function Attrs: uwtable
define internal i8** @"*Pointer(Pointer(Void))@Pointer(T)::null:Pointer(Pointer(Void))"(i32 %self) #0 !dbg !137 {
entry:
ret i8** null, !dbg !138
}
; Function Attrs: uwtable
define internal i32 @"~procProc(Pointer(Void), Pointer(Void), LibUnwind::ReasonCode)@/usr/share/crystal/src/callstack.cr:77"(i8* %context, i8* %data) #0 !dbg !139 {
alloca:
%bt = alloca %"Array(Pointer(Void))"*, !dbg !140
%ip = alloca i8*, !dbg !140
br label %entry
entry: ; preds = %alloca
%0 = bitcast i8* %data to %"Array(Pointer(Void))"*, !dbg !140
store %"Array(Pointer(Void))"* %0, %"Array(Pointer(Void))"** %bt, !dbg !141
%1 = call i64 @_Unwind_GetIP(i8* %context), !dbg !142
%2 = inttoptr i64 %1 to i8*, !dbg !142
store i8* %2, i8** %ip, !dbg !143
%3 = load %"Array(Pointer(Void))"*, %"Array(Pointer(Void))"** %bt, !dbg !143
%4 = load i8*, i8** %ip, !dbg !143
%5 = call %"Array(Pointer(Void))"* @"*Array(Pointer(Void))@Array(T)#<<<Pointer(Void)>:Array(Pointer(Void))"(%"Array(Pointer(Void))"* %3, i8* %4), !dbg !144
ret i32 0, !dbg !144
}
declare i64 @_Unwind_GetIP(i8*)
; Function Attrs: uwtable
define internal %"Array(Pointer(Void))"* @"*Array(Pointer(Void))@Array(T)#<<<Pointer(Void)>:Array(Pointer(Void))"(%"Array(Pointer(Void))"* %self, i8* %value) #0 !dbg !145 {
entry:
%0 = call %"Array(Pointer(Void))"* @"*Array(Pointer(Void))@Array(T)#push<Pointer(Void)>:Array(Pointer(Void))"(%"Array(Pointer(Void))"* %self, i8* %value), !dbg !146
ret %"Array(Pointer(Void))"* %0, !dbg !146
}
; Function Attrs: uwtable
define internal %"Array(Pointer(Void))"* @"*Array(Pointer(Void))@Array(T)#push<Pointer(Void)>:Array(Pointer(Void))"(%"Array(Pointer(Void))"* %self, i8* %value) #0 !dbg !147 {
entry:
%0 = call i8** @"*Array(Pointer(Void))@Array(T)#check_needs_resize:(Pointer(Pointer(Void)) | Nil)"(%"Array(Pointer(Void))"* %self), !dbg !148
%1 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 3, !dbg !148
%2 = load i8**, i8*** %1, !dbg !148
%3 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 1, !dbg !148
%4 = load i32, i32* %3, !dbg !148
%5 = call i8* @"*Pointer(Pointer(Void))@Pointer(T)#[]=<Int32, Pointer(Void)>:Pointer(Void)"(i8** %2, i32 %4, i8* %value), !dbg !149
%6 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 1, !dbg !149
%7 = load i32, i32* %6, !dbg !149
%8 = add i32 %7, 1, !dbg !149
%9 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 1, !dbg !150
store i32 %8, i32* %9, !dbg !150
ret %"Array(Pointer(Void))"* %self, !dbg !150
}
; Function Attrs: uwtable
define internal i8** @"*Array(Pointer(Void))@Array(T)#check_needs_resize:(Pointer(Pointer(Void)) | Nil)"(%"Array(Pointer(Void))"* %self) #0 !dbg !151 {
entry:
%0 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 1, !dbg !152
%1 = load i32, i32* %0, !dbg !152
%2 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 2, !dbg !152
%3 = load i32, i32* %2, !dbg !152
%4 = icmp eq i32 %1, %3, !dbg !152
br i1 %4, label %then, label %else, !dbg !152
then: ; preds = %entry
%5 = call i8** @"*Array(Pointer(Void))@Array(T)#double_capacity:Pointer(Pointer(Void))"(%"Array(Pointer(Void))"* %self), !dbg !152
br label %exit, !dbg !152
else: ; preds = %entry
br label %exit, !dbg !152
exit: ; preds = %else, %then
%6 = phi i8** [ %5, %then ], [ null, %else ], !dbg !152
ret i8** %6, !dbg !152
}
; Function Attrs: uwtable
define internal i8** @"*Array(Pointer(Void))@Array(T)#double_capacity:Pointer(Pointer(Void))"(%"Array(Pointer(Void))"* %self) #0 !dbg !153 {
entry:
%0 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 2, !dbg !154
%1 = load i32, i32* %0, !dbg !154
%2 = icmp eq i32 %1, 0, !dbg !154
br i1 %2, label %then, label %else, !dbg !154
then: ; preds = %entry
br label %exit, !dbg !154
else: ; preds = %entry
%3 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 2, !dbg !154
%4 = load i32, i32* %3, !dbg !154
%5 = mul i32 %4, 2, !dbg !154
br label %exit, !dbg !154
exit: ; preds = %else, %then
%6 = phi i32 [ 3, %then ], [ %5, %else ], !dbg !154
%7 = call i8** @"*Array(Pointer(Void))@Array(T)#resize_to_capacity<Int32>:Pointer(Pointer(Void))"(%"Array(Pointer(Void))"* %self, i32 %6), !dbg !155
ret i8** %7, !dbg !155
}
; Function Attrs: uwtable
define internal i8** @"*Array(Pointer(Void))@Array(T)#resize_to_capacity<Int32>:Pointer(Pointer(Void))"(%"Array(Pointer(Void))"* %self, i32 %capacity) #0 !dbg !156 {
entry:
%0 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 2, !dbg !157
store i32 %capacity, i32* %0, !dbg !157
%1 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 3, !dbg !158
%2 = load i8**, i8*** %1, !dbg !158
%3 = icmp ne i8** %2, null, !dbg !158
br i1 %3, label %then, label %else, !dbg !158
then: ; preds = %entry
%4 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 3, !dbg !158
%5 = load i8**, i8*** %4, !dbg !158
%6 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 2, !dbg !158
%7 = load i32, i32* %6, !dbg !158
%8 = call i8** @"*Pointer(Pointer(Void))@Pointer(T)#realloc<Int32>:Pointer(Pointer(Void))"(i8** %5, i32 %7), !dbg !159
%9 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 3, !dbg !160
store i8** %8, i8*** %9, !dbg !160
br label %exit, !dbg !160
else: ; preds = %entry
%10 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 2, !dbg !160
%11 = load i32, i32* %10, !dbg !160
%12 = call i8** @"*Pointer(Pointer(Void))@Pointer(T)::malloc<Int32>:Pointer(Pointer(Void))"(i32 737, i32 %11), !dbg !161
%13 = getelementptr inbounds %"Array(Pointer(Void))", %"Array(Pointer(Void))"* %self, i32 0, i32 3, !dbg !162
store i8** %12, i8*** %13, !dbg !162
br label %exit, !dbg !162
exit: ; preds = %else, %then
%14 = phi i8** [ %8, %then ], [ %12, %else ], !dbg !162
ret i8** %14, !dbg !162
}
; Function Attrs: uwtable
define internal i8** @"*Pointer(Pointer(Void))@Pointer(T)#realloc<Int32>:Pointer(Pointer(Void))"(i8** %self, i32 %size) #0 !dbg !163 {
entry:
%0 = icmp slt i32 %size, 0, !dbg !164
br i1 %0, label %then, label %else, !dbg !164
then: ; preds = %entry
%1 = call %ArgumentError* @"*ArgumentError::new<String>:ArgumentError"(%String* bitcast ({ i32, i32, i32, [14 x i8] }* @"'Negative size'" to %String*)), !dbg !165
call void @"*raise<ArgumentError>:NoReturn"(%ArgumentError* %1), !dbg !166
unreachable, !dbg !166
else: ; preds = %entry
%2 = sext i32 %size to i64, !dbg !166
%3 = bitcast i8** %self to i8*, !dbg !166
%4 = mul i64 %2, ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), !dbg !166
%5 = call i8* @__crystal_realloc64(i8* %3, i64 %4), !dbg !166
%6 = bitcast i8* %5 to i8**, !dbg !166
ret i8** %6, !dbg !166
}
; Function Attrs: uwtable
define internal i8** @"*Pointer(Pointer(Void))@Pointer(T)::malloc<Int32>:Pointer(Pointer(Void))"(i32 %self, i32 %size) #0 !dbg !167 {
entry:
%0 = icmp slt i32 %size, 0, !dbg !168
br i1 %0, label %then, label %else, !dbg !168
then: ; preds = %entry
%1 = call %ArgumentError* @"*ArgumentError::new<String>:ArgumentError"(%String* bitcast ({ i32, i32, i32, [29 x i8] }* @"'Negative Pointer#ma...'" to %String*)), !dbg !169
call void @"*raise<ArgumentError>:NoReturn"(%ArgumentError* %1), !dbg !170
unreachable, !dbg !170
else: ; preds = %entry
%2 = sext i32 %size to i64, !dbg !170
%3 = mul i64 ptrtoint (i1** getelementptr (i1*, i1** null, i32 1) to i64), %2, !dbg !171
%4 = call i8* @__crystal_malloc64(i64 %3), !dbg !171
%5 = trunc i64 %3 to i32, !dbg !171
call void @llvm.memset.p0i8.i32(i8* %4, i8 0, i32 %5, i32 4, i1 false), !dbg !171
%6 = bitcast i8* %4 to i8**, !dbg !171
ret i8** %6, !dbg !170
}
; Function Attrs: uwtable
define internal i8* @"*Pointer(Pointer(Void))@Pointer(T)#[]=<Int32, Pointer(Void)>:Pointer(Void)"(i8** %self, i32 %offset, i8* %value) #0 !dbg !172 {
entry:
%0 = call i8** @"*Pointer(Pointer(Void))@Pointer(T)#+<Int32>:Pointer(Pointer(Void))"(i8** %self, i32 %offset), !dbg !173
store i8* %value, i8** %0, !dbg !173
ret i8* %value, !dbg !173
}
; Function Attrs: uwtable
define internal i8** @"*Pointer(Pointer(Void))@Pointer(T)#+<Int32>:Pointer(Pointer(Void))"(i8** %self, i32 %other) #0 !dbg !174 {
entry:
%0 = sext i32 %other to i64, !dbg !175
%1 = getelementptr inbounds i8*, i8** %self, i64 %0, !dbg !175
ret i8** %1, !dbg !175
}
define internal i8* @"~check_proc_is_not_closure"(%"->") {
entry:
%1 = extractvalue %"->" %0, 0, !dbg !127
%2 = extractvalue %"->" %0, 1, !dbg !127
%3 = icmp eq i8* %2, null, !dbg !127
br i1 %3, label %ctx_is_null, label %ctx_is_not_null, !dbg !127
ctx_is_null: ; preds = %entry
ret i8* %1, !dbg !127
ctx_is_not_null: ; preds = %entry
call void @"*raise<String>:NoReturn"(%String* bitcast ({ i32, i32, i32, [38 x i8] }* @"'passing a closure t...'" to %String*))
unreachable
}
; Function Attrs: noreturn uwtable
define internal void @"*raise<String>:NoReturn"(%String* %message) #1 !dbg !176 {
entry:
%0 = call %Exception* @"*Exception::new<String>:Exception"(%String* %message), !dbg !177
call void @"*raise<Exception>:NoReturn"(%Exception* %0), !dbg !178
unreachable, !dbg !178
}
; Function Attrs: uwtable
define internal %Exception* @"*Exception::new<String>:Exception"(%String* %__arg0) #0 !dbg !179 {
alloca:
%_ = alloca %Exception*, !dbg !180
br label %entry
entry: ; preds = %alloca
%0 = call i8* @__crystal_malloc64(i64 ptrtoint (%Exception* getelementptr (%Exception, %Exception* null, i32 1) to i64)), !dbg !180
%1 = bitcast i8* %0 to %Exception*, !dbg !180
%2 = bitcast %Exception* %1 to i8*, !dbg !180
call void @llvm.memset.p0i8.i32(i8* %2, i8 0, i32 ptrtoint (%Exception* getelementptr (%Exception, %Exception* null, i32 1) to i32), i32 4, i1 false), !dbg !180
%3 = getelementptr inbounds %Exception, %Exception* %1, i32 0, i32 0, !dbg !180
store i32 63, i32* %3, !dbg !180
store %Exception* %1, %Exception** %_, !dbg !180
%4 = load %Exception*, %Exception** %_, !dbg !180
call void @"*Exception#initialize<String>:Nil"(%Exception* %4, %String* %__arg0), !dbg !180
%5 = load %Exception*, %Exception** %_, !dbg !180
ret %Exception* %5, !dbg !180
}
; Function Attrs: uwtable
define internal void @"*Exception#initialize<String>:Nil"(%Exception* %self, %String* %message) #0 !dbg !181 {
alloca:
%cause = alloca %Nil, !dbg !182
br label %entry
entry: ; preds = %alloca
%0 = getelementptr inbounds %Exception, %Exception* %self, i32 0, i32 1, !dbg !183
store %String* %message, %String** %0, !dbg !183
%1 = load %Nil, %Nil* %cause, !dbg !183
%2 = getelementptr inbounds %Exception, %Exception* %self, i32 0, i32 2, !dbg !184
store i32* null, i32** %2, !dbg !184
ret void, !dbg !184
}
; Function Attrs: noreturn uwtable
define internal void @"*raise<Exception>:NoReturn"(%Exception* %exception) #1 !dbg !185 {
alloca:
%__temp_32 = alloca %"(CallStack | Nil)", !dbg !186
%unwind_ex = alloca %"struct.LibUnwind::Exception"*, !dbg !186
%0 = alloca %CallStack, !dbg !186
br label %entry
entry: ; preds = %alloca
%1 = getelementptr inbounds %Exception, %Exception* %exception, i32 0, i32 3, !dbg !186
%2 = load %"(CallStack | Nil)", %"(CallStack | Nil)"* %1, !dbg !186
store %"(CallStack | Nil)" %2, %"(CallStack | Nil)"* %__temp_32, !dbg !186
%3 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %1, i32 0, i32 0, !dbg !186
%4 = load i32, i32* %3, !dbg !186
%5 = icmp eq i32 %4, 0, !dbg !186
%6 = xor i1 %5, true, !dbg !186
%7 = and i1 true, %6, !dbg !186
br i1 %7, label %then, label %else, !dbg !186
then: ; preds = %entry
%8 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %__temp_32, i32 0, i32 1, !dbg !186
%9 = bitcast [2 x i64]* %8 to %CallStack*, !dbg !186
br label %exit, !dbg !186
else: ; preds = %entry
%10 = call %CallStack @"*CallStack::new:CallStack"(), !dbg !186
store %CallStack %10, %CallStack* %0, !dbg !186
%11 = load %CallStack, %CallStack* %0, !dbg !186
%12 = call %CallStack @"*Exception#callstack=<CallStack>:CallStack"(%Exception* %exception, %CallStack %11), !dbg !186
br label %exit, !dbg !186
exit: ; preds = %else, %then
%13 = call %"struct.LibUnwind::Exception"* @"*Pointer(LibUnwind::Exception)@Pointer(T)::malloc:Pointer(LibUnwind::Exception)"(i32 728), !dbg !186
store %"struct.LibUnwind::Exception"* %13, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !186
%14 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !186
%15 = call i64 @"*UInt64@Number::zero:UInt64"(), !dbg !186
%16 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %14, i32 0, i32 0, !dbg !186
store i64 %15, i64* %16, !dbg !186
%17 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !186
%18 = call i64 @"*UInt64@Number::zero:UInt64"(), !dbg !186
%19 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %17, i32 0, i32 1, !dbg !186
store i64 %18, i64* %19, !dbg !186
%20 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !186
%21 = ptrtoint %Exception* %exception to i64, !dbg !186
%22 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %20, i32 0, i32 4, !dbg !186
store i64 %21, i64* %22, !dbg !186
%23 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !186
%24 = getelementptr inbounds %"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* %23, i32 0, i32 5, !dbg !186
store i32 63, i32* %24, !dbg !186
%25 = load %"struct.LibUnwind::Exception"*, %"struct.LibUnwind::Exception"** %unwind_ex, !dbg !186
call void @__crystal_raise(%"struct.LibUnwind::Exception"* %25), !dbg !186
unreachable, !dbg !186
}
; Function Attrs: uwtable
define internal %CallStack @"*Exception#callstack=<CallStack>:CallStack"(%Exception* %self, %CallStack %callstack) #0 !dbg !187 {
alloca:
%callstack1 = alloca %CallStack, !dbg !188
br label %entry
entry: ; preds = %alloca
store %CallStack %callstack, %CallStack* %callstack1, !dbg !188
%0 = getelementptr inbounds %Exception, %Exception* %self, i32 0, i32 3, !dbg !189
%1 = load %CallStack, %CallStack* %callstack1, !dbg !189
%2 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %0, i32 0, i32 0, !dbg !189
store i32 353, i32* %2, !dbg !189
%3 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %0, i32 0, i32 1, !dbg !189
%4 = bitcast [2 x i64]* %3 to %CallStack*, !dbg !189
store %CallStack %1, %CallStack* %4, !dbg !189
%5 = load %CallStack, %CallStack* %callstack1, !dbg !189
ret %CallStack %5, !dbg !189
}
; Function Attrs: uwtable
define internal %"struct.LibUnwind::Exception"* @"*Pointer(LibUnwind::Exception)@Pointer(T)::malloc:Pointer(LibUnwind::Exception)"(i32 %self) #0 !dbg !190 {
alloca:
%size = alloca i32, !dbg !191
br label %entry
entry: ; preds = %alloca
store i32 1, i32* %size, !dbg !192
%0 = load i32, i32* %size, !dbg !193
%1 = icmp slt i32 %0, 0, !dbg !193
br i1 %1, label %then, label %else, !dbg !193
then: ; preds = %entry
%2 = call %ArgumentError* @"*ArgumentError::new<String>:ArgumentError"(%String* bitcast ({ i32, i32, i32, [29 x i8] }* @"'Negative Pointer#ma...'" to %String*)), !dbg !194
call void @"*raise<ArgumentError>:NoReturn"(%ArgumentError* %2), !dbg !195
unreachable, !dbg !195
else: ; preds = %entry
%3 = load i32, i32* %size, !dbg !195
%4 = sext i32 %3 to i64, !dbg !195
%5 = mul i64 ptrtoint (%"struct.LibUnwind::Exception"* getelementptr (%"struct.LibUnwind::Exception", %"struct.LibUnwind::Exception"* null, i32 1) to i64), %4, !dbg !196
%6 = call i8* @__crystal_malloc_atomic64(i64 %5), !dbg !196
%7 = trunc i64 %5 to i32, !dbg !196
call void @llvm.memset.p0i8.i32(i8* %6, i8 0, i32 %7, i32 4, i1 false), !dbg !196
%8 = bitcast i8* %6 to %"struct.LibUnwind::Exception"*, !dbg !196
ret %"struct.LibUnwind::Exception"* %8, !dbg !195
}
; Function Attrs: uwtable
define internal i64 @"*UInt64@Number::zero:UInt64"() #0 !dbg !197 {
entry:
%0 = call i64 @"*UInt64::new<Int32>:UInt64"(i32 0), !dbg !199
ret i64 %0, !dbg !199
}
; Function Attrs: uwtable
define internal i64 @"*UInt64::new<Int32>:UInt64"(i32 %value) #0 !dbg !200 {
entry:
%0 = sext i32 %value to i64, !dbg !202
ret i64 %0, !dbg !202
}
declare i32 @_Unwind_Backtrace(i32 (i8*, i8*)*, i8*)
; Function Attrs: uwtable
define internal %CallStack @"*ArgumentError@Exception#callstack=<CallStack>:CallStack"(%ArgumentError* %self, %CallStack %callstack) #0 !dbg !203 {
alloca:
%callstack1 = alloca %CallStack, !dbg !204
br label %entry
entry: ; preds = %alloca
store %CallStack %callstack, %CallStack* %callstack1, !dbg !204
%0 = getelementptr inbounds %ArgumentError, %ArgumentError* %self, i32 0, i32 3, !dbg !205
%1 = load %CallStack, %CallStack* %callstack1, !dbg !205
%2 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %0, i32 0, i32 0, !dbg !205
store i32 353, i32* %2, !dbg !205
%3 = getelementptr inbounds %"(CallStack | Nil)", %"(CallStack | Nil)"* %0, i32 0, i32 1, !dbg !205
%4 = bitcast [2 x i64]* %3 to %CallStack*, !dbg !205
store %CallStack %1, %CallStack* %4, !dbg !205
%5 = load %CallStack, %CallStack* %callstack1, !dbg !205
ret %CallStack %5, !dbg !205
}
; Function Attrs: uwtable
define internal %"Slice(UInt8)" @"*Slice(UInt8)@Slice(T)::new:read_only<Pointer(UInt8), Int32, Bool>:Slice(UInt8)"(i32 %self, i8* %__arg0, i32 %__arg1, i1 %__temp_105) #0 !dbg !206 {
alloca:
%_ = alloca %"Slice(UInt8)", !dbg !207
%0 = alloca %"Slice(UInt8)", !dbg !207
br label %entry
entry: ; preds = %alloca
%1 = bitcast %"Slice(UInt8)"* %0 to i8*, !dbg !207
call void @llvm.memset.p0i8.i32(i8* %1, i8 0, i32 ptrtoint (%"Slice(UInt8)"* getelementptr (%"Slice(UInt8)", %"Slice(UInt8)"* null, i32 1) to i32), i32 4, i1 false), !dbg !207
%2 = load %"Slice(UInt8)", %"Slice(UInt8)"* %0, !dbg !207
store %"Slice(UInt8)" %2, %"Slice(UInt8)"* %_, !dbg !207
%3 = call i32 @"*Slice(UInt8)@Slice(T)#initialize:read_only<Pointer(UInt8), Int32, Bool>:Int32"(%"Slice(UInt8)"* %_, i8* %__arg0, i32 %__arg1, i1 %__temp_105), !dbg !207
%4 = load %"Slice(UInt8)", %"Slice(UInt8)"* %_, !dbg !207
ret %"Slice(UInt8)" %4, !dbg !207
}
; Function Attrs: uwtable
define internal i32 @"*Slice(UInt8)@Slice(T)#initialize:read_only<Pointer(UInt8), Int32, Bool>:Int32"(%"Slice(UInt8)"* %self, i8* %pointer, i32 %size, i1 %read_only) #0 !dbg !208 {
entry:
%0 = getelementptr inbounds %"Slice(UInt8)", %"Slice(UInt8)"* %self, i32 0, i32 2, !dbg !209
store i8* %pointer, i8** %0, !dbg !209
%1 = getelementptr inbounds %"Slice(UInt8)", %"Slice(UInt8)"* %self, i32 0, i32 1, !dbg !210
store i1 %read_only, i1* %1, !dbg !210
%2 = getelementptr inbounds %"Slice(UInt8)", %"Slice(UInt8)"* %self, i32 0, i32 0, !dbg !211
store i32 %size, i32* %2, !dbg !211
ret i32 %size, !dbg !211
}
; Function Attrs: uwtable
define internal i8 @"*UInt8::new!<Int32>:UInt8"(i32 %value) #0 !dbg !212 {
entry:
%0 = trunc i32 %value to i8, !dbg !213
ret i8 %0, !dbg !213
}
; Function Attrs: uwtable
define internal i8 @"*Pointer(UInt8)@Pointer(T)#[]=<Int32, UInt8>:UInt8"(i8* %self, i32 %offset, i8 %value) #0 !dbg !214 {
entry:
%0 = call i8* @"*Pointer(UInt8)@Pointer(T)#+<Int32>:Pointer(UInt8)"(i8* %self, i32 %offset), !dbg !215
store i8 %value, i8* %0, !dbg !215
ret i8 %value, !dbg !215
}
; Function Attrs: uwtable
define internal i8* @"*Pointer(UInt8)@Pointer(T)#+<Int32>:Pointer(UInt8)"(i8* %self, i32 %other) #0 !dbg !216 {
entry:
%0 = sext i32 %other to i64, !dbg !217
%1 = getelementptr inbounds i8, i8* %self, i64 %0, !dbg !217
ret i8* %1, !dbg !217
}
define internal void @"~CallStack::CURRENT_DIR:init"() {
alloca:
%dir = alloca %String*, !dbg !25
br label %entry
entry: ; preds = %alloca
%0 = call %String** @"~Process::INITIAL_PWD:read"()
%1 = load %String*, %String** %0
store %String* %1, %String** %dir
%2 = load %String*, %String** %dir
%3 = call i1 @"*String#ends_with?<Char>:Bool"(%String* %2, i32 47)
br i1 %3, label %then, label %else
then: ; preds = %entry
br label %exit
else: ; preds = %entry
%4 = load %String*, %String** %dir
%5 = call %String* @"*String#+<Char>:String"(%String* %4, i32 47)
store %String* %5, %String** %dir
br label %exit
exit: ; preds = %else, %then
%6 = load %String*, %String** %dir
store %String* %6, %String** @"CallStack::CURRENT_DIR"
ret void
}
define internal %String** @"~Process::INITIAL_PWD:read"() {
entry:
%0 = load i1, i1* @"Process::INITIAL_PWD:init", !dbg !25
br i1 %0, label %initialized, label %not_initialized, !dbg !25
initialized: ; preds = %not_initialized, %entry
ret %String** @"Process::INITIAL_PWD"
not_initialized: ; preds = %entry
store i1 true, i1* @"Process::INITIAL_PWD:init", !dbg !25
call void @"~Process::INITIAL_PWD:init"()
br label %initialized
}
define internal void @"~Process::INITIAL_PWD:init"() {
entry:
%0 = call %String* @"*Dir::current:String"()
store %String* %0, %String** @"Process::INITIAL_PWD"
ret void
}
; Function Attrs: uwtable
define internal %String* @"*Dir::current:String"() #0 !dbg !218 {
entry:
%0 = call %String* @"*Crystal::System::Dir::current:String"(), !dbg !220
ret %String* %0, !dbg !220
}
; Function Attrs: uwtable
define internal %String* @"*Crystal::System::Dir::current:String"() #0 !dbg !221 {
alloca:
%dir = alloca i8*, !dbg !223
%dir_str = alloca %String*, !dbg !223
br label %entry
entry: ; preds = %alloca
%0 = call i8* @getcwd(i8* null, i64 0), !dbg !224
store i8* %0, i8** %dir, !dbg !225
%1 = icmp ne i8* %0, null, !dbg !225
br i1 %1, label %then, label %else, !dbg !225
then: ; preds = %entry
br label %exit, !dbg !225
else: ; preds = %entry
%2 = call %Errno* @"*Errno::new<String>:Errno"(%String* bitcast ({ i32, i32, i32, [7 x i8] }* @"'getcwd'" to %String*)), !dbg !226
call void @"*raise<Errno>:NoReturn"(%Errno* %2), !dbg !227
unreachable, !dbg !227
exit: ; preds = %then
%3 = load i8*, i8** %dir, !dbg !227
%4 = call %String* @"*String::new<Pointer(UInt8)>:String"(i8* %3), !dbg !228
store %String* %4, %String** %dir_str, !dbg !229
%5 = load i8*, i8** %dir, !dbg !229
call void @free(i8* %5), !dbg !230
%6 = load %String*, %String** %dir_str, !dbg !230
ret %String* %6, !dbg !230
}
declare i8* @getcwd(i8*, i64)
; Function Attrs: uwtable
define internal %Errno* @"*Errno::new<String>:Errno"(%String* %__arg0) #0 !dbg !231 {
alloca:
%_ = alloca %Errno*, !dbg !233
br label %entry
entry: ; preds = %alloca
%0 = call i8* @__crystal_malloc64(i64 ptrtoint (%Errno* getelementptr (%Errno, %Errno* null, i32 1) to i64)), !dbg !233
%1 = bitcast i8* %0 to %Errno*, !dbg !233
%2 = bitcast %Errno* %1 to i8*, !dbg !233
call void @llvm.memset.p0i8.i32(i8* %2, i8 0, i32 ptrtoint (%Errno* getelementptr (%Errno, %Errno* null, i32 1) to i32), i32 4, i1 false), !dbg !233
%3 = getelementptr inbounds %Errno, %Errno* %1, i32 0, i32 0, !dbg !233
store i32 54, i32* %3, !dbg !233
store %Errno* %1, %Errno** %_, !dbg !233
%4 = load %Errno*, %Errno** %_, !dbg !233
call void @"*Errno#initialize<String>:Nil"(%Errno* %4, %String* %__arg0), !dbg !233
%5 = load %Errno*, %Errno** %_, !dbg !233
ret %Errno* %5, !dbg !233
}
; Function Attrs: uwtable
define internal void @"*Errno#initialize<String>:Nil"(%Errno* %self, %String* %message) #0 !dbg !234 {
alloca:
%errno = alloca i32, !dbg !235
br label %entry
entry: ; preds = %alloca
%0 = call i32 @"*Errno::value:Int32"(), !dbg !236
store i32 %0, i32* %errno, !dbg !237
%1 = load i32, i32* %errno, !dbg !237
call void @"*Errno#initialize<String, Int32>:Nil"(%Errno* %self, %String* %message, i32 %1), !dbg !235
ret void, !dbg !235
}
; Function Attrs: uwtable
define internal i32 @"*Errno::value:Int32"() #0 !dbg !238 {
entry:
%0 = call i32* @__errno_location(), !dbg !239
%1 = load i32, i32* %0, !dbg !239
ret i32 %1, !dbg !239
}
declare i32* @__errno_location()
; Function Attrs: uwtable
define internal void @"*Errno#initialize<String, Int32>:Nil"(%Errno* %self, %String* %message, i32 %errno) #0 !dbg !240 {
entry:
%0 = getelementptr inbounds %Errno, %Errno* %self, i32 0, i32 4, !dbg !241
store i32 %errno, i32* %0, !dbg !241
%1 = getelementptr inbounds %Errno, %Errno* %self, i32 0, i32 4, !dbg !241
%2 = load i32, i32* %1, !dbg !241
%3 = call i8* @strerror(i32 %2), !dbg !242
%4 = call %String* @"*String::new<Pointer(UInt8)>:String"(i8* %3), !dbg !243
%5 = getelementptr inbounds %Errno, %Errno* %self, i32 0, i32 5, !dbg !244
store %String* %4, %String** %5, !dbg !244
%6 = call %"String::Builder"* @"*String::Builder::new:String::Builder"(), !dbg !245
%7 = call %"String::Builder"* @"*String::Builder@IO#<<<String>:String::Builder"(%"String::Builder"* %6, %String* %message), !dbg !245
%8 = call %"String::Builder"* @"*String::Builder@IO#<<<String>:String::Builder"(%"String::Builder"* %7, %String* bitcast ({ i32, i32, i32, [3 x i8] }* @"': '" to %String*)), !dbg !245
%9 = getelementptr inbounds %Errno, %Errno* %self, i32 0, i32 5, !dbg !245
%10 = load %String*, %String** %9, !dbg !245
%11 = call %"String::Builder"* @"*String::Builder@IO#<<<String>:String::Builder"(%"String::Builder"* %8, %String* %10), !dbg !245
%12 = call %String* @"*String::Builder#to_s:String"(%"String::Builder"* %11), !dbg !245
call void @"*Errno@Exception#initialize<String>:Nil"(%Errno* %self, %String* %12), !dbg !246
ret void, !dbg !246
}
declare i8* @strerror(i32)
; Function Attrs: uwtable
define internal %String* @"*String::new<Pointer(UInt8)>:String"(i8* %chars) #0 !dbg !247 {
entry:
%0 = call i64 @strlen(i8* %chars), !dbg !249
%1 = call %String* @"*String::new<Pointer(UInt8), UInt64>:String"(i8* %chars, i64 %0), !dbg !250
ret %String* %1, !dbg !250
}
declare i64 @strlen(i8*)
; Function Attrs: uwtable
define internal %String* @"*String::new<Pointer(UInt8), UInt64>:String"(i8* %chars, i64 %bytesize) #0 !dbg !251 {
alloca:
%size = alloca i32, !dbg !252
br label %entry
entry: ; preds = %alloca
store i32 0, i32* %size, !dbg !253
%0 = load i32, i32* %size, !dbg !253
%1 = call %String* @"*String::new<Pointer(UInt8), UInt64, Int32>:String"(i8* %chars, i64 %bytesize, i32 %0), !dbg !252
ret %String* %1, !dbg !252
}
; Function Attrs: uwtable
define internal %String* @"*String::new<Pointer(UInt8), UInt64, Int32>:String"(i8* %chars, i64 %bytesize, i32 %size) #0 !dbg !254 {
alloca:
%buffer = alloca i8*, !dbg !255
%capacity = alloca i64, !dbg !255
%str = alloca i8*, !dbg !255
%buffer1 = alloca i8*, !dbg !255
%__temp_25 = alloca %"Tuple(UInt64, Int32)", !dbg !255
%bytesize2 = alloca i64, !dbg !255
%size3 = alloca i32, !dbg !255
%__temp_26 = alloca i1, !dbg !255
%str_header = alloca %"Tuple(Int32, Int32, Int32)"*, !dbg !255
%0 = alloca %"Tuple(UInt64, Int32)", !dbg !256
%1 = alloca %"Tuple(Int32, Int32, Int32)", !dbg !257
br label %entry
entry: ; preds = %alloca
%2 = icmp eq i64 %bytesize, 0, !dbg !258
%3 = and i1 true, %2, !dbg !258
br i1 %3, label %then, label %else, !dbg !258
then: ; preds = %entry
ret %String* bitcast ({ i32, i32, i32, [1 x i8] }* @"''" to %String*), !dbg !258
else: ; preds = %entry
store i64 %bytesize, i64* %capacity, !dbg !255
%4 = load i64, i64* %capacity, !dbg !255
call void @"*String::check_capacity_in_bounds<UInt64>:Nil"(i64 %4), !dbg !259
%5 = load i64, i64* %capacity, !dbg !259
%6 = trunc i64 %5 to i32, !dbg !259
%7 = add i32 %6, 12, !dbg !259
%8 = add i32 %7, 1, !dbg !259
%9 = call i8* @"*GC::malloc_atomic<UInt32>:Pointer(Void)"(i32 %8), !dbg !260
store i8* %9, i8** %str, !dbg !261
%10 = load i8*, i8** %str, !dbg !261
%11 = bitcast i8* %10 to %String*, !dbg !261
%12 = call i8* @"*String#to_unsafe:Pointer(UInt8)"(%String* %11), !dbg !262
store i8* %12, i8** %buffer1, !dbg !263
%13 = load i8*, i8** %buffer1, !dbg !263
store i8* %13, i8** %buffer, !dbg !263
%14 = load i8*, i8** %buffer, !dbg !263
%15 = call i8* @"*Pointer(UInt8)@Pointer(T)#copy_from<Pointer(UInt8), UInt64>:Pointer(UInt8)"(i8* %14, i8* %chars, i64 %bytesize), !dbg !256
%16 = getelementptr inbounds %"Tuple(UInt64, Int32)", %"Tuple(UInt64, Int32)"* %0, i32 0, i32 0, !dbg !256
store i64 %bytesize, i64* %16, !dbg !256
%17 = getelementptr inbounds %"Tuple(UInt64, Int32)", %"Tuple(UInt64, Int32)"* %0, i32 0, i32 1, !dbg !256
store i32 %size, i32* %17, !dbg !256
%18 = load %"Tuple(UInt64, Int32)", %"Tuple(UInt64, Int32)"* %0, !dbg !264
store %"Tuple(UInt64, Int32)" %18, %"Tuple(UInt64, Int32)"* %__temp_25, !dbg !264
%19 = getelementptr inbounds %"Tuple(UInt64, Int32)", %"Tuple(UInt64, Int32)"* %__temp_25, i32 0, i32 0, !dbg !264
%20 = load i64, i64* %19, !dbg !264
store i64 %20, i64* %bytesize2, !dbg !265
%21 = getelementptr inbounds %"Tuple(UInt64, Int32)", %"Tuple(UInt64, Int32)"* %__temp_25, i32 0, i32 1, !dbg !265
%22 = load i32, i32* %21, !dbg !265
store i32 %22, i32* %size3, !dbg !266
%23 = load i64, i64* %bytesize2, !dbg !267
%24 = icmp ule i64 0, %23, !dbg !267
%25 = or i1 true, %24, !dbg !267
store i1 %25, i1* %__temp_26, !dbg !267
br i1 %25, label %then6, label %else7, !dbg !267
then4: ; preds = %exit
br label %exit8, !dbg !267
else5: ; preds = %exit
%26 = call %ArgumentError* @"*ArgumentError::new<String>:ArgumentError"(%String* bitcast ({ i32, i32, i32, [32 x i8] }* @"'Bytesize out of cap...'" to %String*)), !dbg !268
call void @"*raise<ArgumentError>:NoReturn"(%ArgumentError* %26), !dbg !269
unreachable, !dbg !269
then6: ; preds = %else
%27 = load i64, i64* %bytesize2, !dbg !267
%28 = load i64, i64* %capacity, !dbg !267
%29 = icmp ule i64 %27, %28, !dbg !267
br label %exit, !dbg !267
else7: ; preds = %else
%30 = load i1, i1* %__temp_26, !dbg !267
br label %exit, !dbg !267
exit: ; preds = %else7, %then6
%31 = phi i1 [ %29, %then6 ], [ %30, %else7 ], !dbg !267
br i1 %31, label %then4, label %else5, !dbg !267
exit8: ; preds = %then4
%32 = load i8*, i8** %buffer1, !dbg !269
%33 = load i64, i64* %bytesize2, !dbg !269
%34 = call i8 @"*Pointer(UInt8)@Pointer(T)#[]=<UInt64, UInt8>:UInt8"(i8* %32, i64 %33, i8 0), !dbg !270
%35 = load i64, i64* %bytesize2, !dbg !271
%36 = load i64, i64* %capacity, !dbg !271
%37 = icmp ult i64 %35, %36, !dbg !271
br i1 %37, label %then9, label %else10, !dbg !271
then9: ; preds = %exit8
%38 = load i8*, i8** %str, !dbg !271
%39 = load i64, i64* %bytesize2, !dbg !271
%40 = trunc i64 %39 to i32, !dbg !271
%41 = add i32 %40, 12, !dbg !271
%42 = add i32 %41, 1, !dbg !271
%43 = call i8* @"*Pointer(UInt8)@Pointer(T)#realloc<UInt32>:Pointer(UInt8)"(i8* %38, i32 %42), !dbg !272
store i8* %43, i8** %str, !dbg !273
br label %exit11, !dbg !273
else10: ; preds = %exit8
br label %exit11, !dbg !273
exit11: ; preds = %else10, %then9
%44 = load i8*, i8** %str, !dbg !273
%45 = bitcast i8* %44 to %"Tuple(Int32, Int32, Int32)"*, !dbg !273
store %"Tuple(Int32, Int32, Int32)"* %45, %"Tuple(Int32, Int32, Int32)"** %str_header, !dbg !257
%46 = load %"Tuple(Int32, Int32, Int32)"*, %"Tuple(Int32, Int32, Int32)"** %str_header, !dbg !257
%47 = call i32* @"~String::TYPE_ID:read"(), !dbg !257
%48 = load i32, i32* %47, !dbg !257
%49 = getelementptr inbounds %"Tuple(Int32, Int32, Int32)", %"Tuple(Int32, Int32, Int32)"* %1, i32 0, i32 0, !dbg !257
store i32 %48, i32* %49, !dbg !257
%50 = load i64, i64* %bytesize2, !dbg !257
%51 = trunc i64 %50 to i32, !dbg !257
%52 = getelementptr inbounds %"Tuple(Int32, Int32, Int32)", %"Tuple(Int32, Int32, Int32)"* %1, i32 0, i32 1, !dbg !257
store i32 %51, i32* %52, !dbg !257
%53 = load i32, i32* %size3, !dbg !257
%54 = getelementptr inbounds %"Tuple(Int32, Int32, Int32)", %"Tuple(Int32, Int32, Int32)"* %1, i32 0, i32 2, !dbg !257
store i32 %53, i32* %54, !dbg !257
%55 = load %"Tuple(Int32, Int32, Int32)", %