diff --git a/SparrowImplicitLib/bitOper.spr b/SparrowImplicitLib/bitOper.spr index 15ceae86..6d5c39af 100644 --- a/SparrowImplicitLib/bitOper.spr +++ b/SparrowImplicitLib/bitOper.spr @@ -16,72 +16,58 @@ using oper_precedence_!<>! = bitOperPrecedence+30 [autoCt] - [native("_bit_neg_8")] fun pre_!~!(n: Byte): Byte - [native("_bit_shl_8")] fun !<>!(n, k: Byte): Byte - [native("_bit_xor_8")] fun !^!(n1, n2: Byte): Byte - [native("_bit_or_8")] fun !|!(n1, n2: Byte): Byte - [native("_bit_and_8")] fun !&!(n1, n2: Byte): Byte + [native("_bit_neg_8")] fun pre_!~!(n: Int8): Int8 + [native("_bit_shl_8")] fun !<>!(n, k: Int8): Int8 + [native("_bit_xor_8")] fun !^!(n1, n2: Int8): Int8 + [native("_bit_or_8")] fun !|!(n1, n2: Int8): Int8 + [native("_bit_and_8")] fun !&!(n1, n2: Int8): Int8 - [native("_bit_neg_8")] fun pre_!~!(n: UByte): UByte - [native("_bit_shl_8")] fun !<>!(n, k: UByte): UByte - [native("_bit_xor_8")] fun !^!(n1, n2: UByte): UByte - [native("_bit_or_8")] fun !|!(n1, n2: UByte): UByte - [native("_bit_and_8")] fun !&!(n1, n2: UByte): UByte + [native("_bit_neg_8")] fun pre_!~!(n: UInt8): UInt8 + [native("_bit_shl_8")] fun !<>!(n, k: UInt8): UInt8 + [native("_bit_xor_8")] fun !^!(n1, n2: UInt8): UInt8 + [native("_bit_or_8")] fun !|!(n1, n2: UInt8): UInt8 + [native("_bit_and_8")] fun !&!(n1, n2: UInt8): UInt8 - [native("_bit_neg_16")] fun pre_!~!(n: Short): Short - [native("_bit_shl_16")] fun !<>!(n, k: Short): Short - [native("_bit_xor_16")] fun !^!(n1, n2: Short): Short - [native("_bit_or_16")] fun !|!(n1, n2: Short): Short - [native("_bit_and_16")] fun !&!(n1, n2: Short): Short + [native("_bit_neg_16")] fun pre_!~!(n: Int16): Int16 + [native("_bit_shl_16")] fun !<>!(n, k: Int16): Int16 + [native("_bit_xor_16")] fun !^!(n1, n2: Int16): Int16 + [native("_bit_or_16")] fun !|!(n1, n2: Int16): Int16 + [native("_bit_and_16")] fun !&!(n1, n2: Int16): Int16 - [native("_bit_neg_16")] fun pre_!~!(n: UShort): UShort - [native("_bit_shl_16")] fun !<>!(n, k: UShort): UShort - [native("_bit_xor_16")] fun !^!(n1, n2: UShort): UShort - [native("_bit_or_16")] fun !|!(n1, n2: UShort): UShort - [native("_bit_and_16")] fun !&!(n1, n2: UShort): UShort + [native("_bit_neg_16")] fun pre_!~!(n: UInt16): UInt16 + [native("_bit_shl_16")] fun !<>!(n, k: UInt16): UInt16 + [native("_bit_xor_16")] fun !^!(n1, n2: UInt16): UInt16 + [native("_bit_or_16")] fun !|!(n1, n2: UInt16): UInt16 + [native("_bit_and_16")] fun !&!(n1, n2: UInt16): UInt16 - [native("_bit_neg_32")] fun pre_!~!(n: Int): Int - [native("_bit_shl_32")] fun !<>!(n, k: Int): Int - [native("_bit_xor_32")] fun !^!(n1, n2: Int): Int - [native("_bit_or_32")] fun !|!(n1, n2: Int): Int - [native("_bit_and_32")] fun !&!(n1, n2: Int): Int + [native("_bit_neg_32")] fun pre_!~!(n: Int32): Int32 + [native("_bit_shl_32")] fun !<>!(n, k: Int32): Int32 + [native("_bit_xor_32")] fun !^!(n1, n2: Int32): Int32 + [native("_bit_or_32")] fun !|!(n1, n2: Int32): Int32 + [native("_bit_and_32")] fun !&!(n1, n2: Int32): Int32 - [native("_bit_neg_32")] fun pre_!~!(n: UInt): UInt - [native("_bit_shl_32")] fun !<>!(n, k: UInt): UInt - [native("_bit_xor_32")] fun !^!(n1, n2: UInt): UInt - [native("_bit_or_32")] fun !|!(n1, n2: UInt): UInt - [native("_bit_and_32")] fun !&!(n1, n2: UInt): UInt + [native("_bit_neg_32")] fun pre_!~!(n: UInt32): UInt32 + [native("_bit_shl_32")] fun !<>!(n, k: UInt32): UInt32 + [native("_bit_xor_32")] fun !^!(n1, n2: UInt32): UInt32 + [native("_bit_or_32")] fun !|!(n1, n2: UInt32): UInt32 + [native("_bit_and_32")] fun !&!(n1, n2: UInt32): UInt32 - [native("_bit_neg_64")] fun pre_!~!(n: Long): Long - [native("_bit_shl_64")] fun !<>!(n, k: Long): Long - [native("_bit_xor_64")] fun !^!(n1, n2: Long): Long - [native("_bit_or_64")] fun !|!(n1, n2: Long): Long - [native("_bit_and_64")] fun !&!(n1, n2: Long): Long + [native("_bit_neg_64")] fun pre_!~!(n: Int64): Int64 + [native("_bit_shl_64")] fun !<>!(n, k: Int64): Int64 + [native("_bit_xor_64")] fun !^!(n1, n2: Int64): Int64 + [native("_bit_or_64")] fun !|!(n1, n2: Int64): Int64 + [native("_bit_and_64")] fun !&!(n1, n2: Int64): Int64 - [native("_bit_neg_64")] fun pre_!~!(n: ULong): ULong - [native("_bit_shl_64")] fun !<>!(n, k: ULong): ULong - [native("_bit_xor_64")] fun !^!(n1, n2: ULong): ULong - [native("_bit_or_64")] fun !|!(n1, n2: ULong): ULong - [native("_bit_and_64")] fun !&!(n1, n2: ULong): ULong - - [native("_bit_neg_64")] fun pre_!~!(n: SizeType): SizeType - [native("_bit_shl_64")] fun !<>!(n, k: SizeType): SizeType - [native("_bit_xor_64")] fun !^!(n1, n2: SizeType): SizeType - [native("_bit_or_64")] fun !|!(n1, n2: SizeType): SizeType - [native("_bit_and_64")] fun !&!(n1, n2: SizeType): SizeType - - [native("_bit_neg_64")] fun pre_!~!(n: DiffType): DiffType - [native("_bit_shl_64")] fun !<>!(n, k: DiffType): DiffType - [native("_bit_xor_64")] fun !^!(n1, n2: DiffType): DiffType - [native("_bit_or_64")] fun !|!(n1, n2: DiffType): DiffType - [native("_bit_and_64")] fun !&!(n1, n2: DiffType): DiffType + [native("_bit_neg_64")] fun pre_!~!(n: UInt64): UInt64 + [native("_bit_shl_64")] fun !<>!(n, k: UInt64): UInt64 + [native("_bit_xor_64")] fun !^!(n1, n2: UInt64): UInt64 + [native("_bit_or_64")] fun !|!(n1, n2: UInt64): UInt64 + [native("_bit_and_64")] fun !&!(n1, n2: UInt64): UInt64 diff --git a/SparrowImplicitLib/check.spr b/SparrowImplicitLib/check.spr index b523408d..a3f08ac1 100644 --- a/SparrowImplicitLib/check.spr +++ b/SparrowImplicitLib/check.spr @@ -8,22 +8,20 @@ import std.function(Function) [initCtor] datatype Gen(t: Type) using ValueType = t - _generator: Function(t, UInt) + using _isGenerator = true + _generator: Function(t, Int) -concept _Generator(x) if isValid(x(UInt(0))) +concept _Generator(x) if isValid(x(0)) fun mkGen(t: Type, generator: _Generator): Gen(t) - using FunType = Function(t, UInt) + using FunType = Function(t, Int) return Gen(t)(FunType(generator)) -fun ()(this: !Gen, sizeHint: UInt): ValueType = _generator(sizeHint) +fun ()(this: !Gen, sizeHint: Int): ValueType = _generator(sizeHint) fun isValid(this: Gen): Bool = _generator isSet -concept GenType(x) \ - if typeOf(x.ValueType) == Type \ - && typeOf(x.isValid) == Bool \ - && typeOf(x(0)) == x.ValueType +concept GenType(x) if x._isGenerator //! Arbitrary prototype //fun arbitrary(t: Type): t Gen @@ -35,7 +33,7 @@ fun arbitrary(t: Type): t Gen if Integer(#$t) //! Configuration options for our check function [initCtor] datatype CheckConfig - numTests, maxAttempts: UInt + numTests, maxAttempts: Int isVerbose: Bool fun ctor(this: !CheckConfig) numTests = 100 @@ -76,7 +74,7 @@ fun check(values: TestableValuesRange, predMsg: AnyType): Bool \ if isValid(predMsg.v1) fun check(values: TestableValuesRange, pred: AnyType, msg: StringRef, config: CheckConfig = CheckConfig()): Bool cout << "* Checking " << msg << endl - var classes: Map(String, UInt) + var classes: Map(String, Int) var numTrivial = 0 var n = 0 @@ -140,7 +138,7 @@ concept FreqGenType(x) if( ) //! Returns a generator that generates elements from the range -fun elements(r: Range): r.RetType Gen = _Impl.ElementsGen(typeOf(r))(r).gen +fun elements(r: Range): r.RetType Gen = tmpToMut(_Impl.ElementsGen(typeOf(r))(r)).gen //! Given a set of generators, this will randomly chose one of them fun oneOf(gens: Range): gens.RetType if GenType(#$gens.RetType) @@ -171,19 +169,19 @@ fun frequency(gens: Range): typeOf((#$gens.RetType).v2) if FreqGenType(#$gens.Re fun randBetween(min, max: Integer): commonType(typeOf(min), typeOf(max)) using T = commonType(typeOf(min), typeOf(max)) - using RAND_MAX = 0x7fffffff - let offset: T = T(Double(_Impl.rand()) / RAND_MAX * Double(max - min)) + using RAND_MAX = Float(0x7fffffff) + let offset: T = T(Float(_Impl.rand()) / RAND_MAX * Float(max - min)) return T(min) + offset package _Impl [native("rand")] - fun rand(): UInt + fun rand(): UInt32 package NumericGen(t: Type) if UnsignedInteger(#$t) - fun gen(sizeHint: UInt) = t(randBetween(0, 6 + sizeHint)) + fun gen(sizeHint: Int) = t(randBetween(0, 6 + sizeHint)) package NumericGen(t: Type) if SignedInteger(#$t) - fun gen(sizeHint: UInt): t + fun gen(sizeHint: Int): t let h: Int = sizeHint + 3 return t(randBetween(-h, h+1)) @@ -192,7 +190,7 @@ package _Impl using _T = t _gen: Gen(t) - _count: UInt + _count: Int fun ctor(this, other: !ForAllGenerator) this._gen ctor other._gen @@ -278,13 +276,13 @@ package _Impl using _RangeType = rangeType _range: rangeType - _count: SizeType + _count: Int fun ctor(this: !ElementsGen, range: this._RangeType) this._range ctor range this._count ctor (range rangeSize) - fun ()(this: !ElementsGen, sizeHint: UInt): ElementType + fun ()(this: !ElementsGen, sizeHint: Int): ElementType let r = _range r advance randBetween(0, Int(_count)) return r.front diff --git a/SparrowImplicitLib/logic/lRef.spr b/SparrowImplicitLib/logic/lRef.spr index 50dd4109..a7ec09d0 100644 --- a/SparrowImplicitLib/logic/lRef.spr +++ b/SparrowImplicitLib/logic/lRef.spr @@ -109,7 +109,7 @@ fun reset(this: !LRef, value: !this.ValueType) cout << "LRef.reset " << this << "\n" fun isUnique(this: !LRef) = _pptr.isUnique -fun useCount(this: !LRef): UInt = _pptr.useCount +fun useCount(this: !LRef): Int = _pptr.useCount fun isNull(this: !LRef) = _pptr.get().isNull fun isSet(this: !LRef) = _pptr.get().isSet diff --git a/SparrowImplicitLib/logic/prologImpl/errorReporter.spr b/SparrowImplicitLib/logic/prologImpl/errorReporter.spr index 98d57a48..4013d022 100644 --- a/SparrowImplicitLib/logic/prologImpl/errorReporter.spr +++ b/SparrowImplicitLib/logic/prologImpl/errorReporter.spr @@ -22,7 +22,7 @@ fun _printLocation(this: !ConsoleErrorReporter, os: !OutStream, loc: Location) os << '>' var endCol = loc.end.col if ( loc.start.line != loc.end.line ) - endCol = UInt(line.size()+1); + endCol = line.size()+1; if ( loc.start.col == endCol ) ++endCol; for i = 1..loc.start.col diff --git a/SparrowImplicitLib/logic/prologImpl/ir.spr b/SparrowImplicitLib/logic/prologImpl/ir.spr index 14f49023..9a4e1661 100644 --- a/SparrowImplicitLib/logic/prologImpl/ir.spr +++ b/SparrowImplicitLib/logic/prologImpl/ir.spr @@ -20,7 +20,7 @@ using allowNativeCodeGen = true for pptr: @PredicateClausePtr = program.get().predicates.all let p: @PredicateClause = pptr.get let name: @String = p.name - let arity: UInt = p.args.size + let arity = p.args.size // Search for an existing predicate with same name and same arity let r = findIf(predicates.all, @@ -45,7 +45,7 @@ using allowNativeCodeGen = true datatype SparrowPredicate name: String - arity: UInt + arity: Int firstClause: PredicateClausePtr paramVars: Vector(Parameter) localVars: Vector(ExpressionPtr) @@ -55,7 +55,7 @@ using allowNativeCodeGen = true fun ctor(this: !SparrowPredicate, firstClause: !PredicateClausePtr) this.name ctor firstClause.get().name - this.arity ctor UInt(firstClause.get().args.size) + this.arity ctor firstClause.get().args.size this.firstClause ctor firstClause this.paramVars ctor this.localVars ctor @@ -207,7 +207,7 @@ using allowNativeCodeGen = true // A name (param / local var) cannot be twice in an 'is' condition let varName: @String = left.data - let idx: DiffType = indexOf(isVars.all, left.data) + let idx = indexOf(isVars.all, left.data) if ( idx >= 0 ) canBeNative = false return diff --git a/SparrowImplicitLib/math.spr b/SparrowImplicitLib/math.spr index 5f5e9eed..a3a9b1fb 100644 --- a/SparrowImplicitLib/math.spr +++ b/SparrowImplicitLib/math.spr @@ -1,37 +1,37 @@ module math -[native("llvm.sqrt.f32")] fun sqrt(x: Float): Float -[native("llvm.sin.f32")] fun sin(x: Float): Float -[native("llvm.cos.f32")] fun cos(x: Float): Float -[native("llvm.powi.f32")] fun powi(x: Float, y: Int): Float -[native("llvm.pow.f32")] fun pow(x, y: Float): Float -[native("llvm.exp.f32")] fun exp(x: Float): Float -[native("llvm.exp2.f32")] fun exp2(x: Float): Float -[native("llvm.log.f32")] fun log(x: Float): Float -[native("llvm.log10.f32")] fun log10(x: Float): Float -[native("llvm.log2.f32")] fun log2(x: Float): Float -[native("llvm.fabs.f32")] fun fabs(x: Float): Float -[native("llvm.floor.f32")] fun floor(x: Float): Float -[native("llvm.ceil.f32")] fun ceil(x: Float): Float -[native("llvm.truc.f32")] fun truc(x: Float): Float -[native("llvm.rint.f32")] fun rint(x: Float): Float -[native("llvm.rint.f32")] fun nearbyint(x: Float): Float +[native("llvm.sqrt.f32")] fun sqrt(x: Float32): Float32 +[native("llvm.sin.f32")] fun sin(x: Float32): Float32 +[native("llvm.cos.f32")] fun cos(x: Float32): Float32 +[native("llvm.powi.f32")] fun powi(x: Float32, y: Int): Float32 +[native("llvm.pow.f32")] fun pow(x, y: Float32): Float32 +[native("llvm.exp.f32")] fun exp(x: Float32): Float32 +[native("llvm.exp2.f32")] fun exp2(x: Float32): Float32 +[native("llvm.log.f32")] fun log(x: Float32): Float32 +[native("llvm.log10.f32")] fun log10(x: Float32): Float32 +[native("llvm.log2.f32")] fun log2(x: Float32): Float32 +[native("llvm.fabs.f32")] fun fabs(x: Float32): Float32 +[native("llvm.floor.f32")] fun floor(x: Float32): Float32 +[native("llvm.ceil.f32")] fun ceil(x: Float32): Float32 +[native("llvm.truc.f32")] fun truc(x: Float32): Float32 +[native("llvm.rint.f32")] fun rint(x: Float32): Float32 +[native("llvm.rint.f32")] fun nearbyint(x: Float32): Float32 -[native("llvm.sqrt.f64")] fun sqrt(x: Double): Double -[native("llvm.sin.f64")] fun sin(x: Double): Double -[native("llvm.cos.f64")] fun cos(x: Double): Double -[native("llvm.powi.f64")] fun powi(x: Double, y: Int): Double -[native("llvm.pow.f64")] fun pow(x, y: Double): Double -[native("llvm.exp.f64")] fun exp(x: Double): Double -[native("llvm.exp2.f64")] fun exp2(x: Double): Double -[native("llvm.log.f64")] fun log(x: Double): Double -[native("llvm.log10.f64")] fun log10(x: Double): Double -[native("llvm.log2.f64")] fun log2(x: Double): Double -[native("llvm.fabs.f64")] fun fabs(x: Double): Double -[native("llvm.floor.f64")] fun floor(x: Double): Double -[native("llvm.ceil.f64")] fun ceil(x: Double): Double -[native("llvm.truc.f64")] fun truc(x: Double): Double -[native("llvm.rint.f64")] fun rint(x: Double): Double -[native("llvm.rint.f64")] fun nearbyint(x: Double): Double +[native("llvm.sqrt.f64")] fun sqrt(x: Float64): Float64 +[native("llvm.sin.f64")] fun sin(x: Float64): Float64 +[native("llvm.cos.f64")] fun cos(x: Float64): Float64 +[native("llvm.powi.f64")] fun powi(x: Float64, y: Int): Float64 +[native("llvm.pow.f64")] fun pow(x, y: Float64): Float64 +[native("llvm.exp.f64")] fun exp(x: Float64): Float64 +[native("llvm.exp2.f64")] fun exp2(x: Float64): Float64 +[native("llvm.log.f64")] fun log(x: Float64): Float64 +[native("llvm.log10.f64")] fun log10(x: Float64): Float64 +[native("llvm.log2.f64")] fun log2(x: Float64): Float64 +[native("llvm.fabs.f64")] fun fabs(x: Float64): Float64 +[native("llvm.floor.f64")] fun floor(x: Float64): Float64 +[native("llvm.ceil.f64")] fun ceil(x: Float64): Float64 +[native("llvm.truc.f64")] fun truc(x: Float64): Float64 +[native("llvm.rint.f64")] fun rint(x: Float64): Float64 +[native("llvm.rint.f64")] fun nearbyint(x: Float64): Float64 fun abs(x: Integer) = ife(x<0, -x, typeOf(x)(x)) diff --git a/SparrowImplicitLib/meta/location.spr b/SparrowImplicitLib/meta/location.spr index cffa04ce..f0abd4bc 100644 --- a/SparrowImplicitLib/meta/location.spr +++ b/SparrowImplicitLib/meta/location.spr @@ -3,7 +3,7 @@ module meta.location /// A line + column pair, indicating a position in a file [bitcopiable] datatype LineCol - line, col: UInt + line, col: Int /// Type describing a source code; for now we just use an untyped Ptr [bitcopiable] @@ -22,7 +22,7 @@ datatype Location //fun ctor(this: @Location) // setOne(this) -fun mkLineCol(line, col: UInt): LineCol +fun mkLineCol(line, col: Int): LineCol let res: !LineCol res.line = line res.col = col @@ -58,11 +58,11 @@ fun stepOver(l: !Location) l.start = l.end /// Add the given number of columns to the end position; start position remains unchanged -fun addColumns(l: !Location, count: UInt) +fun addColumns(l: !Location, count: Int) l.end.col += count /// Add the given number of lines to the end position; start position remains unchanged -fun addLines(l: !Location, count: UInt) +fun addLines(l: !Location, count: Int) l.end.line += count l.end.col = 1 diff --git a/SparrowImplicitLib/meta/sparrowNodes.spr b/SparrowImplicitLib/meta/sparrowNodes.spr index 5308b324..4058731a 100644 --- a/SparrowImplicitLib/meta/sparrowNodes.spr +++ b/SparrowImplicitLib/meta/sparrowNodes.spr @@ -53,17 +53,17 @@ [native("$meta.Sparrow.mkParenthesisExp")] fun mkParenthesisExp(loc: Location const, exp: AstNode): AstNode [native("$meta.Sparrow.mkIntLiteral")] - fun mkIntLiteral(loc: Location const, value: Int): AstNode + fun mkIntLiteral(loc: Location const, value: Int32): AstNode [native("$meta.Sparrow.mkUIntLiteral")] - fun mkUIntLiteral(loc: Location const, value: UInt): AstNode + fun mkUIntLiteral(loc: Location const, value: UInt32): AstNode [native("$meta.Sparrow.mkLongLiteral")] - fun mkLongLiteral(loc: Location const, value: Long): AstNode + fun mkLongLiteral(loc: Location const, value: Int64): AstNode [native("$meta.Sparrow.mkULongLiteral")] - fun mkULongLiteral(loc: Location const, value: ULong): AstNode + fun mkULongLiteral(loc: Location const, value: UInt64): AstNode [native("$meta.Sparrow.mkFloatLiteral")] - fun mkFloatLiteral(loc: Location const, value: Float): AstNode + fun mkFloatLiteral(loc: Location const, value: Float32): AstNode [native("$meta.Sparrow.mkDoubleLiteral")] - fun mkDoubleLiteral(loc: Location const, value: Double): AstNode + fun mkDoubleLiteral(loc: Location const, value: Float64): AstNode [native("$meta.Sparrow.mkCharLiteral")] fun mkCharLiteral(loc: Location const, value: Char): AstNode [native("$meta.Sparrow.mkStringLiteral")] diff --git a/SparrowImplicitLib/os.spr b/SparrowImplicitLib/os.spr index d1ef290b..a941abe5 100644 --- a/SparrowImplicitLib/os.spr +++ b/SparrowImplicitLib/os.spr @@ -53,13 +53,13 @@ fun readLine(this: !File): String return res fun write(this: !File, data: StringRef): Int - var res: Int = CApi.fwrite(UntypedPtr(data.begin), 1, UInt(data.size), this) + var res: Int = CApi.fwrite(UntypedPtr(data.begin), 1U, UInt32(data.size), this) return res //! Returns the file size. //! Note: as a side effect, seeks the file to the beginning fun size(this: !File): Int - CApi.fseek(this, 0, CApi.SEEK_END) + CApi.fseek(this, 0L, CApi.SEEK_END) var res: Int = CApi.ftell(this) CApi.rewind(this) return res @@ -99,11 +99,11 @@ package CApi [native("feof")] fun feof(file: File): Int [native("fgetc")] fun fgetc(file: File): Int [native("fgets")] fun fgets(buffer: UntypedPtr, bufSize: Int, file: File): @Char - [native("fread")] fun fread(buffer: UntypedPtr, size, count: UInt, file: File): UInt - [native("fwrite")] fun fwrite(buffer: UntypedPtr, size, count: UInt, file: File): UInt - [native("fseek")] fun fseek(file: File, offset: Long, origin: Int) + [native("fread")] fun fread(buffer: UntypedPtr, size, count: UInt32, file: File): UInt32 + [native("fwrite")] fun fwrite(buffer: UntypedPtr, size, count: UInt32, file: File): UInt32 + [native("fseek")] fun fseek(file: File, offset: Int64, origin: Int) [native("rewind")] fun rewind(file: File) - [native("ftell")] fun ftell(file: File): Long + [native("ftell")] fun ftell(file: File): Int64 using SEEK_SET = 0 using SEEK_CUR = 1 diff --git a/SparrowImplicitLib/par/atomic.spr b/SparrowImplicitLib/par/atomic.spr index e597dfa6..8b0667d0 100644 --- a/SparrowImplicitLib/par/atomic.spr +++ b/SparrowImplicitLib/par/atomic.spr @@ -3,8 +3,8 @@ module par.atomic import config import "atomic.llvm" -using AtomicInt = Atomic(Int) -using AtomicLong = Atomic(Long) +using AtomicInt32 = Atomic(Int32) +using AtomicInt64 = Atomic(Int64) concept AtomicType(x) if x._IsAtomicType concept AtomicInteger(x) if x._IsAtomicType && Integer(#$x.ValueType) @@ -27,26 +27,26 @@ datatype Atomic(T: Type) if sizeOf(T) <= 8 fun =(this: !AtomicType, val: this.ValueType) = this store val //! Loads the value from an atomic; returns a non-atomic value - [native("_Atomic_load32")] fun load(this: AtomicInt const): Int - [native("_Atomic_load64")] fun load(this: AtomicLong const): Long + [native("_Atomic_load32")] fun load(this: AtomicInt32 const): Int32 + [native("_Atomic_load64")] fun load(this: AtomicInt64 const): Int64 fun load(this: NonStdAtomicType): ValueType \ = this._fromUnderlying(this._baseAtomic load) //! Stores a value inside the given atomic - [native("_Atomic_store32")] fun store(this: !AtomicInt, newVal: Int) - [native("_Atomic_store64")] fun store(this: !AtomicLong, newVal: Long) + [native("_Atomic_store32")] fun store(this: !AtomicInt32, newVal: Int32) + [native("_Atomic_store64")] fun store(this: !AtomicInt64, newVal: Int64) fun store(this: !NonStdAtomicType, newVal: AnyType) this._baseAtomic store this._toUnderlying(newVal) //! Fetches the current value of an atomic, and stores a new value in the atomic - [native("_Atomic_fetchAndStore32")] fun fetchAndStore(x: !AtomicInt, newVal: Int): Int - [native("_Atomic_fetchAndStore64")] fun fetchAndStore(x: !AtomicLong, newVal: Long): Long + [native("_Atomic_fetchAndStore32")] fun fetchAndStore(x: !AtomicInt32, newVal: Int32): Int32 + [native("_Atomic_fetchAndStore64")] fun fetchAndStore(x: !AtomicInt64, newVal: Int64): Int64 fun fetchAndStore(x: !NonStdAtomicType, newVal: AnyType): x.ValueType \ = x._fromUnderlying(x._baseAtomic fetchAndStore x._toUnderlying(newVal)) //! Fetch the value of the atomic, and then add the given value to it - [native("_Atomic_fetchAndAdd32")] fun fetchAndAdd(x: !AtomicInt, val: Int): Int - [native("_Atomic_fetchAndAdd64")] fun fetchAndAdd(x: !AtomicLong, val: Long): Long + [native("_Atomic_fetchAndAdd32")] fun fetchAndAdd(x: !AtomicInt32, val: Int32): Int32 + [native("_Atomic_fetchAndAdd64")] fun fetchAndAdd(x: !AtomicInt64, val: Int64): Int64 fun fetchAndAdd(x: !NonStdAtomicType, val: AnyType): x.ValueType \ = x._fromUnderlying(x._baseAtomic fetchAndAdd x._toUnderlying(val)) \ if Integer(#$x.ValueType) @@ -82,8 +82,8 @@ datatype Atomic(T: Type) if sizeOf(T) <= 8 fun _baseAtomic(this: Atomic): @Atomic(_UnderlyingType) = reinterpretCast(@Atomic(_UnderlyingType), this) //! Compare the atomic value with the given comparand; if equal store 'newVal' and return true; if not equal returns false -[native("_Atomic_compareAndSwap32")] fun compareAndSwap(x: !AtomicInt, newVal, comparand: Int): Bool -[native("_Atomic_compareAndSwap64")] fun compareAndSwap(x: !AtomicLong, newVal, comparand: Long): Bool +[native("_Atomic_compareAndSwap32")] fun compareAndSwap(x: !AtomicInt32, newVal, comparand: Int32): Bool +[native("_Atomic_compareAndSwap64")] fun compareAndSwap(x: !AtomicInt64, newVal, comparand: Int64): Bool fun compareAndSwap(x: !NonStdAtomicType, newVal, comparand: AnyType): Bool \ = compareAndSwap(x._baseAtomic, x._toUnderlying(newVal), x._toUnderlying(comparand)) @@ -95,6 +95,6 @@ fun asAtomic(val: !AnyType): @Atomic(-@typeOf(val)) if sizeOf(val) == sizeOf(Ato package _Impl datatype AtomicTypeTraits(T: Type) if sizeOf(T) <= 4 - using _UnderlyingType = Int + using _UnderlyingType = Int32 datatype AtomicTypeTraits(T: Type) if sizeOf(T) == 8 - using _UnderlyingType = Long + using _UnderlyingType = Int64 diff --git a/SparrowImplicitLib/par/config.spr b/SparrowImplicitLib/par/config.spr index deade66b..e1e7d9aa 100644 --- a/SparrowImplicitLib/par/config.spr +++ b/SparrowImplicitLib/par/config.spr @@ -3,7 +3,7 @@ module par.config import std.ptr [bitcopiable] -datatype NativeThreadHandle = Byte Ptr // Opaque type +datatype NativeThreadHandle = Int8 Ptr // Opaque type fun >>(h: NativeThreadHandle, os: !OutStream) if ( h.impl.isSet ) @@ -15,13 +15,13 @@ using InvalidThreadHandle = NativeThreadHandle() //! Get the number of available logical CPU cores for our process //! This dictates how much parallelism we have to be exploit -fun getAvailableCoresNum(): UInt - let maxProcs: Long = _Impl.sysconf(_Impl._SC_NPROCESSORS_ONLN) - return ife(maxProcs<1, UInt(1), UInt(maxProcs)) +fun getAvailableCoresNum(): Int + let maxProcs: Int = _Impl.sysconf(_Impl._SC_NPROCESSORS_ONLN) + return ife(maxProcs<1, 1, maxProcs) // TODO: also consider process affinity package _Impl using _SC_NPROCESSORS_ONLN = 58 - [native("sysconf")] fun sysconf(name: Int): Long + [native("sysconf")] fun sysconf(name: Int): Int64 diff --git a/SparrowImplicitLib/par/locks.spr b/SparrowImplicitLib/par/locks.spr index fe733f83..91ebd494 100644 --- a/SparrowImplicitLib/par/locks.spr +++ b/SparrowImplicitLib/par/locks.spr @@ -78,12 +78,12 @@ fun unlock(mutex: !RecMutex) { let res = Impl.pthread_mutex_unlock(mutex.handle) package Impl using PTHREAD_MUTEX_SIZE = 56 - using PTHREAD_MUTEX_SIG_INIT = 0x32AAABA7 - using PTHREAD_RECURSIVE_MUTEX_SIG_INIT = 0x32AAABA2 + using PTHREAD_MUTEX_SIG_INIT = 0x32AAABA7L + using PTHREAD_RECURSIVE_MUTEX_SIG_INIT = 0x32AAABA2L datatype PThreadMutex - sig: Long - opaque: StaticArray(Byte, PTHREAD_MUTEX_SIZE) + sig: Int64 + opaque: StaticArray(Int8, PTHREAD_MUTEX_SIZE) [native("pthread_mutex_init")] fun pthread_mutex_init(mutex: !PThreadMutex, attr: UntypedPtr): Int [native("pthread_mutex_lock")] fun pthread_mutex_lock(mutex: !PThreadMutex): Int diff --git a/SparrowImplicitLib/par/parFor.spr b/SparrowImplicitLib/par/parFor.spr index e1e27124..400e51b5 100644 --- a/SparrowImplicitLib/par/parFor.spr +++ b/SparrowImplicitLib/par/parFor.spr @@ -11,7 +11,7 @@ concept Partitioner(x) \ && isValid(x.partition(valueOfType(x.RangeType), 0)) fun parFor(r: Range, f: AnyType) if isValid(f(r.front())) - Impl.parFor(r, f, DefaultPartitioner(typeOf(r))()) + Impl.parFor(r, f, tmpToMut(DefaultPartitioner(typeOf(r))())) fun parFor(r: Range, f: AnyType, part: !Partitioner) if isValid(f(r.front())) Impl.parFor(r, f, part) @@ -41,7 +41,7 @@ fun partition(this: !DefaultPartitioner, r: Range, depth: Int) : RangeType * Ran datatype BoundedRange(baseRangeType: Type) _baseRange: baseRangeType - _count: SizeType + _count: Int using RetType = baseRangeType.RetType using _RangeType = baseRangeType @@ -50,7 +50,7 @@ fun ctor(this: !BoundedRange, r: this._RangeType) _baseRange ctor r _count = (_baseRange rangeSize) -fun ctor(this: !BoundedRange, r: typeOf(this), nSkip, nTake: SizeType) +fun ctor(this: !BoundedRange, r: typeOf(this), nSkip, nTake: Int) _baseRange ctor r._baseRange _baseRange advance nSkip _count ctor nTake diff --git a/SparrowImplicitLib/par/semaphore.spr b/SparrowImplicitLib/par/semaphore.spr index d389f446..03af172c 100644 --- a/SparrowImplicitLib/par/semaphore.spr +++ b/SparrowImplicitLib/par/semaphore.spr @@ -8,7 +8,7 @@ import config datatype Semaphore _handle: _Impl.SemaphoreT -fun ctor(this: !Semaphore, startValue: UInt = 0) +fun ctor(this: !Semaphore, startValue: Int = 0) _handle ctor let res = _Impl.semaphore_create(_Impl.mach_task_self(), _handle, _Impl.SYNC_POLICY_FIFO, Int(startValue)) @@ -38,7 +38,7 @@ package _Impl //using SemType = Int; - //[native("sem_init")] fun sem_init(s: !SemType, pshared: Int, value: UInt): Int; + //[native("sem_init")] fun sem_init(s: !SemType, pshared: Int, value: Int): Int; //[native("sem_destroy")] fun sem_destroy(s: !SemType): Int; //[native("sem_wait")] fun sem_wait(s: !SemType): Int; //[native("sem_post")] fun sem_post(s: !SemType): Int; diff --git a/SparrowImplicitLib/par/tasksImpl/taskPrefix.spr b/SparrowImplicitLib/par/tasksImpl/taskPrefix.spr index 56fa7e8f..d19919e6 100644 --- a/SparrowImplicitLib/par/tasksImpl/taskPrefix.spr +++ b/SparrowImplicitLib/par/tasksImpl/taskPrefix.spr @@ -9,7 +9,7 @@ using TaskPtr = TaskPrefix Ptr datatype TaskPrefix //! The function to be called to execute the task (along with its 'this' offset) /*private*/ executeFn: FunctionPtr(Null rt, @TaskPrefix) - /*private*/ taskOffset: DiffType + /*private*/ taskOffset: Int //! The parent task of this task null for root tasks /*private*/ parent: TaskPrefix Ptr diff --git a/SparrowImplicitLib/par/tasksImpl/taskQueue.spr b/SparrowImplicitLib/par/tasksImpl/taskQueue.spr index 6e5c65a0..69b54ffc 100644 --- a/SparrowImplicitLib/par/tasksImpl/taskQueue.spr +++ b/SparrowImplicitLib/par/tasksImpl/taskQueue.spr @@ -26,12 +26,12 @@ fun empty(q: !TaskQueue): Bool let lock: ScopedLock(Mutex) = q._mutex return q._first isNull -fun size(q: !TaskQueue): SizeType +fun size(q: !TaskQueue): Int let lock: ScopedLock(Mutex) = q._mutex return q uncheckedSize -fun uncheckedSize(q: !TaskQueue): SizeType - var count: SizeType = 0 +fun uncheckedSize(q: !TaskQueue): Int + var count: Int = 0 var p: TaskPtr = q._first while p isSet ++count diff --git a/SparrowImplicitLib/par/tasksImpl/taskSystem.spr b/SparrowImplicitLib/par/tasksImpl/taskSystem.spr index 951e2e77..a032b654 100644 --- a/SparrowImplicitLib/par/tasksImpl/taskSystem.spr +++ b/SparrowImplicitLib/par/tasksImpl/taskSystem.spr @@ -26,7 +26,7 @@ datatype TaskSystem var globalTaskSystem: TaskSystem Ptr -fun initTaskSystem(numWorkers: UInt = 0) +fun initTaskSystem(numWorkers: Int = 0) // Create the task system object //assert(globalTaskSystem isNull) globalTaskSystem = new(TaskSystem) @@ -70,4 +70,4 @@ fun onTaskAvailable(ts: !TaskSystem) return //! Get the number of currently available workers -fun numAvailableWorkers(ts: !TaskSystem): SizeType = (ts.workers size) - (ts.idleCounter numIdleWorkers) +fun numAvailableWorkers(ts: !TaskSystem): Int = (ts.workers size) - (ts.idleCounter numIdleWorkers) diff --git a/SparrowImplicitLib/par/tasksImpl/workerImpl.spr b/SparrowImplicitLib/par/tasksImpl/workerImpl.spr index cd467dca..9a1fde1b 100644 --- a/SparrowImplicitLib/par/tasksImpl/workerImpl.spr +++ b/SparrowImplicitLib/par/tasksImpl/workerImpl.spr @@ -113,7 +113,7 @@ datatype TaskSystem var globalTaskSystem: TaskSystem Ptr -fun initTaskSystem(numWorkers: UInt = 0) +fun initTaskSystem(numWorkers: Int = 0) // Create the task system object //assert(globalTaskSystem isNull) globalTaskSystem = new(TaskSystem) @@ -157,7 +157,7 @@ fun onTaskAvailable(ts: !TaskSystem) return //! Get the number of currently available workers -fun numAvailableWorkers(ts: !TaskSystem): SizeType = (ts.workers size) - (ts.idleCounter numIdleWorkers) +fun numAvailableWorkers(ts: !TaskSystem): Int = (ts.workers size) - (ts.idleCounter numIdleWorkers) //////////////////////////////////////////////////////////////////////////////// // InternalWorkerThread datatype diff --git a/SparrowImplicitLib/par/thread.spr b/SparrowImplicitLib/par/thread.spr index 433a5855..d91d08e2 100644 --- a/SparrowImplicitLib/par/thread.spr +++ b/SparrowImplicitLib/par/thread.spr @@ -7,9 +7,9 @@ import std.newDelete //! Datatype describing a thread ID [bitcopiable] datatype ThreadId - id: ULong + id: UInt64 -fun ctor(this: !ThreadId, id: ULong) +fun ctor(this: !ThreadId, id: UInt64) this.id ctor id fun ctor(this: !ThreadId, h: NativeThreadHandle) this.id ctor @@ -78,9 +78,9 @@ fun curThreadId: ThreadId = ThreadId(NativeThreadHandle()) fun yield = _Impl.sched_yield() //! Sleep the given amount of milliseconds -fun sleep(durMs: UInt) - let req = _Impl.TimeSpec(durMs/1000, (durMs%1000)*1000000) - let rem = _Impl.TimeSpec(0, 0) +fun sleepMs(durMs: Int) + let req = _Impl.TimeSpec(Int64(durMs/1000), Int64((durMs%1000))*1000000L) + let rem = _Impl.TimeSpec(0L, 0L) _Impl.nanosleep(req, rem) package _Impl @@ -107,14 +107,14 @@ package _Impl return handle [initCtor, bitcopiable] datatype TimeSpec - tv_sec, tv_nsec: Long + tv_sec, tv_nsec: Int64 [native("pthread_create")] fun pthread_create(handle: !NativeThreadHandle, attr: UntypedPtr, f: ThreadFun, arg: UntypedPtr): Int [native("pthread_join")] fun pthread_join(handle: NativeThreadHandle, valPtr: UntypedPtr): Int [native("pthread_detach")] fun pthread_detach(handle: NativeThreadHandle): Int [native("pthread_self")] fun pthread_self: NativeThreadHandle - [native("pthread_threadid_np")] fun pthread_threadid_np(t: NativeThreadHandle, res: !ULong): Int + [native("pthread_threadid_np")] fun pthread_threadid_np(t: NativeThreadHandle, res: !UInt64): Int [native("sched_yield")] fun sched_yield [native("nanosleep")] fun nanosleep(req, rem: !TimeSpec): Int diff --git a/SparrowImplicitLib/par/tls.spr b/SparrowImplicitLib/par/tls.spr index 0fd0bcce..e957760b 100644 --- a/SparrowImplicitLib/par/tls.spr +++ b/SparrowImplicitLib/par/tls.spr @@ -46,7 +46,7 @@ package _Impl fun setValue(tls: TlsCommon, val: UntypedPtr) = pthread_setspecific(tls.key, val) fun getValue(tls: TlsCommon): UntypedPtr = pthread_getspecific(tls.key) - using KeyT = ULong + using KeyT = UInt64 [native("pthread_key_create")] fun pthread_key_create(k: !KeyT, dtorFun: DtorFun): Int [native("pthread_key_delete")] fun pthread_key_delete(k: KeyT): Int diff --git a/SparrowImplicitLib/sprCore/basicDecls.spr b/SparrowImplicitLib/sprCore/basicDecls.spr index 7db10005..e6388bde 100644 --- a/SparrowImplicitLib/sprCore/basicDecls.spr +++ b/SparrowImplicitLib/sprCore/basicDecls.spr @@ -11,24 +11,28 @@ [native("_Type_copy_ctor")] fun ctor(this: !Type, other: Type) [noDefault, bitcopiable] - datatype Uninitialized {} - - [native("Null")] datatype Null {} - - [native("i1")] datatype Bool {} - [native("i8")] datatype Byte {} - [convert, native("u8")] datatype UByte {} - [convert, native("i16")] datatype Short {} - [convert, native("u16")] datatype UShort {} - [convert, native("i32")] datatype Int {} - [convert, native("u32")] datatype UInt {} - [convert, native("i64")] datatype Long {} - [convert, native("u64")] datatype ULong {} - [convert, native("u64")] datatype SizeType {} - [convert, native("i64")] datatype DiffType {} - [convert, native("float")] datatype Float {} - [convert, native("double")] datatype Double {} - [native("i8")] datatype Char {} + datatype Uninitialized + + [native("Null")] datatype Null + + [native("i1")] datatype Bool + + [native("i8")] datatype Int8 + [native("u8")] datatype UInt8 + [native("i16")] datatype Int16 + [native("u16")] datatype UInt16 + [native("i32")] datatype Int + [native("u32")] datatype UInt32 + [native("i64")] datatype Int64 + [native("u64")] datatype UInt64 + + [native("float")] datatype Float32 + [native("double")] datatype Float + + [native("i8")] datatype Char + +using Int32 = Int +using Float64 = Float [protected] fun ctor(this: Uninitialized) {} @@ -49,245 +53,181 @@ fun dtor(this: Bool) {} [autoCt, native("_ass_1_1")] fun = (this: !Bool, other: Bool): Bool - [native("_zero_init_8")] fun ctor(this: !Byte) - [native("_ass_8_8")] fun ctor(this: !Byte, src: Byte) - [native("_ass_8_8")] fun ctor(this: !Byte, src: Char) - [native("_ass_8_8")] fun ctor(this: !Byte, src: UByte) - [native("_ass_8_16")] fun ctor(this: !Byte, src: Short) - [native("_ass_8_16")] fun ctor(this: !Byte, src: UShort) - [native("_ass_8_32")] fun ctor(this: !Byte, src: Int) - [native("_ass_8_32")] fun ctor(this: !Byte, src: UInt) - [native("_ass_8_64")] fun ctor(this: !Byte, src: Long) - [native("_ass_8_64")] fun ctor(this: !Byte, src: ULong) - [native("_ass_8_64")] fun ctor(this: !Byte, src: SizeType) - [native("_ass_8_64")] fun ctor(this: !Byte, src: DiffType) - [native("_ass_i8_f")] fun ctor(this: !Byte, src: Float) - [native("_ass_i8_d")] fun ctor(this: !Byte, src: Double) - fun dtor(this: Byte) {} - [native("_ass_8_8")] fun = (this: !Byte, other: Byte) - - [native("_zero_init_8")] fun ctor(this: !UByte) - [native("_ass_8_8"), convert] fun ctor(this: !UByte, src: Byte) - [native("_ass_8_8")] fun ctor(this: !UByte, src: UByte) - [native("_ass_8_16")] fun ctor(this: !UByte, src: Short) - [native("_ass_8_16")] fun ctor(this: !UByte, src: UShort) - [native("_ass_8_32")] fun ctor(this: !UByte, src: Int) - [native("_ass_8_32")] fun ctor(this: !UByte, src: UInt) - [native("_ass_8_64")] fun ctor(this: !UByte, src: Long) - [native("_ass_8_64")] fun ctor(this: !UByte, src: ULong) - [native("_ass_8_64")] fun ctor(this: !UByte, src: SizeType) - [native("_ass_8_64")] fun ctor(this: !UByte, src: DiffType) - [native("_ass_u8_f")] fun ctor(this: !UByte, src: Float) - [native("_ass_u8_d")] fun ctor(this: !UByte, src: Double) - fun dtor(this: UByte) {} - [native("_ass_8_8")] fun = (this: !UByte, other: UByte) - - [native("_zero_init_16")] fun ctor(this: !Short) - [native("_ass_16_8s"), convert] fun ctor(this: !Short, src: Byte) - [native("_ass_16_8z"), convert] fun ctor(this: !Short, src: UByte) - [native("_ass_16_16")] fun ctor(this: !Short, src: Short) - [native("_ass_16_16")] fun ctor(this: !Short, src: UShort) - [native("_ass_16_32")] fun ctor(this: !Short, src: Int) - [native("_ass_16_32")] fun ctor(this: !Short, src: UInt) - [native("_ass_16_64")] fun ctor(this: !Short, src: Long) - [native("_ass_16_64")] fun ctor(this: !Short, src: ULong) - [native("_ass_16_64")] fun ctor(this: !Short, src: SizeType) - [native("_ass_16_64")] fun ctor(this: !Short, src: DiffType) - [native("_ass_i16_f")] fun ctor(this: !Short, src: Float) - [native("_ass_i16_d")] fun ctor(this: !Short, src: Double) - fun dtor(this: Short) {} - [native("_ass_16_16")] fun = (this: !Short, other: Short) - - [native("_zero_init_16")] fun ctor(this: !UShort) - [native("_ass_16_8z"), convert] fun ctor(this: !UShort, src: Byte) - [native("_ass_16_8z"), convert] fun ctor(this: !UShort, src: UByte) - [native("_ass_16_16"), convert] fun ctor(this: !UShort, src: Short) - [native("_ass_16_16")] fun ctor(this: !UShort, src: UShort) - [native("_ass_16_32")] fun ctor(this: !UShort, src: Int) - [native("_ass_16_32")] fun ctor(this: !UShort, src: UInt) - [native("_ass_16_64")] fun ctor(this: !UShort, src: Long) - [native("_ass_16_64")] fun ctor(this: !UShort, src: ULong) - [native("_ass_16_64")] fun ctor(this: !UShort, src: SizeType) - [native("_ass_16_64")] fun ctor(this: !UShort, src: DiffType) - [native("_ass_u16_f")] fun ctor(this: !UShort, src: Float) - [native("_ass_u16_d")] fun ctor(this: !UShort, src: Double) - fun dtor(this: UShort) {} - [native("_ass_16_16")] fun = (this: !UShort, other: UShort) - - [native("_zero_init_32")] fun ctor(this: !Int) - [native("_ass_32_8s"), convert] fun ctor(this: !Int, src: Byte) - [native("_ass_32_8z"), convert] fun ctor(this: !Int, src: UByte) - [native("_ass_32_16s"), convert] fun ctor(this: !Int, src: Short) - [native("_ass_32_16z"), convert] fun ctor(this: !Int, src: UShort) - [native("_ass_32_32")] fun ctor(this: !Int, src: Int) - [native("_ass_32_32")] fun ctor(this: !Int, src: UInt) - [native("_ass_32_64")] fun ctor(this: !Int, src: Long) - [native("_ass_32_64")] fun ctor(this: !Int, src: ULong) - [native("_ass_32_64")] fun ctor(this: !Int, src: SizeType) - [native("_ass_32_64")] fun ctor(this: !Int, src: DiffType) - [native("_ass_i32_f")] fun ctor(this: !Int, src: Float) - [native("_ass_i32_d")] fun ctor(this: !Int, src: Double) - [native("_ass_32_8z")] fun ctor(this: !Int, src: Char) - fun dtor(this: Int) {} - [native("_ass_32_32")] fun = (this: !Int, other: Int) - - [native("_zero_init_32")] fun ctor(this: !UInt) - [native("_ass_32_8z"), convert] fun ctor(this: !UInt, src: Byte) - [native("_ass_32_8z"), convert] fun ctor(this: !UInt, src: UByte) - [native("_ass_32_16z"), convert] fun ctor(this: !UInt, src: Short) - [native("_ass_32_16z"), convert] fun ctor(this: !UInt, src: UShort) - [native("_ass_32_32"), convert] fun ctor(this: !UInt, src: Int) - [native("_ass_32_32")] fun ctor(this: !UInt, src: UInt) - [native("_ass_32_64")] fun ctor(this: !UInt, src: Long) - [native("_ass_32_64")] fun ctor(this: !UInt, src: ULong) - [native("_ass_32_64")] fun ctor(this: !UInt, src: SizeType) - [native("_ass_32_64")] fun ctor(this: !UInt, src: DiffType) - [native("_ass_u32_f")] fun ctor(this: !UInt, src: Float) - [native("_ass_u32_d")] fun ctor(this: !UInt, src: Double) - fun dtor(this: UInt) {} - [native("_ass_32_32")] fun = (this: !UInt, other: UInt) - - [native("_zero_init_64")] fun ctor(this: !Long) - [native("_ass_64_8s"), convert] fun ctor(this: !Long, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !Long, src: UByte) - [native("_ass_64_16s"), convert] fun ctor(this: !Long, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !Long, src: UShort) - [native("_ass_64_32s"), convert] fun ctor(this: !Long, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !Long, src: UInt) - [native("_ass_64_64")] fun ctor(this: !Long, src: Long) - [native("_ass_64_64")] fun ctor(this: !Long, src: ULong) - [native("_ass_64_64"), convert] fun ctor(this: !Long, src: SizeType) - [native("_ass_64_64"), convert] fun ctor(this: !Long, src: DiffType) - [native("_ass_i64_f")] fun ctor(this: !Long, src: Float) - [native("_ass_i64_d")] fun ctor(this: !Long, src: Double) - fun dtor(this: Long) {} - [native("_ass_64_64")] fun = (this: !Long, other: Long) - - [native("_zero_init_64")] fun ctor(this: !ULong) - [native("_ass_64_8z"), convert] fun ctor(this: !ULong, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !ULong, src: UByte) - [native("_ass_64_16z"), convert] fun ctor(this: !ULong, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !ULong, src: UShort) - [native("_ass_64_32z"), convert] fun ctor(this: !ULong, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !ULong, src: UInt) - [native("_ass_64_64"), convert] fun ctor(this: !ULong, src: Long) - [native("_ass_64_64")] fun ctor(this: !ULong, src: ULong) - [native("_ass_64_64"), convert] fun ctor(this: !ULong, src: SizeType) - [native("_ass_64_64"), convert] fun ctor(this: !ULong, src: DiffType) - [native("_ass_u64_f")] fun ctor(this: !ULong, src: Float) - [native("_ass_u64_d")] fun ctor(this: !ULong, src: Double) - fun dtor(this: ULong) {} - [native("_ass_64_64")] fun = (this: !ULong, other: ULong) - - [native("_zero_init_64")] fun ctor(this: !SizeType) - [native("_ass_64_8z"), convert] fun ctor(this: !SizeType, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !SizeType, src: UByte) - [native("_ass_64_16z"), convert] fun ctor(this: !SizeType, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !SizeType, src: UShort) - [native("_ass_64_32z"), convert] fun ctor(this: !SizeType, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !SizeType, src: UInt) - [native("_ass_64_64")] fun ctor(this: !SizeType, src: Long) - [native("_ass_64_64")] fun ctor(this: !SizeType, src: ULong) - [native("_ass_64_64")] fun ctor(this: !SizeType, src: SizeType) - [native("_ass_64_64"), convert] fun ctor(this: !SizeType, src: DiffType) - [native("_ass_u64_f")] fun ctor(this: !SizeType, src: Float) - [native("_ass_u64_d")] fun ctor(this: !SizeType, src: Double) - fun dtor(this: SizeType) {} - [native("_ass_64_64")] fun = (this: !SizeType, other: SizeType) - - [native("_zero_init_64")] fun ctor(this: !DiffType) - [native("_ass_64_8s"), convert] fun ctor(this: !DiffType, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !DiffType, src: UByte) - [native("_ass_64_16s"), convert] fun ctor(this: !DiffType, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !DiffType, src: UShort) - [native("_ass_64_32s"), convert] fun ctor(this: !DiffType, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !DiffType, src: UInt) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: Long) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: ULong) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: SizeType) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: DiffType) - [native("_ass_i64_f")] fun ctor(this: !DiffType, src: Float) - [native("_ass_i64_d")] fun ctor(this: !DiffType, src: Double) - fun dtor(this: DiffType) {} - [native("_ass_64_64")] fun = (this: !DiffType, other: DiffType) - - [native("_zero_init_f")] fun ctor(this: !Float) - [native("_ass_f_i8"), convert] fun ctor(this: !Float, src: Byte) - [native("_ass_f_u8"), convert] fun ctor(this: !Float, src: UByte) - [native("_ass_f_i16"), convert] fun ctor(this: !Float, src: Short) - [native("_ass_f_u16"), convert] fun ctor(this: !Float, src: UShort) - [native("_ass_f_i32"), convert] fun ctor(this: !Float, src: Int) - [native("_ass_f_u32"), convert] fun ctor(this: !Float, src: UInt) - [native("_ass_f_i64"), convert] fun ctor(this: !Float, src: Long) - [native("_ass_f_u64"), convert] fun ctor(this: !Float, src: ULong) - [native("_ass_f_i64"), convert] fun ctor(this: !Float, src: SizeType) - [native("_ass_f_u64"), convert] fun ctor(this: !Float, src: DiffType) - [native("_ass_f_f")] fun ctor(this: !Float, src: Float) - [native("_ass_f_d")] fun ctor(this: !Float, src: Double) - fun dtor(this: Float) {} - [native("_ass_f_f")] fun = (this: !Float, other: Float) - - [native("_zero_init_d")] fun ctor(this: !Double) - [native("_ass_d_i8"), convert] fun ctor(this: !Double, src: Byte) - [native("_ass_d_u8"), convert] fun ctor(this: !Double, src: UByte) - [native("_ass_d_i16"), convert] fun ctor(this: !Double, src: Short) - [native("_ass_d_u16"), convert] fun ctor(this: !Double, src: UShort) - [native("_ass_d_i32"), convert] fun ctor(this: !Double, src: Int) - [native("_ass_d_u32"), convert] fun ctor(this: !Double, src: UInt) - [native("_ass_d_i64"), convert] fun ctor(this: !Double, src: Long) - [native("_ass_d_u64"), convert] fun ctor(this: !Double, src: ULong) - [native("_ass_d_i64"), convert] fun ctor(this: !Double, src: SizeType) - [native("_ass_d_u64"), convert] fun ctor(this: !Double, src: DiffType) - [native("_ass_d_f"), convert] fun ctor(this: !Double, src: Float) - [native("_ass_d_d")] fun ctor(this: !Double, src: Double) - fun dtor(this: Double) {} - [native("_ass_d_d")] fun = (this: !Double, other: Double) + [native("_zero_init_8")] fun ctor(this: !Int8) + [native("_ass_8_8")] fun ctor(this: !Int8, src: Int8) + [native("_ass_8_8")] fun ctor(this: !Int8, src: Char) + [native("_ass_8_8")] fun ctor(this: !Int8, src: UInt8) + [native("_ass_8_16")] fun ctor(this: !Int8, src: Int16) + [native("_ass_8_16")] fun ctor(this: !Int8, src: UInt16) + [native("_ass_8_32")] fun ctor(this: !Int8, src: Int32) + [native("_ass_8_32")] fun ctor(this: !Int8, src: UInt32) + [native("_ass_8_64")] fun ctor(this: !Int8, src: Int64) + [native("_ass_8_64")] fun ctor(this: !Int8, src: UInt64) + [native("_ass_i8_f")] fun ctor(this: !Int8, src: Float32) + [native("_ass_i8_d")] fun ctor(this: !Int8, src: Float64) + fun dtor(this: Int8) {} + [native("_ass_8_8")] fun = (this: !Int8, other: Int8) + + [native("_zero_init_8")] fun ctor(this: !UInt8) + [native("_ass_8_8")] fun ctor(this: !UInt8, src: Int8) + [native("_ass_8_8")] fun ctor(this: !UInt8, src: UInt8) + [native("_ass_8_16")] fun ctor(this: !UInt8, src: Int16) + [native("_ass_8_16")] fun ctor(this: !UInt8, src: UInt16) + [native("_ass_8_32")] fun ctor(this: !UInt8, src: Int32) + [native("_ass_8_32")] fun ctor(this: !UInt8, src: UInt32) + [native("_ass_8_64")] fun ctor(this: !UInt8, src: Int64) + [native("_ass_8_64")] fun ctor(this: !UInt8, src: UInt64) + [native("_ass_u8_f")] fun ctor(this: !UInt8, src: Float32) + [native("_ass_u8_d")] fun ctor(this: !UInt8, src: Float64) + fun dtor(this: UInt8) {} + [native("_ass_8_8")] fun = (this: !UInt8, other: UInt8) + + [native("_zero_init_16")] fun ctor(this: !Int16) + [native("_ass_16_8s")] fun ctor(this: !Int16, src: Int8) + [native("_ass_16_8z")] fun ctor(this: !Int16, src: UInt8) + [native("_ass_16_16")] fun ctor(this: !Int16, src: Int16) + [native("_ass_16_16")] fun ctor(this: !Int16, src: UInt16) + [native("_ass_16_32")] fun ctor(this: !Int16, src: Int32) + [native("_ass_16_32")] fun ctor(this: !Int16, src: UInt32) + [native("_ass_16_64")] fun ctor(this: !Int16, src: Int64) + [native("_ass_16_64")] fun ctor(this: !Int16, src: UInt64) + [native("_ass_i16_f")] fun ctor(this: !Int16, src: Float32) + [native("_ass_i16_d")] fun ctor(this: !Int16, src: Float64) + fun dtor(this: Int16) {} + [native("_ass_16_16")] fun = (this: !Int16, other: Int16) + + [native("_zero_init_16")] fun ctor(this: !UInt16) + [native("_ass_16_8z")] fun ctor(this: !UInt16, src: Int8) + [native("_ass_16_8z")] fun ctor(this: !UInt16, src: UInt8) + [native("_ass_16_16")] fun ctor(this: !UInt16, src: Int16) + [native("_ass_16_16")] fun ctor(this: !UInt16, src: UInt16) + [native("_ass_16_32")] fun ctor(this: !UInt16, src: Int32) + [native("_ass_16_32")] fun ctor(this: !UInt16, src: UInt32) + [native("_ass_16_64")] fun ctor(this: !UInt16, src: Int64) + [native("_ass_16_64")] fun ctor(this: !UInt16, src: UInt64) + [native("_ass_u16_f")] fun ctor(this: !UInt16, src: Float32) + [native("_ass_u16_d")] fun ctor(this: !UInt16, src: Float64) + fun dtor(this: UInt16) {} + [native("_ass_16_16")] fun = (this: !UInt16, other: UInt16) + + [native("_zero_init_32")] fun ctor(this: !Int32) + [native("_ass_32_8s")] fun ctor(this: !Int32, src: Int8) + [native("_ass_32_8z")] fun ctor(this: !Int32, src: UInt8) + [native("_ass_32_16s")] fun ctor(this: !Int32, src: Int16) + [native("_ass_32_16z")] fun ctor(this: !Int32, src: UInt16) + [native("_ass_32_32")] fun ctor(this: !Int32, src: Int32) + [native("_ass_32_32")] fun ctor(this: !Int32, src: UInt32) + [native("_ass_32_64")] fun ctor(this: !Int32, src: Int64) + [native("_ass_32_64")] fun ctor(this: !Int32, src: UInt64) + [native("_ass_i32_f")] fun ctor(this: !Int32, src: Float32) + [native("_ass_i32_d")] fun ctor(this: !Int32, src: Float64) + [native("_ass_32_8z")] fun ctor(this: !Int32, src: Char) + fun dtor(this: Int32) {} + [native("_ass_32_32")] fun = (this: !Int32, other: Int32) + + [native("_zero_init_32")] fun ctor(this: !UInt32) + [native("_ass_32_8z")] fun ctor(this: !UInt32, src: Int8) + [native("_ass_32_8z")] fun ctor(this: !UInt32, src: UInt8) + [native("_ass_32_16z")] fun ctor(this: !UInt32, src: Int16) + [native("_ass_32_16z")] fun ctor(this: !UInt32, src: UInt16) + [native("_ass_32_32")] fun ctor(this: !UInt32, src: Int32) + [native("_ass_32_32")] fun ctor(this: !UInt32, src: UInt32) + [native("_ass_32_64")] fun ctor(this: !UInt32, src: Int64) + [native("_ass_32_64")] fun ctor(this: !UInt32, src: UInt64) + [native("_ass_u32_f")] fun ctor(this: !UInt32, src: Float32) + [native("_ass_u32_d")] fun ctor(this: !UInt32, src: Float64) + fun dtor(this: UInt32) {} + [native("_ass_32_32")] fun = (this: !UInt32, other: UInt32) + + [native("_zero_init_64")] fun ctor(this: !Int64) + [native("_ass_64_8s")] fun ctor(this: !Int64, src: Int8) + [native("_ass_64_8z")] fun ctor(this: !Int64, src: UInt8) + [native("_ass_64_16s")] fun ctor(this: !Int64, src: Int16) + [native("_ass_64_16z")] fun ctor(this: !Int64, src: UInt16) + [native("_ass_64_32s")] fun ctor(this: !Int64, src: Int32) + [native("_ass_64_32z")] fun ctor(this: !Int64, src: UInt32) + [native("_ass_64_64")] fun ctor(this: !Int64, src: Int64) + [native("_ass_64_64")] fun ctor(this: !Int64, src: UInt64) + [native("_ass_i64_f")] fun ctor(this: !Int64, src: Float32) + [native("_ass_i64_d")] fun ctor(this: !Int64, src: Float64) + fun dtor(this: Int64) {} + [native("_ass_64_64")] fun = (this: !Int64, other: Int64) + + [native("_zero_init_64")] fun ctor(this: !UInt64) + [native("_ass_64_8z")] fun ctor(this: !UInt64, src: Int8) + [native("_ass_64_8z")] fun ctor(this: !UInt64, src: UInt8) + [native("_ass_64_16z")] fun ctor(this: !UInt64, src: Int16) + [native("_ass_64_16z")] fun ctor(this: !UInt64, src: UInt16) + [native("_ass_64_32z")] fun ctor(this: !UInt64, src: Int32) + [native("_ass_64_32z")] fun ctor(this: !UInt64, src: UInt32) + [native("_ass_64_64")] fun ctor(this: !UInt64, src: Int64) + [native("_ass_64_64")] fun ctor(this: !UInt64, src: UInt64) + [native("_ass_u64_f")] fun ctor(this: !UInt64, src: Float32) + [native("_ass_u64_d")] fun ctor(this: !UInt64, src: Float64) + fun dtor(this: UInt64) {} + [native("_ass_64_64")] fun = (this: !UInt64, other: UInt64) + + [native("_zero_init_f")] fun ctor(this: !Float32) + [native("_ass_f_i8")] fun ctor(this: !Float32, src: Int8) + [native("_ass_f_u8")] fun ctor(this: !Float32, src: UInt8) + [native("_ass_f_i16")] fun ctor(this: !Float32, src: Int16) + [native("_ass_f_u16")] fun ctor(this: !Float32, src: UInt16) + [native("_ass_f_i32")] fun ctor(this: !Float32, src: Int32) + [native("_ass_f_u32")] fun ctor(this: !Float32, src: UInt32) + [native("_ass_f_i64")] fun ctor(this: !Float32, src: Int64) + [native("_ass_f_u64")] fun ctor(this: !Float32, src: UInt64) + [native("_ass_f_f")] fun ctor(this: !Float32, src: Float32) + [native("_ass_f_d")] fun ctor(this: !Float32, src: Float64) + fun dtor(this: Float32) {} + [native("_ass_f_f")] fun = (this: !Float32, other: Float32) + + [native("_zero_init_d")] fun ctor(this: !Float64) + [native("_ass_d_i8")] fun ctor(this: !Float64, src: Int8) + [native("_ass_d_u8")] fun ctor(this: !Float64, src: UInt8) + [native("_ass_d_i16")] fun ctor(this: !Float64, src: Int16) + [native("_ass_d_u16")] fun ctor(this: !Float64, src: UInt16) + [native("_ass_d_i32")] fun ctor(this: !Float64, src: Int32) + [native("_ass_d_u32")] fun ctor(this: !Float64, src: UInt32) + [native("_ass_d_i64")] fun ctor(this: !Float64, src: Int64) + [native("_ass_d_u64")] fun ctor(this: !Float64, src: UInt64) + [native("_ass_d_f")] fun ctor(this: !Float64, src: Float32) + [native("_ass_d_d")] fun ctor(this: !Float64, src: Float64) + fun dtor(this: Float64) {} + [native("_ass_d_d")] fun = (this: !Float64, other: Float64) [native("_zero_init_8")] fun ctor(this: !Char) [native("_ass_8_8")] fun ctor(this: !Char, src: Char) - [native("_ass_8_8")] fun ctor(this: !Char, src: Byte) - [native("_ass_8_8")] fun ctor(this: !Char, src: UByte) - [native("_ass_8_16")] fun ctor(this: !Char, src: Short) - [native("_ass_8_16")] fun ctor(this: !Char, src: UShort) - [native("_ass_8_32")] fun ctor(this: !Char, src: Int) - [native("_ass_8_32")] fun ctor(this: !Char, src: UInt) - [native("_ass_8_64")] fun ctor(this: !Char, src: Long) - [native("_ass_8_64")] fun ctor(this: !Char, src: ULong) - [native("_ass_8_64")] fun ctor(this: !Char, src: SizeType) - [native("_ass_8_64")] fun ctor(this: !Char, src: DiffType) + [native("_ass_8_8")] fun ctor(this: !Char, src: Int8) + [native("_ass_8_32")] fun ctor(this: !Char, src: Int32) fun dtor(this: Char) {} [native("_ass_8_8")] fun = (this: !Char, other: Char) concept SmallInteger(x) \ - if typeOf(x) == Byte \ - || typeOf(x) == UByte \ - || typeOf(x) == Short \ - || typeOf(x) == UShort \ + if typeOf(x) == Int8 \ + || typeOf(x) == UInt8 \ + || typeOf(x) == Int16 \ + || typeOf(x) == UInt16 \ concept BigInteger(x) \ - if typeOf(x) == Int \ - || typeOf(x) == UInt \ - || typeOf(x) == Long \ - || typeOf(x) == ULong \ - || typeOf(x) == SizeType \ - || typeOf(x) == DiffType \ + if typeOf(x) == Int32 \ + || typeOf(x) == UInt32 \ + || typeOf(x) == Int64 \ + || typeOf(x) == UInt64 \ concept SignedInteger(x) \ - if typeOf(x) == Byte \ - || typeOf(x) == Short \ - || typeOf(x) == Int \ - || typeOf(x) == Long \ - || typeOf(x) == DiffType \ + if typeOf(x) == Int8 \ + || typeOf(x) == Int16 \ + || typeOf(x) == Int32 \ + || typeOf(x) == Int64 \ concept UnsignedInteger(x) \ - if typeOf(x) == UByte \ - || typeOf(x) == UShort \ - || typeOf(x) == UInt \ - || typeOf(x) == ULong \ - || typeOf(x) == SizeType \ + if typeOf(x) == UInt8 \ + || typeOf(x) == UInt16 \ + || typeOf(x) == UInt32 \ + || typeOf(x) == UInt64 \ concept Integer(x) \ @@ -296,8 +236,8 @@ concept Integer(x) \ concept FloatingPointNumber(x) \ - if typeOf(x) == Float \ - || typeOf(x) == Double \ + if typeOf(x) == Float32 \ + || typeOf(x) == Float64 \ concept Number(x) \ @@ -305,33 +245,33 @@ concept Number(x) \ || FloatingPointNumber(x) \ -datatype NumericLimits(t: Type) if t == Byte - using maxValue = Byte(0x7f) - using minValue = Byte(0x80) -datatype NumericLimits(t: Type) if t == UByte - using maxValue = UByte(0xff) - using minValue = UByte(0x00) - -datatype NumericLimits(t: Type) if t == Short - using maxValue = Short(0x7fff) - using minValue = Short(0x8000) -datatype NumericLimits(t: Type) if t == UShort - using maxValue = UShort(0xfff) - using minValue = UShort(0x000) - -datatype NumericLimits(t: Type) if t == Int - using maxValue = Int(0x7fffffff) - using minValue = Int(0x80000000) -datatype NumericLimits(t: Type) if t == UInt - using maxValue = UInt(0xffffffff) - using minValue = UInt(0x00000000) - -datatype NumericLimits(t: Type) if t == Long - using maxValue = Long(0x7fffffffffffffffL) - using minValue = Long(0x8000000000000000L) -datatype NumericLimits(t: Type) if t == ULong - using maxValue = ULong(0xffffffffffffffffL) - using minValue = ULong(0x0000000000000000L) +datatype NumericLimits(t: Type) if t == Int8 + using maxValue = Int8(0x7f) + using minValue = Int8(0x80) +datatype NumericLimits(t: Type) if t == UInt8 + using maxValue = UInt8(0xff) + using minValue = UInt8(0x00) + +datatype NumericLimits(t: Type) if t == Int16 + using maxValue = Int16(0x7fff) + using minValue = Int16(0x8000) +datatype NumericLimits(t: Type) if t == UInt16 + using maxValue = UInt16(0xfff) + using minValue = UInt16(0x000) + +datatype NumericLimits(t: Type) if t == Int32 + using maxValue = Int32(0x7fffffff) + using minValue = Int32(0x80000000) +datatype NumericLimits(t: Type) if t == UInt32 + using maxValue = UInt32(0xffffffff) + using minValue = UInt32(0x00000000) + +datatype NumericLimits(t: Type) if t == Int64 + using maxValue = Int64(0x7fffffffffffffffL) + using minValue = Int64(0x8000000000000000L) +datatype NumericLimits(t: Type) if t == UInt64 + using maxValue = UInt64(0xffffffffffffffffL) + using minValue = UInt64(0x0000000000000000L) //////////////////////////////////////////////////////////////////////////////// /// operator precedence @@ -402,215 +342,182 @@ using oper_assoc_:= = -1 /// [autoCt, protected] - [native("_Byte_opEQ")] fun == (x, y: Byte): Bool - [native("_UByte_opEQ")] fun == (x, y: UByte): Bool - [native("_Short_opEQ")] fun == (x, y: Short): Bool - [native("_UShort_opEQ")] fun == (x, y: UShort): Bool - [native("_Int_opEQ")] fun == (x, y: Int): Bool - [native("_UInt_opEQ")] fun == (x, y: UInt): Bool - [native("_Long_opEQ")] fun == (x, y: Long): Bool - [native("_ULong_opEQ")] fun == (x, y: ULong): Bool - [native("_SizeType_opEQ")] fun == (x, y: SizeType): Bool - [native("_DiffType_opEQ")] fun == (x, y: DiffType): Bool - [native("_Float_opEQ")] fun == (x, y: Float): Bool - [native("_Double_opEQ")] fun == (x, y: Double): Bool - - [native("_Byte_opNE")] fun != (x, y: Byte): Bool - [native("_UByte_opNE")] fun != (x, y: UByte): Bool - [native("_Short_opNE")] fun != (x, y: Short): Bool - [native("_UShort_opNE")] fun != (x, y: UShort): Bool - [native("_Int_opNE")] fun != (x, y: Int): Bool - [native("_UInt_opNE")] fun != (x, y: UInt): Bool - [native("_Long_opNE")] fun != (x, y: Long): Bool - [native("_ULong_opNE")] fun != (x, y: ULong): Bool - [native("_SizeType_opNE")] fun != (x, y: SizeType): Bool - [native("_DiffType_opNE")] fun != (x, y: DiffType): Bool - [native("_Float_opNE")] fun != (x, y: Float): Bool - [native("_Double_opNE")] fun != (x, y: Double): Bool - - [native("_Byte_opLT")] fun < (x, y: Byte): Bool - [native("_UByte_opLT")] fun < (x, y: UByte): Bool - [native("_Short_opLT")] fun < (x, y: Short): Bool - [native("_UShort_opLT")] fun < (x, y: UShort): Bool - [native("_Int_opLT")] fun < (x, y: Int): Bool - [native("_UInt_opLT")] fun < (x, y: UInt): Bool - [native("_Long_opLT")] fun < (x, y: Long): Bool - [native("_ULong_opLT")] fun < (x, y: ULong): Bool - [native("_SizeType_opLT")] fun < (x, y: SizeType): Bool - [native("_DiffType_opLT")] fun < (x, y: DiffType): Bool - [native("_Float_opLT")] fun < (x, y: Float): Bool - [native("_Double_opLT")] fun < (x, y: Double): Bool - - [native("_Byte_opGT")] fun > (x, y: Byte): Bool - [native("_UByte_opGT")] fun > (x, y: UByte): Bool - [native("_Short_opGT")] fun > (x, y: Short): Bool - [native("_UShort_opGT")] fun > (x, y: UShort): Bool - [native("_Int_opGT")] fun > (x, y: Int): Bool - [native("_UInt_opGT")] fun > (x, y: UInt): Bool - [native("_Long_opGT")] fun > (x, y: Long): Bool - [native("_ULong_opGT")] fun > (x, y: ULong): Bool - [native("_SizeType_opGT")] fun > (x, y: SizeType): Bool - [native("_DiffType_opGT")] fun > (x, y: DiffType): Bool - [native("_Float_opGT")] fun > (x, y: Float): Bool - [native("_Double_opGT")] fun > (x, y: Double): Bool - - [native("_Byte_opLE")] fun <= (x, y: Byte): Bool - [native("_UByte_opLE")] fun <= (x, y: UByte): Bool - [native("_Short_opLE")] fun <= (x, y: Short): Bool - [native("_UShort_opLE")] fun <= (x, y: UShort): Bool - [native("_Int_opLE")] fun <= (x, y: Int): Bool - [native("_UInt_opLE")] fun <= (x, y: UInt): Bool - [native("_Long_opLE")] fun <= (x, y: Long): Bool - [native("_ULong_opLE")] fun <= (x, y: ULong): Bool - [native("_SizeType_opLE")] fun <= (x, y: SizeType): Bool - [native("_DiffType_opLE")] fun <= (x, y: DiffType): Bool - [native("_Float_opLE")] fun <= (x, y: Float): Bool - [native("_Double_opLE")] fun <= (x, y: Double): Bool - - [native("_Byte_opGE")] fun >= (x, y: Byte): Bool - [native("_UByte_opGE")] fun >= (x, y: UByte): Bool - [native("_Short_opGE")] fun >= (x, y: Short): Bool - [native("_UShort_opGE")] fun >= (x, y: UShort): Bool - [native("_Int_opGE")] fun >= (x, y: Int): Bool - [native("_UInt_opGE")] fun >= (x, y: UInt): Bool - [native("_Long_opGE")] fun >= (x, y: Long): Bool - [native("_ULong_opGE")] fun >= (x, y: ULong): Bool - [native("_SizeType_opGE")] fun >= (x, y: SizeType): Bool - [native("_DiffType_opGE")] fun >= (x, y: DiffType): Bool - [native("_Float_opGE")] fun >= (x, y: Float): Bool - [native("_Double_opGE")] fun >= (x, y: Double): Bool - - [native("_Byte_opPlus")] fun + (x, y: Byte): Byte - [native("_UByte_opPlus")] fun + (x, y: UByte): UByte - [native("_Short_opPlus")] fun + (x, y: Short): Short - [native("_UShort_opPlus")] fun + (x, y: UShort): UShort - [native("_Int_opPlus")] fun + (x, y: Int): Int - [native("_UInt_opPlus")] fun + (x, y: UInt): UInt - [native("_Long_opPlus")] fun + (x, y: Long): Long - [native("_ULong_opPlus")] fun + (x, y: ULong): ULong - [native("_SizeType_opPlus")] fun + (x, y: SizeType): SizeType - [native("_DiffType_opPlus")] fun + (x, y: DiffType): DiffType - [native("_Float_opPlus")] fun + (x, y: Float): Float - [native("_Double_opPlus")] fun + (x, y: Double): Double - - [native("_Byte_opMinus")] fun - (x, y: Byte): Byte - [native("_UByte_opMinus")] fun - (x, y: UByte): UByte - [native("_Short_opMinus")] fun - (x, y: Short): Short - [native("_UShort_opMinus")] fun - (x, y: UShort): UShort - [native("_Int_opMinus")] fun - (x, y: Int): Int - [native("_UInt_opMinus")] fun - (x, y: UInt): UInt - [native("_Long_opMinus")] fun - (x, y: Long): Long - [native("_ULong_opMinus")] fun - (x, y: ULong): ULong - [native("_SizeType_opMinus")] fun - (x, y: SizeType): SizeType - [native("_DiffType_opMinus")] fun - (x, y: DiffType): DiffType - [native("_Float_opMinus")] fun - (x, y: Float): Float - [native("_Double_opMinus")] fun - (x, y: Double): Double - - [native("_Byte_opMul")] fun * (x, y: Byte): Byte - [native("_UByte_opMul")] fun * (x, y: UByte): UByte - [native("_Short_opMul")] fun * (x, y: Short): Short - [native("_UShort_opMul")] fun * (x, y: UShort): UShort - [native("_Int_opMul")] fun * (x, y: Int): Int - [native("_UInt_opMul")] fun * (x, y: UInt): UInt - [native("_Long_opMul")] fun * (x, y: Long): Long - [native("_ULong_opMul")] fun * (x, y: ULong): ULong - [native("_SizeType_opMul")] fun * (x, y: SizeType): SizeType - [native("_DiffType_opMul")] fun * (x, y: DiffType): DiffType - [native("_Float_opMul")] fun * (x, y: Float): Float - [native("_Double_opMul")] fun * (x, y: Double): Double - - [native("_Byte_opDiv")] fun / (x, y: Byte): Byte - [native("_UByte_opDiv")] fun / (x, y: UByte): UByte - [native("_Short_opDiv")] fun / (x, y: Short): Short - [native("_UShort_opDiv")] fun / (x, y: UShort): UShort - [native("_Int_opDiv")] fun / (x, y: Int): Int - [native("_UInt_opDiv")] fun / (x, y: UInt): UInt - [native("_Long_opDiv")] fun / (x, y: Long): Long - [native("_ULong_opDiv")] fun / (x, y: ULong): ULong - [native("_SizeType_opDiv")] fun / (x, y: SizeType): SizeType - [native("_DiffType_opDiv")] fun / (x, y: DiffType): DiffType - [native("_Float_opDiv")] fun / (x, y: Float): Float - [native("_Double_opDiv")] fun / (x, y: Double): Double - - [native("_Byte_opMod")] fun % (x, y: Byte): Byte - [native("_UByte_opMod")] fun % (x, y: UByte): UByte - [native("_Short_opMod")] fun % (x, y: Short): Short - [native("_UShort_opMod")] fun % (x, y: UShort): UShort - [native("_Int_opMod")] fun % (x, y: Int): Int - [native("_UInt_opMod")] fun % (x, y: UInt): UInt - [native("_Long_opMod")] fun % (x, y: Long): Long - [native("_ULong_opMod")] fun % (x, y: ULong): ULong - [native("_SizeType_opMod")] fun % (x, y: SizeType): SizeType - [native("_DiffType_opMod")] fun % (x, y: DiffType): DiffType - [native("_Float_opMod")] fun % (x, y: Float): Float - [native("_Double_opMod")] fun % (x, y: Double): Double + [native("_Int8_opEQ")] fun == (x, y: Int8): Bool + [native("_UInt8_opEQ")] fun == (x, y: UInt8): Bool + [native("_Int16_opEQ")] fun == (x, y: Int16): Bool + [native("_UInt16_opEQ")] fun == (x, y: UInt16): Bool + [native("_Int32_opEQ")] fun == (x, y: Int32): Bool + [native("_UInt32_opEQ")] fun == (x, y: UInt32): Bool + [native("_Int64_opEQ")] fun == (x, y: Int64): Bool + [native("_UInt64_opEQ")] fun == (x, y: UInt64): Bool + [native("_Float32_opEQ")] fun == (x, y: Float32): Bool + [native("_Float64_opEQ")] fun == (x, y: Float64): Bool + + [native("_Int8_opNE")] fun != (x, y: Int8): Bool + [native("_UInt8_opNE")] fun != (x, y: UInt8): Bool + [native("_Int16_opNE")] fun != (x, y: Int16): Bool + [native("_UInt16_opNE")] fun != (x, y: UInt16): Bool + [native("_Int32_opNE")] fun != (x, y: Int32): Bool + [native("_UInt32_opNE")] fun != (x, y: UInt32): Bool + [native("_Int64_opNE")] fun != (x, y: Int64): Bool + [native("_UInt64_opNE")] fun != (x, y: UInt64): Bool + [native("_Float32_opNE")] fun != (x, y: Float32): Bool + [native("_Float64_opNE")] fun != (x, y: Float64): Bool + + [native("_Int8_opLT")] fun < (x, y: Int8): Bool + [native("_UInt8_opLT")] fun < (x, y: UInt8): Bool + [native("_Int16_opLT")] fun < (x, y: Int16): Bool + [native("_UInt16_opLT")] fun < (x, y: UInt16): Bool + [native("_Int32_opLT")] fun < (x, y: Int32): Bool + [native("_UInt32_opLT")] fun < (x, y: UInt32): Bool + [native("_Int64_opLT")] fun < (x, y: Int64): Bool + [native("_UInt64_opLT")] fun < (x, y: UInt64): Bool + [native("_Float32_opLT")] fun < (x, y: Float32): Bool + [native("_Float64_opLT")] fun < (x, y: Float64): Bool + + [native("_Int8_opGT")] fun > (x, y: Int8): Bool + [native("_UInt8_opGT")] fun > (x, y: UInt8): Bool + [native("_Int16_opGT")] fun > (x, y: Int16): Bool + [native("_UInt16_opGT")] fun > (x, y: UInt16): Bool + [native("_Int32_opGT")] fun > (x, y: Int32): Bool + [native("_UInt32_opGT")] fun > (x, y: UInt32): Bool + [native("_Int64_opGT")] fun > (x, y: Int64): Bool + [native("_UInt64_opGT")] fun > (x, y: UInt64): Bool + [native("_Float32_opGT")] fun > (x, y: Float32): Bool + [native("_Float64_opGT")] fun > (x, y: Float64): Bool + + [native("_Int8_opLE")] fun <= (x, y: Int8): Bool + [native("_UInt8_opLE")] fun <= (x, y: UInt8): Bool + [native("_Int16_opLE")] fun <= (x, y: Int16): Bool + [native("_UInt16_opLE")] fun <= (x, y: UInt16): Bool + [native("_Int32_opLE")] fun <= (x, y: Int32): Bool + [native("_UInt32_opLE")] fun <= (x, y: UInt32): Bool + [native("_Int64_opLE")] fun <= (x, y: Int64): Bool + [native("_UInt64_opLE")] fun <= (x, y: UInt64): Bool + [native("_Float32_opLE")] fun <= (x, y: Float32): Bool + [native("_Float64_opLE")] fun <= (x, y: Float64): Bool + + [native("_Int8_opGE")] fun >= (x, y: Int8): Bool + [native("_UInt8_opGE")] fun >= (x, y: UInt8): Bool + [native("_Int16_opGE")] fun >= (x, y: Int16): Bool + [native("_UInt16_opGE")] fun >= (x, y: UInt16): Bool + [native("_Int32_opGE")] fun >= (x, y: Int32): Bool + [native("_UInt32_opGE")] fun >= (x, y: UInt32): Bool + [native("_Int64_opGE")] fun >= (x, y: Int64): Bool + [native("_UInt64_opGE")] fun >= (x, y: UInt64): Bool + [native("_Float32_opGE")] fun >= (x, y: Float32): Bool + [native("_Float64_opGE")] fun >= (x, y: Float64): Bool + + [native("_Int8_opPlus")] fun + (x, y: Int8): Int8 + [native("_UInt8_opPlus")] fun + (x, y: UInt8): UInt8 + [native("_Int16_opPlus")] fun + (x, y: Int16): Int16 + [native("_UInt16_opPlus")] fun + (x, y: UInt16): UInt16 + [native("_Int32_opPlus")] fun + (x, y: Int32): Int32 + [native("_UInt32_opPlus")] fun + (x, y: UInt32): UInt32 + [native("_Int64_opPlus")] fun + (x, y: Int64): Int64 + [native("_UInt64_opPlus")] fun + (x, y: UInt64): UInt64 + [native("_Float32_opPlus")] fun + (x, y: Float32): Float32 + [native("_Float64_opPlus")] fun + (x, y: Float64): Float64 + + [native("_Int8_opMinus")] fun - (x, y: Int8): Int8 + [native("_UInt8_opMinus")] fun - (x, y: UInt8): UInt8 + [native("_Int16_opMinus")] fun - (x, y: Int16): Int16 + [native("_UInt16_opMinus")] fun - (x, y: UInt16): UInt16 + [native("_Int32_opMinus")] fun - (x, y: Int32): Int32 + [native("_UInt32_opMinus")] fun - (x, y: UInt32): UInt32 + [native("_Int64_opMinus")] fun - (x, y: Int64): Int64 + [native("_UInt64_opMinus")] fun - (x, y: UInt64): UInt64 + [native("_Float32_opMinus")] fun - (x, y: Float32): Float32 + [native("_Float64_opMinus")] fun - (x, y: Float64): Float64 + + [native("_Int8_opMul")] fun * (x, y: Int8): Int8 + [native("_UInt8_opMul")] fun * (x, y: UInt8): UInt8 + [native("_Int16_opMul")] fun * (x, y: Int16): Int16 + [native("_UInt16_opMul")] fun * (x, y: UInt16): UInt16 + [native("_Int32_opMul")] fun * (x, y: Int32): Int32 + [native("_UInt32_opMul")] fun * (x, y: UInt32): UInt32 + [native("_Int64_opMul")] fun * (x, y: Int64): Int64 + [native("_UInt64_opMul")] fun * (x, y: UInt64): UInt64 + [native("_Float32_opMul")] fun * (x, y: Float32): Float32 + [native("_Float64_opMul")] fun * (x, y: Float64): Float64 + + [native("_Int8_opDiv")] fun / (x, y: Int8): Int8 + [native("_UInt8_opDiv")] fun / (x, y: UInt8): UInt8 + [native("_Int16_opDiv")] fun / (x, y: Int16): Int16 + [native("_UInt16_opDiv")] fun / (x, y: UInt16): UInt16 + [native("_Int32_opDiv")] fun / (x, y: Int32): Int32 + [native("_UInt32_opDiv")] fun / (x, y: UInt32): UInt32 + [native("_Int64_opDiv")] fun / (x, y: Int64): Int64 + [native("_UInt64_opDiv")] fun / (x, y: UInt64): UInt64 + [native("_Float32_opDiv")] fun / (x, y: Float32): Float32 + [native("_Float64_opDiv")] fun / (x, y: Float64): Float64 + + [native("_Int8_opMod")] fun % (x, y: Int8): Int8 + [native("_UInt8_opMod")] fun % (x, y: UInt8): UInt8 + [native("_Int16_opMod")] fun % (x, y: Int16): Int16 + [native("_UInt16_opMod")] fun % (x, y: UInt16): UInt16 + [native("_Int32_opMod")] fun % (x, y: Int32): Int32 + [native("_UInt32_opMod")] fun % (x, y: UInt32): UInt32 + [native("_Int64_opMod")] fun % (x, y: Int64): Int64 + [native("_UInt64_opMod")] fun % (x, y: UInt64): UInt64 + [native("_Float32_opMod")] fun % (x, y: Float32): Float32 + [native("_Float64_opMod")] fun % (x, y: Float64): Float64 // Unary + - [native("_Byte_opPlus1")] fun + (x: Byte): Byte - [native("_UByte_opPlus1")] fun + (x: UByte): UByte - [native("_Short_opPlus1")] fun + (x: Short): Short - [native("_UShort_opPlus1")] fun + (x: UShort): UShort - [native("_Int_opPlus1")] fun + (x: Int): Int - [native("_UInt_opPlus1")] fun + (x: UInt): UInt - [native("_Long_opPlus1")] fun + (x: Long): Long - [native("_ULong_opPlus1")] fun + (x: ULong): ULong - [native("_SizeType_opPlus1")] fun + (x: SizeType): SizeType - [native("_DiffType_opPlus1")] fun + (x: DiffType): DiffType - [native("_Float_opPlus1")] fun + (x: Float): Float - [native("_Double_opPlus1")] fun + (x: Double): Double + [native("_Int8_opPlus1")] fun + (x: Int8): Int8 + [native("_UInt8_opPlus1")] fun + (x: UInt8): UInt8 + [native("_Int16_opPlus1")] fun + (x: Int16): Int16 + [native("_UInt16_opPlus1")] fun + (x: UInt16): UInt16 + [native("_Int32_opPlus1")] fun + (x: Int32): Int32 + [native("_UInt32_opPlus1")] fun + (x: UInt32): UInt32 + [native("_Int64_opPlus1")] fun + (x: Int64): Int64 + [native("_UInt64_opPlus1")] fun + (x: UInt64): UInt64 + [native("_Float32_opPlus1")] fun + (x: Float32): Float32 + [native("_Float64_opPlus1")] fun + (x: Float64): Float64 // Unary - (only for signed types) - [native("_Byte_opMinus1")] fun - (x: Byte): Byte - [native("_Short_opMinus1")] fun - (x: Short): Short - [native("_Int_opMinus1")] fun - (x: Int): Int - [native("_Long_opMinus1")] fun - (x: Long): Long - [native("_DiffType_opMinus1")] fun - (x: DiffType): DiffType - [native("_Float_opMinus1")] fun - (x: Float): Float - [native("_Double_opMinus1")] fun - (x: Double): Double - - fun pre_++(n: !Byte): Byte { n+=Byte(1); return n; } - fun pre_++(n: !UByte): UByte { n+=UByte(1); return n; } - fun pre_++(n: !Short): Short { n+=Short(1); return n; } - fun pre_++(n: !UShort): UShort { n+=UShort(1); return n; } - fun pre_++(n: !Int): Int { n+=1; return n; } - fun pre_++(n: !UInt): UInt { n+=UInt(1); return n; } - fun pre_++(n: !Long): Long { n+=Long(1); return n; } - fun pre_++(n: !ULong): ULong { n+=ULong(1); return n; } - fun pre_++(n: !SizeType): SizeType { n+=SizeType(1); return n; } - fun pre_++(n: !DiffType): DiffType { n+=DiffType(1); return n; } - - fun pre_--(n: !Byte): Byte { n-=Byte(1); return n; } - fun pre_--(n: !UByte): UByte { n-=UByte(1); return n; } - fun pre_--(n: !Short): Short { n-=Short(1); return n; } - fun pre_--(n: !UShort): UShort { n-=UShort(1); return n; } - fun pre_--(n: !Int): Int { n-=1; return n; } - fun pre_--(n: !UInt): UInt { n-=UInt(1); return n; } - fun pre_--(n: !Long): Long { n-=Long(1); return n; } - fun pre_--(n: !ULong): ULong { n-=ULong(1); return n; } - fun pre_--(n: !SizeType): SizeType { n-=SizeType(1); return n; } - fun pre_--(n: !DiffType): DiffType { n-=DiffType(1); return n; } - - fun post_++(n: !Byte): Byte { let old = n; n+=Byte(1); return old; } - fun post_++(n: !UByte): UByte { let old = n; n+=UByte(1); return old; } - fun post_++(n: !Short): Short { let old = n; n+=Short(1); return old; } - fun post_++(n: !UShort): UShort { let old = n; n+=UShort(1); return old; } - fun post_++(n: !Int): Int { let old = n; n+=1; return old; } - fun post_++(n: !UInt): UInt { let old = n; n+=UInt(1); return old; } - fun post_++(n: !Long): Long { let old = n; n+=Long(1); return old; } - fun post_++(n: !ULong): ULong { let old = n; n+=ULong(1); return old; } - fun post_++(n: !SizeType): SizeType { let old = n; n+=SizeType(1); return old; } - fun post_++(n: !DiffType): DiffType { let old = n; n+=DiffType(1); return old; } - - fun post_--(n: !Byte): Byte { let old = n; n-=Byte(1); return old; } - fun post_--(n: !UByte): UByte { let old = n; n-=UByte(1); return old; } - fun post_--(n: !Short): Short { let old = n; n-=Short(1); return old; } - fun post_--(n: !UShort): UShort { let old = n; n-=UShort(1); return old; } - fun post_--(n: !Int): Int { let old = n; n-=1; return old; } - fun post_--(n: !UInt): UInt { let old = n; n-=UInt(1); return old; } - fun post_--(n: !Long): Long { let old = n; n-=Long(1); return old; } - fun post_--(n: !ULong): ULong { let old = n; n-=ULong(1); return old; } - fun post_--(n: !SizeType): SizeType { let old = n; n-=SizeType(1); return old; } - fun post_--(n: !DiffType): DiffType { let old = n; n-=DiffType(1); return old; } + [native("_Int8_opMinus1")] fun - (x: Int8): Int8 + [native("_Int16_opMinus1")] fun - (x: Int16): Int16 + [native("_Int32_opMinus1")] fun - (x: Int32): Int32 + [native("_Int64_opMinus1")] fun - (x: Int64): Int64 + [native("_Float32_opMinus1")] fun - (x: Float32): Float32 + [native("_Float64_opMinus1")] fun - (x: Float64): Float64 + + fun pre_++(n: !Int8): Int8 { n+=Int8(1); return n; } + fun pre_++(n: !UInt8): UInt8 { n+=UInt8(1); return n; } + fun pre_++(n: !Int16): Int16 { n+=Int16(1); return n; } + fun pre_++(n: !UInt16): UInt16 { n+=UInt16(1); return n; } + fun pre_++(n: !Int32): Int32 { n+=1; return n; } + fun pre_++(n: !UInt32): UInt32 { n+=UInt32(1); return n; } + fun pre_++(n: !Int64): Int64 { n+=Int64(1); return n; } + fun pre_++(n: !UInt64): UInt64 { n+=UInt64(1); return n; } + + fun pre_--(n: !Int8): Int8 { n-=Int8(1); return n; } + fun pre_--(n: !UInt8): UInt8 { n-=UInt8(1); return n; } + fun pre_--(n: !Int16): Int16 { n-=Int16(1); return n; } + fun pre_--(n: !UInt16): UInt16 { n-=UInt16(1); return n; } + fun pre_--(n: !Int32): Int32 { n-=1; return n; } + fun pre_--(n: !UInt32): UInt32 { n-=UInt32(1); return n; } + fun pre_--(n: !Int64): Int64 { n-=Int64(1); return n; } + fun pre_--(n: !UInt64): UInt64 { n-=UInt64(1); return n; } + + fun post_++(n: !Int8): Int8 { let old = n; n+=Int8(1); return old; } + fun post_++(n: !UInt8): UInt8 { let old = n; n+=UInt8(1); return old; } + fun post_++(n: !Int16): Int16 { let old = n; n+=Int16(1); return old; } + fun post_++(n: !UInt16): UInt16 { let old = n; n+=UInt16(1); return old; } + fun post_++(n: !Int32): Int32 { let old = n; n+=1; return old; } + fun post_++(n: !UInt32): UInt32 { let old = n; n+=UInt32(1); return old; } + fun post_++(n: !Int64): Int64 { let old = n; n+=Int64(1); return old; } + fun post_++(n: !UInt64): UInt64 { let old = n; n+=UInt64(1); return old; } + + fun post_--(n: !Int8): Int8 { let old = n; n-=Int8(1); return old; } + fun post_--(n: !UInt8): UInt8 { let old = n; n-=UInt8(1); return old; } + fun post_--(n: !Int16): Int16 { let old = n; n-=Int16(1); return old; } + fun post_--(n: !UInt16): UInt16 { let old = n; n-=UInt16(1); return old; } + fun post_--(n: !Int32): Int32 { let old = n; n-=1; return old; } + fun post_--(n: !UInt32): UInt32 { let old = n; n-=UInt32(1); return old; } + fun post_--(n: !Int64): Int64 { let old = n; n-=Int64(1); return old; } + fun post_--(n: !UInt64): UInt64 { let old = n; n-=UInt64(1); return old; } //////////////////////////////////////////////////////////////////////////////// /// StringRef @@ -628,10 +535,10 @@ datatype StringRef begin ctor UntypedPtr() end ctor UntypedPtr() - fun ctor(this: !StringRef, size: SizeType) + fun ctor(this: !StringRef, size: Int) begin = malloc(size + 1) end = (begin ptrAdd size) - (end asRefOf Byte) = Byte(0) + (end asRefOf Int8) = Int8(0) fun ctor(this: !StringRef, other: StringRef) begin = other.begin end = other.end @@ -641,20 +548,20 @@ datatype StringRef fun dtor(this: StringRef) {} fun isEmpty(this: StringRef) = (end ptrDiff begin) == 0 - fun size(this: StringRef): SizeType = (end ptrDiff begin) + fun size(this: StringRef): Int = (end ptrDiff begin) fun front(this: StringRef): @Char = begin asRefOf Char fun back(this: StringRef): @Char = end ptrSub 1 asRefOf Char fun ()(this: StringRef) : @Char = begin asRefOf Char - fun ()(this: StringRef, index: SizeType): @Char = begin ptrAdd index asRefOf Char - fun at(this: StringRef, index: SizeType): @Char = begin ptrAdd index asRefOf Char + fun ()(this: StringRef, index: Int): @Char = begin ptrAdd index asRefOf Char + fun at(this: StringRef, index: Int): @Char = begin ptrAdd index asRefOf Char fun popFront(this: !StringRef) { begin = (begin ptrAdd 1); } fun popBack(this: !StringRef) { end = (begin ptrSub 1); } - fun popFront(this: !StringRef, n: SizeType) { begin = (begin ptrAdd n); } - fun popBack(this: !StringRef, n: SizeType) { end = (begin ptrAdd n); } + fun popFront(this: !StringRef, n: Int) { begin = (begin ptrAdd n); } + fun popBack(this: !StringRef, n: Int) { end = (begin ptrAdd n); } - fun subrange(this: StringRef, index: SizeType, num: SizeType): StringRef + fun subrange(this: StringRef, index: Int, num: Int): StringRef return StringRef(begin ptrAdd index, begin ptrAdd (index+num)) fun cStr(this: StringRef): @Char = begin asRefOf Char @@ -669,7 +576,7 @@ fun == (this, other: StringRef): Bool let s = this.size if s != other.size return false - var i: SizeType = 0 + var i: Int = 0 while imut) +fun tmpToMut(x: AnyType tmp): !typeOf(x) = reinterpretCast(!typeOf(x), x) +fun tmpToMut(x: !AnyType): !typeOf(x) = x + /// Concept that is satisfied by any type concept AnyType(x) // Always true @@ -820,13 +733,13 @@ fun #$(t: Type): t /// Some low-level helper functions /// -[native("malloc")] fun malloc(size: SizeType): UntypedPtr -[native("calloc")] fun calloc(size, count: SizeType): UntypedPtr -[native("realloc"), autoCt] fun realloc(p: UntypedPtr, size: SizeType): UntypedPtr +[native("malloc")] fun malloc(size: Int): UntypedPtr +[native("calloc")] fun calloc(size, count: Int): UntypedPtr +[native("realloc"), autoCt] fun realloc(p: UntypedPtr, size: Int): UntypedPtr [native("free"), autoCt] fun free(p: UntypedPtr) -[native("_spr_memcpy"), autoCt] fun memcpy(dest, src: UntypedPtr, size: SizeType) -[native("_spr_memmove"), autoCt] fun memmove(dest, src: UntypedPtr, size: SizeType) -[native("_spr_memset"), autoCt] fun memset(dest: UntypedPtr, val: Byte, count: SizeType) +[native("_spr_memcpy"), autoCt] fun memcpy(dest, src: UntypedPtr, size: Int) +[native("_spr_memmove"), autoCt] fun memmove(dest, src: UntypedPtr, size: Int) +[native("_spr_memset"), autoCt] fun memset(dest: UntypedPtr, val: Int8, count: Int) [native("system")] fun systemNative(x: @Char) [native("sleep")] fun sleep(x: Int) diff --git a/SparrowImplicitLib/sprCore/basicImpl.llvm b/SparrowImplicitLib/sprCore/basicImpl.llvm index 83d26c8f..9367ae28 100644 --- a/SparrowImplicitLib/sprCore/basicImpl.llvm +++ b/SparrowImplicitLib/sprCore/basicImpl.llvm @@ -11,12 +11,12 @@ declare i32 @fflush(%struct._IO_FILE*) nounwind %StringRef = type opaque -@.fmtInt = private unnamed_addr constant [3 x i8] c"%d\00", align 1 -@.fmtUInt = private unnamed_addr constant [3 x i8] c"%u\00", align 1 -@.fmtLong = private unnamed_addr constant [5 x i8] c"%lld\00", align 1 -@.fmtULong = private unnamed_addr constant [5 x i8] c"%llu\00", align 1 +@.fmtInt32 = private unnamed_addr constant [3 x i8] c"%d\00", align 1 +@.fmtUInt32 = private unnamed_addr constant [3 x i8] c"%u\00", align 1 +@.fmtInt64 = private unnamed_addr constant [5 x i8] c"%lld\00", align 1 +@.fmtUInt64 = private unnamed_addr constant [5 x i8] c"%llu\00", align 1 @.fmtChar = private unnamed_addr constant [3 x i8] c"%c\00", align 1 -@.fmtDouble = private unnamed_addr constant [3 x i8] c"%g\00", align 1 +@.fmtFloat64 = private unnamed_addr constant [3 x i8] c"%g\00", align 1 @.fmtPointer = private unnamed_addr constant [3 x i8] c"%p\00", align 1 define i1 @isNullRef(i8* %x) alwaysinline @@ -48,25 +48,26 @@ define void @_Type_copy_ctor(i8** %$this, i8* %other) ret void } -define i8* @ptrAdd(i8* %p, i64 %n) alwaysinline +define i8* @ptrAdd(i8* %p, i32 %n) alwaysinline { - %1 = getelementptr i8, i8* %p, i64 %n + %1 = getelementptr i8, i8* %p, i32 %n ret i8* %1 } -define i8* @ptrSub(i8* %p, i64 %n) alwaysinline +define i8* @ptrSub(i8* %p, i32 %n) alwaysinline { - %1 = sub i64 0, %n - %2 = getelementptr i8, i8* %p, i64 %1 + %1 = sub i32 0, %n + %2 = getelementptr i8, i8* %p, i32 %1 ret i8* %2 } -define i64 @ptrDiff(i8* %p1, i8* %p2) alwaysinline +define i32 @ptrDiff(i8* %p1, i8* %p2) alwaysinline { %1 = ptrtoint i8* %p1 to i64 %2 = ptrtoint i8* %p2 to i64 %3 = sub i64 %1, %2 - ret i64 %3 + %4 = trunc i64 %3 to i32 + ret i32 %4 } define void @_spr_memcpy(i8* %dest, i8* %src, i64 %size) alwaysinline @@ -97,38 +98,58 @@ define void @flushOutput() alwaysinline -define void @writeByte(i8 %val) alwaysinline { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i8 %val) +define void @writeInt8(i8 %val) alwaysinline { + %1 = sext i8 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) ret void } -define void @writeShort(i16 %val) alwaysinline { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i16 %val) +define void @writeUInt8(i8 %val) alwaysinline { + %1 = zext i8 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) ret void } -define void @writeInt(i32 %val) alwaysinline { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i32 %val) +define void @writeInt16(i16 %val) alwaysinline { + %1 = sext i16 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) ret void } -define void @writeUInt(i32 %val) alwaysinline { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtUInt, i32 0, i32 0), i32 %val) +define void @writeUInt16(i16 %val) alwaysinline { + %1 = zext i16 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) ret void } -define void @writeLong(i64 %val) alwaysinline { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtLong, i32 0, i32 0), i64 %val) +define void @writeInt32(i32 %val) alwaysinline { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %val) ret void } -define void @writeULong(i64 %val) alwaysinline { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtULong, i32 0, i32 0), i64 %val) +define void @writeUInt32(i32 %val) alwaysinline { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtUInt32, i32 0, i32 0), i32 %val) ret void } -define void @writeDouble(double %val) alwaysinline { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtDouble, i32 0, i32 0), double %val) +define void @writeInt64(i64 %val) alwaysinline { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtInt64, i32 0, i32 0), i64 %val) + ret void +} + +define void @writeUInt64(i64 %val) alwaysinline { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtUInt64, i32 0, i32 0), i64 %val) + ret void +} + +define void @writeFloat32(float %val) alwaysinline { + %1 = fpext float %val to double + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtFloat64, i32 0, i32 0), double %1) + ret void +} + +define void @writeFloat64(double %val) alwaysinline { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtFloat64, i32 0, i32 0), double %val) ret void } @@ -145,13 +166,13 @@ define void @writePointer(i8* %val) alwaysinline { define void @_Int_to_CString(i32 %val, i8* %buffer) alwaysinline { - call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i32 %val) nounwind + call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %val) nounwind ret void } define void @_ULong_to_CString(i64 %val, i8* %buffer) alwaysinline { - call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtULong, i32 0, i32 0), i64 %val) nounwind + call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtUInt64, i32 0, i32 0), i64 %val) nounwind ret void } diff --git a/SparrowImplicitLib/sprCore/basicMeta.spr b/SparrowImplicitLib/sprCore/basicMeta.spr index 1927aca2..a9d379ce 100644 --- a/SparrowImplicitLib/sprCore/basicMeta.spr +++ b/SparrowImplicitLib/sprCore/basicMeta.spr @@ -1,9 +1,9 @@ -import basicDecls(UntypedPtr, Byte, StringRef, Null, pre_@) +import basicDecls(UntypedPtr, Int8, StringRef, Null, pre_@) [ct] /// The type used to represent a compiler AST node [bitcopiable] - datatype CompilerAstNode = @Byte + datatype CompilerAstNode = @Int8 /// Taking an AST node, this will evaluate the node and produce the corresponding code /// Opposite of astLift diff --git a/SparrowImplicitLib/sprCore/consoleIO.spr b/SparrowImplicitLib/sprCore/consoleIO.spr index a7e28e65..962d253e 100644 --- a/SparrowImplicitLib/sprCore/consoleIO.spr +++ b/SparrowImplicitLib/sprCore/consoleIO.spr @@ -1,4 +1,4 @@ -import basicDecls(Number, Char, Bool, StringRef, Byte, UByte, Short, UShort, Int, UInt, Long, ULong, SizeType, DiffType, Double, Range) +import basicDecls(Number, Char, Bool, StringRef, Int8, UInt8, Int16, UInt16, Int, Int32, UInt32, Int64, UInt64, Float32, Float64, Float, Range) import streamBasic(FlushHelperClass) var cout: ConsoleOutputStream @@ -16,18 +16,17 @@ fun <<<(this: ConsoleOutputStream, x: StringRef) { for c = x { _Impl.write(c) fun flush(this: ConsoleOutputStream, x: FlushHelperClass) { _Impl.flushOutput } package _Impl - [native("writeByte")] fun write(x: Byte) - [native("writeByte")] fun write(x: UByte) - [native("writeShort")] fun write(x: Short) - [native("writeShort")] fun write(x: UShort) - [native("writeInt")] fun write(x: Int) - [native("writeUInt")] fun write(x: UInt) - [native("writeLong")] fun write(x: Long) - [native("writeULong")] fun write(x: ULong) - [native("writeDouble")] fun write(x: Double) + [native("writeInt8")] fun write(x: Int8) + [native("writeInt8")] fun write(x: UInt8) + [native("writeInt16")] fun write(x: Int16) + [native("writeInt16")] fun write(x: UInt16) + [native("writeInt32")] fun write(x: Int32) + [native("writeUInt32")] fun write(x: UInt32) + [native("writeInt64")] fun write(x: Int64) + [native("writeUInt64")] fun write(x: UInt64) + [native("writeFloat32")] fun write(x: Float32) + [native("writeFloat64")] fun write(x: Float64) [native("writeChar")] fun write(x: Char) - [native("writeULong")] fun write(x: SizeType) - [native("writeLong")] fun write(x: DiffType) [native("flushOutput")] fun flushOutput diff --git a/SparrowImplicitLib/sprCore/functionPtr.spr b/SparrowImplicitLib/sprCore/functionPtr.spr index 81ac3fc0..ea28ddd6 100644 --- a/SparrowImplicitLib/sprCore/functionPtr.spr +++ b/SparrowImplicitLib/sprCore/functionPtr.spr @@ -1,4 +1,4 @@ -import basicDecls(Type, Byte, Int, AnyType, UntypedPtr) +import basicDecls(Type, Int8, Int, AnyType, UntypedPtr) package _Impl0 [bitcopiable] diff --git a/SparrowImplicitLib/sprCore/mainDef.spr b/SparrowImplicitLib/sprCore/mainDef.spr index ebebec75..b870cbc9 100644 --- a/SparrowImplicitLib/sprCore/mainDef.spr +++ b/SparrowImplicitLib/sprCore/mainDef.spr @@ -1,4 +1,4 @@ -import basicDecls(Char, Byte, Int, SizeType, DiffType, StringRef, Null, typeOf, reinterpretCast, sizeOf, UntypedPtr, ptrAdd, ptrSub, ptrDiff, fromCString, *) +import basicDecls(Char, Int8, Int, StringRef, Null, typeOf, reinterpretCast, sizeOf, UntypedPtr, ptrAdd, ptrSub, ptrDiff, fromCString, *) /// Range type that returns StringRef objects referring to program arguments datatype MainParameters @@ -12,17 +12,17 @@ datatype MainParameters this._end = (this._begin + argc) fun isEmpty(this: MainParameters) = this.size == 0 - fun size(this: MainParameters): SizeType = _end - _begin + fun size(this: MainParameters): Int = _end - _begin fun front(this: MainParameters): RetType = _begin toStringRef fun back(this: MainParameters): RetType = _end - 1 toStringRef fun ()(this: MainParameters) : RetType = _begin toStringRef - fun ()(this: MainParameters, n: SizeType): RetType = _begin + n toStringRef + fun ()(this: MainParameters, n: Int): RetType = _begin + n toStringRef fun popFront(this: @MainParameters) { _begin = (_begin + 1); } fun popBack(this: @MainParameters) { _end = (_end - 1); } - fun popFront(this: @MainParameters, n: SizeType) { _begin = (_begin + n); } - fun popBack(this: @MainParameters, n: SizeType) { _end = (_end - n); } + fun popFront(this: @MainParameters, n: Int) { _begin = (_begin + n); } + fun popBack(this: @MainParameters, n: Int) { _end = (_end - n); } package _Impl [bitcopiable] @@ -33,9 +33,9 @@ package _Impl fun fromArgvPtr(argv: @ @Char): CStrPtr = CStrPtr(reinterpretCast(@CStr, argv)) fun toCStrPtr(p: UntypedPtr): CStrPtr = CStrPtr(p.asRefOf(CStr)) fun toUntypedPtr(p: CStrPtr) = UntypedPtr(p.ptr) - fun +(p: CStrPtr, n: SizeType): CStrPtr = toUntypedPtr(p) ptrAdd (n*sizeOf(CStrPtr)) toCStrPtr - fun -(p: CStrPtr, n: SizeType): CStrPtr = toUntypedPtr(p) ptrSub (n*sizeOf(CStrPtr)) toCStrPtr - fun -(p, q: CStrPtr): SizeType = ptrDiff(toUntypedPtr(p), toUntypedPtr(q)) / (sizeOf(CStrPtr)) + fun +(p: CStrPtr, n: Int): CStrPtr = toUntypedPtr(p) ptrAdd (n*sizeOf(CStrPtr)) toCStrPtr + fun -(p: CStrPtr, n: Int): CStrPtr = toUntypedPtr(p) ptrSub (n*sizeOf(CStrPtr)) toCStrPtr + fun -(p, q: CStrPtr): Int = ptrDiff(toUntypedPtr(p), toUntypedPtr(q)) / (sizeOf(CStrPtr)) fun toStringRef(p: CStrPtr): StringRef = fromCString(p.ptr.cstr) diff --git a/SparrowImplicitLib/sprCore/stdTypesImpl.llvm b/SparrowImplicitLib/sprCore/stdTypesImpl.llvm index 8962b059..8ead76db 100644 --- a/SparrowImplicitLib/sprCore/stdTypesImpl.llvm +++ b/SparrowImplicitLib/sprCore/stdTypesImpl.llvm @@ -432,671 +432,671 @@ define i1 @_Bool_opNeg(i1 %x) alwaysinline ret i1 %1 } -define i8 @_Byte_opAssign(i8* %x, i8 %y) alwaysinline +define i8 @_Int8_opAssign(i8* %x, i8 %y) alwaysinline { store i8 %y, i8* %x ret i8 %y } -define i1 @_Byte_opEQ(i8 %x, i8 %y) alwaysinline +define i1 @_Int8_opEQ(i8 %x, i8 %y) alwaysinline { %1 = icmp eq i8 %x, %y ret i1 %1 } -define i1 @_Byte_opNE(i8 %x, i8 %y) alwaysinline +define i1 @_Int8_opNE(i8 %x, i8 %y) alwaysinline { %1 = icmp ne i8 %x, %y ret i1 %1 } -define i1 @_Byte_opLT(i8 %x, i8 %y) alwaysinline +define i1 @_Int8_opLT(i8 %x, i8 %y) alwaysinline { %1 = icmp slt i8 %x, %y ret i1 %1 } -define i1 @_Byte_opGT(i8 %x, i8 %y) alwaysinline +define i1 @_Int8_opGT(i8 %x, i8 %y) alwaysinline { %1 = icmp sgt i8 %x, %y ret i1 %1 } -define i1 @_Byte_opLE(i8 %x, i8 %y) alwaysinline +define i1 @_Int8_opLE(i8 %x, i8 %y) alwaysinline { %1 = icmp sle i8 %x, %y ret i1 %1 } -define i1 @_Byte_opGE(i8 %x, i8 %y) alwaysinline +define i1 @_Int8_opGE(i8 %x, i8 %y) alwaysinline { %1 = icmp sge i8 %x, %y ret i1 %1 } -define i8 @_Byte_opPlus(i8 %x, i8 %y) alwaysinline +define i8 @_Int8_opPlus(i8 %x, i8 %y) alwaysinline { %1 = add i8 %x, %y ret i8 %1 } -define i8 @_Byte_opMinus(i8 %x, i8 %y) alwaysinline +define i8 @_Int8_opMinus(i8 %x, i8 %y) alwaysinline { %1 = sub i8 %x, %y ret i8 %1 } -define i8 @_Byte_opMul(i8 %x, i8 %y) alwaysinline +define i8 @_Int8_opMul(i8 %x, i8 %y) alwaysinline { %1 = mul i8 %x, %y ret i8 %1 } -define i8 @_Byte_opDiv(i8 %x, i8 %y) alwaysinline +define i8 @_Int8_opDiv(i8 %x, i8 %y) alwaysinline { %1 = sdiv i8 %x, %y ret i8 %1 } -define i8 @_Byte_opMod(i8 %x, i8 %y) alwaysinline +define i8 @_Int8_opMod(i8 %x, i8 %y) alwaysinline { %1 = srem i8 %x, %y ret i8 %1 } -define i8 @_Byte_opPlus1(i8 %x) alwaysinline +define i8 @_Int8_opPlus1(i8 %x) alwaysinline { ret i8 %x } -define i8 @_Byte_opMinus1(i8 %x) alwaysinline +define i8 @_Int8_opMinus1(i8 %x) alwaysinline { %1 = sub i8 0, %x ret i8 %1 } -define i8 @_UByte_opAssign(i8* %x, i8 %y) alwaysinline +define i8 @_UInt8_opAssign(i8* %x, i8 %y) alwaysinline { store i8 %y, i8* %x ret i8 %y } -define i1 @_UByte_opEQ(i8 %x, i8 %y) alwaysinline +define i1 @_UInt8_opEQ(i8 %x, i8 %y) alwaysinline { %1 = icmp eq i8 %x, %y ret i1 %1 } -define i1 @_UByte_opNE(i8 %x, i8 %y) alwaysinline +define i1 @_UInt8_opNE(i8 %x, i8 %y) alwaysinline { %1 = icmp ne i8 %x, %y ret i1 %1 } -define i1 @_UByte_opLT(i8 %x, i8 %y) alwaysinline +define i1 @_UInt8_opLT(i8 %x, i8 %y) alwaysinline { %1 = icmp ult i8 %x, %y ret i1 %1 } -define i1 @_UByte_opGT(i8 %x, i8 %y) alwaysinline +define i1 @_UInt8_opGT(i8 %x, i8 %y) alwaysinline { %1 = icmp ugt i8 %x, %y ret i1 %1 } -define i1 @_UByte_opLE(i8 %x, i8 %y) alwaysinline +define i1 @_UInt8_opLE(i8 %x, i8 %y) alwaysinline { %1 = icmp ule i8 %x, %y ret i1 %1 } -define i1 @_UByte_opGE(i8 %x, i8 %y) alwaysinline +define i1 @_UInt8_opGE(i8 %x, i8 %y) alwaysinline { %1 = icmp uge i8 %x, %y ret i1 %1 } -define i8 @_UByte_opPlus(i8 %x, i8 %y) alwaysinline +define i8 @_UInt8_opPlus(i8 %x, i8 %y) alwaysinline { %1 = add i8 %x, %y ret i8 %1 } -define i8 @_UByte_opMinus(i8 %x, i8 %y) alwaysinline +define i8 @_UInt8_opMinus(i8 %x, i8 %y) alwaysinline { %1 = sub i8 %x, %y ret i8 %1 } -define i8 @_UByte_opMul(i8 %x, i8 %y) alwaysinline +define i8 @_UInt8_opMul(i8 %x, i8 %y) alwaysinline { %1 = mul i8 %x, %y ret i8 %1 } -define i8 @_UByte_opDiv(i8 %x, i8 %y) alwaysinline +define i8 @_UInt8_opDiv(i8 %x, i8 %y) alwaysinline { %1 = udiv i8 %x, %y ret i8 %1 } -define i8 @_UByte_opMod(i8 %x, i8 %y) alwaysinline +define i8 @_UInt8_opMod(i8 %x, i8 %y) alwaysinline { %1 = urem i8 %x, %y ret i8 %1 } -define i8 @_UByte_opPlus1(i8 %x) alwaysinline +define i8 @_UInt8_opPlus1(i8 %x) alwaysinline { ret i8 %x } -define i16 @_Short_opAssign(i16* %x, i16 %y) alwaysinline +define i16 @_Int16_opAssign(i16* %x, i16 %y) alwaysinline { store i16 %y, i16* %x ret i16 %y } -define i1 @_Short_opEQ(i16 %x, i16 %y) alwaysinline +define i1 @_Int16_opEQ(i16 %x, i16 %y) alwaysinline { %1 = icmp eq i16 %x, %y ret i1 %1 } -define i1 @_Short_opNE(i16 %x, i16 %y) alwaysinline +define i1 @_Int16_opNE(i16 %x, i16 %y) alwaysinline { %1 = icmp ne i16 %x, %y ret i1 %1 } -define i1 @_Short_opLT(i16 %x, i16 %y) alwaysinline +define i1 @_Int16_opLT(i16 %x, i16 %y) alwaysinline { %1 = icmp slt i16 %x, %y ret i1 %1 } -define i1 @_Short_opGT(i16 %x, i16 %y) alwaysinline +define i1 @_Int16_opGT(i16 %x, i16 %y) alwaysinline { %1 = icmp sgt i16 %x, %y ret i1 %1 } -define i1 @_Short_opLE(i16 %x, i16 %y) alwaysinline +define i1 @_Int16_opLE(i16 %x, i16 %y) alwaysinline { %1 = icmp sle i16 %x, %y ret i1 %1 } -define i1 @_Short_opGE(i16 %x, i16 %y) alwaysinline +define i1 @_Int16_opGE(i16 %x, i16 %y) alwaysinline { %1 = icmp sge i16 %x, %y ret i1 %1 } -define i16 @_Short_opPlus(i16 %x, i16 %y) alwaysinline +define i16 @_Int16_opPlus(i16 %x, i16 %y) alwaysinline { %1 = add i16 %x, %y ret i16 %1 } -define i16 @_Short_opMinus(i16 %x, i16 %y) alwaysinline +define i16 @_Int16_opMinus(i16 %x, i16 %y) alwaysinline { %1 = sub i16 %x, %y ret i16 %1 } -define i16 @_Short_opMul(i16 %x, i16 %y) alwaysinline +define i16 @_Int16_opMul(i16 %x, i16 %y) alwaysinline { %1 = mul i16 %x, %y ret i16 %1 } -define i16 @_Short_opDiv(i16 %x, i16 %y) alwaysinline +define i16 @_Int16_opDiv(i16 %x, i16 %y) alwaysinline { %1 = sdiv i16 %x, %y ret i16 %1 } -define i16 @_Short_opMod(i16 %x, i16 %y) alwaysinline +define i16 @_Int16_opMod(i16 %x, i16 %y) alwaysinline { %1 = srem i16 %x, %y ret i16 %1 } -define i16 @_Short_opPlus1(i16 %x) alwaysinline +define i16 @_Int16_opPlus1(i16 %x) alwaysinline { ret i16 %x } -define i16 @_Short_opMinus1(i16 %x) alwaysinline +define i16 @_Int16_opMinus1(i16 %x) alwaysinline { %1 = sub i16 0, %x ret i16 %1 } -define i16 @_UShort_opAssign(i16* %x, i16 %y) alwaysinline +define i16 @_UInt16_opAssign(i16* %x, i16 %y) alwaysinline { store i16 %y, i16* %x ret i16 %y } -define i1 @_UShort_opEQ(i16 %x, i16 %y) alwaysinline +define i1 @_UInt16_opEQ(i16 %x, i16 %y) alwaysinline { %1 = icmp eq i16 %x, %y ret i1 %1 } -define i1 @_UShort_opNE(i16 %x, i16 %y) alwaysinline +define i1 @_UInt16_opNE(i16 %x, i16 %y) alwaysinline { %1 = icmp ne i16 %x, %y ret i1 %1 } -define i1 @_UShort_opLT(i16 %x, i16 %y) alwaysinline +define i1 @_UInt16_opLT(i16 %x, i16 %y) alwaysinline { %1 = icmp ult i16 %x, %y ret i1 %1 } -define i1 @_UShort_opGT(i16 %x, i16 %y) alwaysinline +define i1 @_UInt16_opGT(i16 %x, i16 %y) alwaysinline { %1 = icmp ugt i16 %x, %y ret i1 %1 } -define i1 @_UShort_opLE(i16 %x, i16 %y) alwaysinline +define i1 @_UInt16_opLE(i16 %x, i16 %y) alwaysinline { %1 = icmp ule i16 %x, %y ret i1 %1 } -define i1 @_UShort_opGE(i16 %x, i16 %y) alwaysinline +define i1 @_UInt16_opGE(i16 %x, i16 %y) alwaysinline { %1 = icmp uge i16 %x, %y ret i1 %1 } -define i16 @_UShort_opPlus(i16 %x, i16 %y) alwaysinline +define i16 @_UInt16_opPlus(i16 %x, i16 %y) alwaysinline { %1 = add i16 %x, %y ret i16 %1 } -define i16 @_UShort_opMinus(i16 %x, i16 %y) alwaysinline +define i16 @_UInt16_opMinus(i16 %x, i16 %y) alwaysinline { %1 = sub i16 %x, %y ret i16 %1 } -define i16 @_UShort_opMul(i16 %x, i16 %y) alwaysinline +define i16 @_UInt16_opMul(i16 %x, i16 %y) alwaysinline { %1 = mul i16 %x, %y ret i16 %1 } -define i16 @_UShort_opDiv(i16 %x, i16 %y) alwaysinline +define i16 @_UInt16_opDiv(i16 %x, i16 %y) alwaysinline { %1 = udiv i16 %x, %y ret i16 %1 } -define i16 @_UShort_opMod(i16 %x, i16 %y) alwaysinline +define i16 @_UInt16_opMod(i16 %x, i16 %y) alwaysinline { %1 = urem i16 %x, %y ret i16 %1 } -define i16 @_UShort_opPlus1(i16 %x) alwaysinline +define i16 @_UInt16_opPlus1(i16 %x) alwaysinline { ret i16 %x } -define i32 @_Int_opAssign(i32* %x, i32 %y) alwaysinline +define i32 @_Int32_opAssign(i32* %x, i32 %y) alwaysinline { store i32 %y, i32* %x ret i32 %y } -define i1 @_Int_opEQ(i32 %x, i32 %y) alwaysinline +define i1 @_Int32_opEQ(i32 %x, i32 %y) alwaysinline { %1 = icmp eq i32 %x, %y ret i1 %1 } -define i1 @_Int_opNE(i32 %x, i32 %y) alwaysinline +define i1 @_Int32_opNE(i32 %x, i32 %y) alwaysinline { %1 = icmp ne i32 %x, %y ret i1 %1 } -define i1 @_Int_opLT(i32 %x, i32 %y) alwaysinline +define i1 @_Int32_opLT(i32 %x, i32 %y) alwaysinline { %1 = icmp slt i32 %x, %y ret i1 %1 } -define i1 @_Int_opGT(i32 %x, i32 %y) alwaysinline +define i1 @_Int32_opGT(i32 %x, i32 %y) alwaysinline { %1 = icmp sgt i32 %x, %y ret i1 %1 } -define i1 @_Int_opLE(i32 %x, i32 %y) alwaysinline +define i1 @_Int32_opLE(i32 %x, i32 %y) alwaysinline { %1 = icmp sle i32 %x, %y ret i1 %1 } -define i1 @_Int_opGE(i32 %x, i32 %y) alwaysinline +define i1 @_Int32_opGE(i32 %x, i32 %y) alwaysinline { %1 = icmp sge i32 %x, %y ret i1 %1 } -define i32 @_Int_opPlus(i32 %x, i32 %y) alwaysinline +define i32 @_Int32_opPlus(i32 %x, i32 %y) alwaysinline { %1 = add i32 %x, %y ret i32 %1 } -define i32 @_Int_opMinus(i32 %x, i32 %y) alwaysinline +define i32 @_Int32_opMinus(i32 %x, i32 %y) alwaysinline { %1 = sub i32 %x, %y ret i32 %1 } -define i32 @_Int_opMul(i32 %x, i32 %y) alwaysinline +define i32 @_Int32_opMul(i32 %x, i32 %y) alwaysinline { %1 = mul i32 %x, %y ret i32 %1 } -define i32 @_Int_opDiv(i32 %x, i32 %y) alwaysinline +define i32 @_Int32_opDiv(i32 %x, i32 %y) alwaysinline { %1 = sdiv i32 %x, %y ret i32 %1 } -define i32 @_Int_opMod(i32 %x, i32 %y) alwaysinline +define i32 @_Int32_opMod(i32 %x, i32 %y) alwaysinline { %1 = srem i32 %x, %y ret i32 %1 } -define i32 @_Int_opPlus1(i32 %x) alwaysinline +define i32 @_Int32_opPlus1(i32 %x) alwaysinline { ret i32 %x } -define i32 @_Int_opMinus1(i32 %x) alwaysinline +define i32 @_Int32_opMinus1(i32 %x) alwaysinline { %1 = sub i32 0, %x ret i32 %1 } -define i32 @_UInt_opAssign(i32* %x, i32 %y) alwaysinline +define i32 @_UInt32_opAssign(i32* %x, i32 %y) alwaysinline { store i32 %y, i32* %x ret i32 %y } -define i1 @_UInt_opEQ(i32 %x, i32 %y) alwaysinline +define i1 @_UInt32_opEQ(i32 %x, i32 %y) alwaysinline { %1 = icmp eq i32 %x, %y ret i1 %1 } -define i1 @_UInt_opNE(i32 %x, i32 %y) alwaysinline +define i1 @_UInt32_opNE(i32 %x, i32 %y) alwaysinline { %1 = icmp ne i32 %x, %y ret i1 %1 } -define i1 @_UInt_opLT(i32 %x, i32 %y) alwaysinline +define i1 @_UInt32_opLT(i32 %x, i32 %y) alwaysinline { %1 = icmp ult i32 %x, %y ret i1 %1 } -define i1 @_UInt_opGT(i32 %x, i32 %y) alwaysinline +define i1 @_UInt32_opGT(i32 %x, i32 %y) alwaysinline { %1 = icmp ugt i32 %x, %y ret i1 %1 } -define i1 @_UInt_opLE(i32 %x, i32 %y) alwaysinline +define i1 @_UInt32_opLE(i32 %x, i32 %y) alwaysinline { %1 = icmp ule i32 %x, %y ret i1 %1 } -define i1 @_UInt_opGE(i32 %x, i32 %y) alwaysinline +define i1 @_UInt32_opGE(i32 %x, i32 %y) alwaysinline { %1 = icmp uge i32 %x, %y ret i1 %1 } -define i32 @_UInt_opPlus(i32 %x, i32 %y) alwaysinline +define i32 @_UInt32_opPlus(i32 %x, i32 %y) alwaysinline { %1 = add i32 %x, %y ret i32 %1 } -define i32 @_UInt_opMinus(i32 %x, i32 %y) alwaysinline +define i32 @_UInt32_opMinus(i32 %x, i32 %y) alwaysinline { %1 = sub i32 %x, %y ret i32 %1 } -define i32 @_UInt_opMul(i32 %x, i32 %y) alwaysinline +define i32 @_UInt32_opMul(i32 %x, i32 %y) alwaysinline { %1 = mul i32 %x, %y ret i32 %1 } -define i32 @_UInt_opDiv(i32 %x, i32 %y) alwaysinline +define i32 @_UInt32_opDiv(i32 %x, i32 %y) alwaysinline { %1 = udiv i32 %x, %y ret i32 %1 } -define i32 @_UInt_opMod(i32 %x, i32 %y) alwaysinline +define i32 @_UInt32_opMod(i32 %x, i32 %y) alwaysinline { %1 = urem i32 %x, %y ret i32 %1 } -define i32 @_UInt_opPlus1(i32 %x) alwaysinline +define i32 @_UInt32_opPlus1(i32 %x) alwaysinline { ret i32 %x } -define i64 @_Long_opAssign(i64* %x, i64 %y) alwaysinline +define i64 @_Int64_opAssign(i64* %x, i64 %y) alwaysinline { store i64 %y, i64* %x ret i64 %y } -define i1 @_Long_opEQ(i64 %x, i64 %y) alwaysinline +define i1 @_Int64_opEQ(i64 %x, i64 %y) alwaysinline { %1 = icmp eq i64 %x, %y ret i1 %1 } -define i1 @_Long_opNE(i64 %x, i64 %y) alwaysinline +define i1 @_Int64_opNE(i64 %x, i64 %y) alwaysinline { %1 = icmp ne i64 %x, %y ret i1 %1 } -define i1 @_Long_opLT(i64 %x, i64 %y) alwaysinline +define i1 @_Int64_opLT(i64 %x, i64 %y) alwaysinline { %1 = icmp slt i64 %x, %y ret i1 %1 } -define i1 @_Long_opGT(i64 %x, i64 %y) alwaysinline +define i1 @_Int64_opGT(i64 %x, i64 %y) alwaysinline { %1 = icmp sgt i64 %x, %y ret i1 %1 } -define i1 @_Long_opLE(i64 %x, i64 %y) alwaysinline +define i1 @_Int64_opLE(i64 %x, i64 %y) alwaysinline { %1 = icmp sle i64 %x, %y ret i1 %1 } -define i1 @_Long_opGE(i64 %x, i64 %y) alwaysinline +define i1 @_Int64_opGE(i64 %x, i64 %y) alwaysinline { %1 = icmp sge i64 %x, %y ret i1 %1 } -define i64 @_Long_opPlus(i64 %x, i64 %y) alwaysinline +define i64 @_Int64_opPlus(i64 %x, i64 %y) alwaysinline { %1 = add i64 %x, %y ret i64 %1 } -define i64 @_Long_opMinus(i64 %x, i64 %y) alwaysinline +define i64 @_Int64_opMinus(i64 %x, i64 %y) alwaysinline { %1 = sub i64 %x, %y ret i64 %1 } -define i64 @_Long_opMul(i64 %x, i64 %y) alwaysinline +define i64 @_Int64_opMul(i64 %x, i64 %y) alwaysinline { %1 = mul i64 %x, %y ret i64 %1 } -define i64 @_Long_opDiv(i64 %x, i64 %y) alwaysinline +define i64 @_Int64_opDiv(i64 %x, i64 %y) alwaysinline { %1 = sdiv i64 %x, %y ret i64 %1 } -define i64 @_Long_opMod(i64 %x, i64 %y) alwaysinline +define i64 @_Int64_opMod(i64 %x, i64 %y) alwaysinline { %1 = srem i64 %x, %y ret i64 %1 } -define i64 @_Long_opPlus1(i64 %x) alwaysinline +define i64 @_Int64_opPlus1(i64 %x) alwaysinline { ret i64 %x } -define i64 @_Long_opMinus1(i64 %x) alwaysinline +define i64 @_Int64_opMinus1(i64 %x) alwaysinline { %1 = sub i64 0, %x ret i64 %1 } -define i64 @_ULong_opAssign(i64* %x, i64 %y) alwaysinline +define i64 @_UInt64_opAssign(i64* %x, i64 %y) alwaysinline { store i64 %y, i64* %x ret i64 %y } -define i1 @_ULong_opEQ(i64 %x, i64 %y) alwaysinline +define i1 @_UInt64_opEQ(i64 %x, i64 %y) alwaysinline { %1 = icmp eq i64 %x, %y ret i1 %1 } -define i1 @_ULong_opNE(i64 %x, i64 %y) alwaysinline +define i1 @_UInt64_opNE(i64 %x, i64 %y) alwaysinline { %1 = icmp ne i64 %x, %y ret i1 %1 } -define i1 @_ULong_opLT(i64 %x, i64 %y) alwaysinline +define i1 @_UInt64_opLT(i64 %x, i64 %y) alwaysinline { %1 = icmp ult i64 %x, %y ret i1 %1 } -define i1 @_ULong_opGT(i64 %x, i64 %y) alwaysinline +define i1 @_UInt64_opGT(i64 %x, i64 %y) alwaysinline { %1 = icmp ugt i64 %x, %y ret i1 %1 } -define i1 @_ULong_opLE(i64 %x, i64 %y) alwaysinline +define i1 @_UInt64_opLE(i64 %x, i64 %y) alwaysinline { %1 = icmp ule i64 %x, %y ret i1 %1 } -define i1 @_ULong_opGE(i64 %x, i64 %y) alwaysinline +define i1 @_UInt64_opGE(i64 %x, i64 %y) alwaysinline { %1 = icmp uge i64 %x, %y ret i1 %1 } -define i64 @_ULong_opPlus(i64 %x, i64 %y) alwaysinline +define i64 @_UInt64_opPlus(i64 %x, i64 %y) alwaysinline { %1 = add i64 %x, %y ret i64 %1 } -define i64 @_ULong_opMinus(i64 %x, i64 %y) alwaysinline +define i64 @_UInt64_opMinus(i64 %x, i64 %y) alwaysinline { %1 = sub i64 %x, %y ret i64 %1 } -define i64 @_ULong_opMul(i64 %x, i64 %y) alwaysinline +define i64 @_UInt64_opMul(i64 %x, i64 %y) alwaysinline { %1 = mul i64 %x, %y ret i64 %1 } -define i64 @_ULong_opDiv(i64 %x, i64 %y) alwaysinline +define i64 @_UInt64_opDiv(i64 %x, i64 %y) alwaysinline { %1 = udiv i64 %x, %y ret i64 %1 } -define i64 @_ULong_opMod(i64 %x, i64 %y) alwaysinline +define i64 @_UInt64_opMod(i64 %x, i64 %y) alwaysinline { %1 = urem i64 %x, %y ret i64 %1 } -define i64 @_ULong_opPlus1(i64 %x) alwaysinline +define i64 @_UInt64_opPlus1(i64 %x) alwaysinline { ret i64 %x } -define float @_Float_opAssign(float* %x, float %y) alwaysinline +define float @_Float32_opAssign(float* %x, float %y) alwaysinline { store float %y, float* %x ret float %y } -define i1 @_Float_opEQ(float %x, float %y) alwaysinline +define i1 @_Float32_opEQ(float %x, float %y) alwaysinline { %1 = fcmp ueq float %x, %y ret i1 %1 } -define i1 @_Float_opNE(float %x, float %y) alwaysinline +define i1 @_Float32_opNE(float %x, float %y) alwaysinline { %1 = fcmp une float %x, %y ret i1 %1 } -define i1 @_Float_opLT(float %x, float %y) alwaysinline +define i1 @_Float32_opLT(float %x, float %y) alwaysinline { %1 = fcmp ult float %x, %y ret i1 %1 } -define i1 @_Float_opGT(float %x, float %y) alwaysinline +define i1 @_Float32_opGT(float %x, float %y) alwaysinline { %1 = fcmp ugt float %x, %y ret i1 %1 } -define i1 @_Float_opLE(float %x, float %y) alwaysinline +define i1 @_Float32_opLE(float %x, float %y) alwaysinline { %1 = fcmp ule float %x, %y ret i1 %1 } -define i1 @_Float_opGE(float %x, float %y) alwaysinline +define i1 @_Float32_opGE(float %x, float %y) alwaysinline { %1 = fcmp uge float %x, %y ret i1 %1 } -define float @_Float_opPlus(float %x, float %y) alwaysinline +define float @_Float32_opPlus(float %x, float %y) alwaysinline { %1 = fadd float %x, %y ret float %1 } -define float @_Float_opMinus(float %x, float %y) alwaysinline +define float @_Float32_opMinus(float %x, float %y) alwaysinline { %1 = fsub float %x, %y ret float %1 } -define float @_Float_opMul(float %x, float %y) alwaysinline +define float @_Float32_opMul(float %x, float %y) alwaysinline { %1 = fmul float %x, %y ret float %1 } -define float @_Float_opDiv(float %x, float %y) alwaysinline +define float @_Float32_opDiv(float %x, float %y) alwaysinline { %1 = fdiv float %x, %y ret float %1 } -define float @_Float_opPlus1(float %x) alwaysinline +define float @_Float32_opPlus1(float %x) alwaysinline { ret float %x } -define float @_Float_opMinus1(float %x) alwaysinline +define float @_Float32_opMinus1(float %x) alwaysinline { %1 = fsub float 0.0, %x ret float %1 } -define double @_Double_opAssign(double* %x, double %y) alwaysinline +define double @_Float64_opAssign(double* %x, double %y) alwaysinline { store double %y, double* %x ret double %y } -define i1 @_Double_opEQ(double %x, double %y) alwaysinline +define i1 @_Float64_opEQ(double %x, double %y) alwaysinline { %1 = fcmp ueq double %x, %y ret i1 %1 } -define i1 @_Double_opNE(double %x, double %y) alwaysinline +define i1 @_Float64_opNE(double %x, double %y) alwaysinline { %1 = fcmp une double %x, %y ret i1 %1 } -define i1 @_Double_opLT(double %x, double %y) alwaysinline +define i1 @_Float64_opLT(double %x, double %y) alwaysinline { %1 = fcmp ult double %x, %y ret i1 %1 } -define i1 @_Double_opGT(double %x, double %y) alwaysinline +define i1 @_Float64_opGT(double %x, double %y) alwaysinline { %1 = fcmp ugt double %x, %y ret i1 %1 } -define i1 @_Double_opLE(double %x, double %y) alwaysinline +define i1 @_Float64_opLE(double %x, double %y) alwaysinline { %1 = fcmp ule double %x, %y ret i1 %1 } -define i1 @_Double_opGE(double %x, double %y) alwaysinline +define i1 @_Float64_opGE(double %x, double %y) alwaysinline { %1 = fcmp uge double %x, %y ret i1 %1 } -define double @_Double_opPlus(double %x, double %y) alwaysinline +define double @_Float64_opPlus(double %x, double %y) alwaysinline { %1 = fadd double %x, %y ret double %1 } -define double @_Double_opMinus(double %x, double %y) alwaysinline +define double @_Float64_opMinus(double %x, double %y) alwaysinline { %1 = fsub double %x, %y ret double %1 } -define double @_Double_opMul(double %x, double %y) alwaysinline +define double @_Float64_opMul(double %x, double %y) alwaysinline { %1 = fmul double %x, %y ret double %1 } -define double @_Double_opDiv(double %x, double %y) alwaysinline +define double @_Float64_opDiv(double %x, double %y) alwaysinline { %1 = fdiv double %x, %y ret double %1 } -define double @_Double_opPlus1(double %x) alwaysinline +define double @_Float64_opPlus1(double %x) alwaysinline { ret double %x } -define double @_Double_opMinus1(double %x) alwaysinline +define double @_Float64_opMinus1(double %x) alwaysinline { %1 = fsub double 0.0, %x ret double %1 diff --git a/SparrowImplicitLib/sprCore/streamBasic.spr b/SparrowImplicitLib/sprCore/streamBasic.spr index ca07fc9f..2e473948 100644 --- a/SparrowImplicitLib/sprCore/streamBasic.spr +++ b/SparrowImplicitLib/sprCore/streamBasic.spr @@ -1,12 +1,12 @@ -import sprCore.basicDecls(AnyType, Number, Char, Bool, StringRef, Byte, Int, Double, Null, isValid, &&, !, oper_precedence___fapp__, oper_precedence___dot__, typeOf, UntypedPtr) +import sprCore.basicDecls(AnyType, Number, Char, Bool, StringRef, Int8, Int, Int64, UInt64, Float, Null, isValid, &&, !, oper_precedence___fapp__, oper_precedence___dot__, typeOf, UntypedPtr) // An output stream must accept the basic types concept OutStream(x) if ( isValid(x.<<<(1)) - //&& isValid(x.<<<(1L)) + && isValid(x.<<<(1L)) && isValid(x.<<<(1.0)) && isValid(x.<<<('c'.char)) - && isValid(x.<<<("string")) + && isValid(x.<<<('string')) ) // If we define an ">>" operator in the type itself, make sure we can support the standard "<<" notation diff --git a/SparrowImplicitLib/sprCore/stringCvt.spr b/SparrowImplicitLib/sprCore/stringCvt.spr index a21dd87e..ac3a2069 100644 --- a/SparrowImplicitLib/sprCore/stringCvt.spr +++ b/SparrowImplicitLib/sprCore/stringCvt.spr @@ -1,10 +1,10 @@ -import basicDecls(StringRef, Char, Int, Long, Double, typeOf) +import basicDecls(StringRef, Char, Int, Int64, Float, typeOf) fun asInt(src: StringRef) = _StringCvtImpl.atoi(src.cStr()) -fun asLong(src: StringRef) = _StringCvtImpl.atoll(src.cStr()) -fun asDouble(src: StringRef) = _StringCvtImpl.atof(src.cStr()) +fun asInt64(src: StringRef) = _StringCvtImpl.atoll(src.cStr()) +fun asFloat(src: StringRef) = _StringCvtImpl.atof(src.cStr()) package _StringCvtImpl [native("atoi")] fun atoi(str: @Char): Int - [native("atoll")] fun atoll(str: @Char): Long - [native("atof")] fun atof(str: @Char): Double + [native("atoll")] fun atoll(str: @Char): Int64 + [native("atof")] fun atof(str: @Char): Float diff --git a/SparrowImplicitLib/std/algorithms.spr b/SparrowImplicitLib/std/algorithms.spr index 8250db2f..cd3ceac8 100644 --- a/SparrowImplicitLib/std/algorithms.spr +++ b/SparrowImplicitLib/std/algorithms.spr @@ -54,23 +54,23 @@ fun findIf(r: Range, pred: AnyType): typeOf(r) if typeOf(pred(*r)) == Bool /// Finds the index of the given value in the range /// Returns -1 if not found -fun indexOf(r: Range, value: AnyType): SizeType if isValid(*r == value) - let n: !SizeType = 0 +fun indexOf(r: Range, value: AnyType): Int if isValid(*r == value) + let n: !Int = 0 for v: r.RetType = r if v == value return n ++n - return SizeType(DiffType(-1)) + return -1 /// Finds the index of the value that satisfy the given predicate /// Returns -1 if not found -fun indexOfIf(r: Range, pred: AnyType): SizeType if typeOf(pred(*r)) == Bool - let n: !SizeType = 0 +fun indexOfIf(r: Range, pred: AnyType): Int if typeOf(pred(*r)) == Bool + let n: !Int = 0 for v: r.RetType = r if pred(v) return n ++n - return SizeType(DiffType(-1)) + return -1 /// Find the first value from r1 that matches any value in r2 /// Returns the subrange of r1 that starts with that value @@ -91,16 +91,16 @@ fun findFirstOfIf(r1, r2: Range, pred: AnyType): typeOf(r1) if typeOf(pred(*r1, return r1c /// Count how many values from the give range has the given value -fun count(range: Range, value: AnyType): SizeType if isValid(*range == value) - let n: !SizeType = 0 +fun count(range: Range, value: AnyType): Int if isValid(*range == value) + let n: !Int = 0 for v: range.RetType = range if v == value ++n return n /// Count how many values from the given range satisfies the given predicate -fun countIf(range: Range, pred: AnyType): SizeType if typeOf(pred(*range)) == Bool - let n: !SizeType = 0 +fun countIf(range: Range, pred: AnyType): Int if typeOf(pred(*range)) == Bool + let n: !Int = 0 for v: range.RetType = range if pred(v) ++n @@ -178,9 +178,9 @@ fun findRangeIf(r1, r2: Range, pred: AnyType): typeOf(r1) if typeOf(pred(*r1, *r /// Returns the index of the first occurrence of r2 in r1 /// Returns -1 if not found /// Complexity: O(n^2) -fun indexOfRange(r1, r2: Range): SizeType if isValid(*r1 == *r2) +fun indexOfRange(r1, r2: Range): Int if isValid(*r1 == *r2) if !r1 || !r2 - return SizeType(DiffType(-1)) + return -1 // Special case: r2 has only one value var tmp = r2 @@ -196,7 +196,7 @@ fun indexOfRange(r1, r2: Range): SizeType if isValid(*r1 == *r2) return idx r1c popFront ++idx - return SizeType(DiffType(-1)) + return -1 /// Returns the position of the minimum element from the range fun minElement(range: Range): typeOf(range) if isValid(*range < *range) @@ -330,7 +330,7 @@ fun isSorted(range: Range, pred: AnyType): Bool if typeOf(pred(*range, *range)) /// Applies the given functor in a fold fashion, from left, starting from the given seed fun foldLeft(range: Range, function: AnyType, seed: AnyType): TypeOp.removeCat(typeOf(seed)) \ - if isValid(seed = function(seed, #$range.RetType)) + if isValid(TypeOp.copyVal(seed) = TypeOp.copyVal(function)(seed, #$range.RetType)) var t = seed for v: range.RetType = range t = function(t, v) @@ -338,7 +338,7 @@ fun foldLeft(range: Range, function: AnyType, seed: AnyType): TypeOp.removeCat(t /// Applies the given functor in a fold fashion, from right, starting from the given seed fun foldRight(range: BidirRange, function: AnyType, seed: AnyType): TypeOp.removeCat(typeOf(seed)) \ - if isValid(seed = function(seed, *range)) + if isValid(TypeOp.copyVal(seed) = TypeOp.copyVal(function)(seed, *range)) return foldLeft(retro(range), function, seed) /// Copies the content of r1 over the content of r2 @@ -425,8 +425,8 @@ fun sort(range: RandomAccessRange, pred: AnyType) if typeOf(pred(*range, *range) _quickSort(range, 0, rangeSize(range) - 1, pred) /// Apply quick sort to sort the given range -fun _quickSort(range: RandomAccessRange, m, n: SizeType) - if m >= n || n == SizeType(DiffType(-1)) +fun _quickSort(range: RandomAccessRange, m, n: Int) + if m >= n || n == -1 return let p = (m + n) / 2 @@ -446,8 +446,8 @@ fun _quickSort(range: RandomAccessRange, m, n: SizeType) _quickSort(range, j+1, n) /// Apply quick sort to sort the given range, according to the given less predicate -fun _quickSort(range: RandomAccessRange, m, n: SizeType, pred: AnyType) - if m >= n || n == SizeType(DiffType(-1)) +fun _quickSort(range: RandomAccessRange, m, n: Int, pred: AnyType) + if m >= n || n == -1 return let p = (m + n) / 2 diff --git a/SparrowImplicitLib/std/array.spr b/SparrowImplicitLib/std/array.spr index 08b9a6e7..aaf14c62 100644 --- a/SparrowImplicitLib/std/array.spr +++ b/SparrowImplicitLib/std/array.spr @@ -21,7 +21,7 @@ datatype Array(valueType: Type) let size = other.size _begin = allocRawPtr(ValueType, size) - _end = _begin.advance(DiffType(size)) + _end = _begin.advance(size) var dst = _begin var src = other._begin @@ -31,18 +31,18 @@ datatype Array(valueType: Type) dst = dst.advance src = src.advance - fun ctor(this: !Array, size: SizeType) + fun ctor(this: !Array, size: Int) _begin = allocRawPtr(ValueType, size) - _end = _begin.advance(DiffType(size)) + _end = _begin.advance(size) var p = _begin while p != _end ; p = p.advance p.value ctor - fun ctor(this: !Array, size: SizeType, value: this.ValueType) + fun ctor(this: !Array, size: Int, value: this.ValueType) _begin = allocRawPtr(ValueType, size) - _end = _begin.advance(DiffType(size)) + _end = _begin.advance(size) var p = _begin @@ -54,7 +54,7 @@ datatype Array(valueType: Type) let size = rangeSize(range) _begin = allocRawPtr(ValueType, size) - _end = _begin.advance(DiffType(size)) + _end = _begin.advance(size) var p = _begin @@ -72,7 +72,7 @@ datatype Array(valueType: Type) p.value dtor _begin.freePtr - fun size(this: Array): SizeType + fun size(this: Array): Int return _end.diff(_begin) fun isEmpty(this: Array): Bool @@ -100,16 +100,16 @@ datatype Array(valueType: Type) _end = other._end other._end = tmp - fun at(this: Array, index: SizeType): @ValueType - return _begin.advance(DiffType(index)).value - fun ()(this: Array, index: SizeType): @ValueType - return _begin.advance(DiffType(index)).value + fun at(this: Array, index: Int): @ValueType + return _begin.advance(index).value + fun ()(this: Array, index: Int): @ValueType + return _begin.advance(index).value fun all(this: Array): RangeType return RangeType(_begin, _end) - fun subrange(this: Array, index: SizeType, num: SizeType): RangeType - return RangeType(_begin.advance(DiffType(index)), _begin.advance(DiffType(index + num))) + fun subrange(this: Array, index: Int, num: Int): RangeType + return RangeType(_begin.advance(index), _begin.advance(index + num)) fun =(this: !Array, other: typeOf(this)): @typeOf(this) var tmp = other diff --git a/SparrowImplicitLib/std/bitset.spr b/SparrowImplicitLib/std/bitset.spr index f3ffc417..601f8040 100644 --- a/SparrowImplicitLib/std/bitset.spr +++ b/SparrowImplicitLib/std/bitset.spr @@ -4,19 +4,19 @@ import array(Array) import bitOper datatype Bitset - _bits: Array(UByte) + _bits: Array(UInt8) [protected] - fun ctor(this: !Bitset, noBits: SizeType) - _bits.ctor(1 + (noBits-1)/8, UByte(0)) + fun ctor(this: !Bitset, noBits: Int) + _bits.ctor(1 + (noBits-1)/8, UInt8(0)) - fun setBit(this: !Bitset, n: SizeType) - _bits(n/8) = _bits(n/8) !|! (UByte(1) !<>(this: ContiguousMemoryRange, os: !OutStream) if isValid(os << this.front) os << "MemRange(" diff --git a/SparrowImplicitLib/std/defaultHashFunction.spr b/SparrowImplicitLib/std/defaultHashFunction.spr index 72d5aaab..1473f6d1 100644 --- a/SparrowImplicitLib/std/defaultHashFunction.spr +++ b/SparrowImplicitLib/std/defaultHashFunction.spr @@ -10,20 +10,20 @@ datatype DefaultHashFunction(type: Type) [protected] fun ()(this: DefaultHashFunction, arg: !this.ValueType) = defaultHash(arg) -fun defaultHash(arg: Char) = _doHash(Byte(arg), _seed) +fun defaultHash(arg: Char) = _doHash(UInt64(Int8(arg)), _seed) //fun defaultHash(arg: Integer) = _doHash(arg, _seed) -fun defaultHash(arg: Integer) = SizeType(arg) +fun defaultHash(arg: Integer) = UInt64(arg) fun defaultHash(arg: StringRef) = _doHash(arg, _seed) -fun defaultHash(arg: String) = _doHash(arg.asStringRef(), _seed) +fun defaultHash(arg: String) = _doHash(arg.asStringRef(), _seed) -using _seed = 0xfadef00d +using _seed = UInt64(0xfadef00d) /// FNV hash generator -fun _doHash(key: StringRef, start: SizeType): SizeType +fun _doHash(key: StringRef, start: UInt64): UInt64 var hash = start for i = 0..key.size - hash = (hash !^! SizeType(Byte(key(i)))) * 0x01000193 + hash = (hash !^! UInt64(Int8(key(i)))) * UInt64(0x01000193) return hash -fun _doHash(value, start: SizeType): SizeType - return (start !^! value) * 0x01000193 +fun _doHash(value, start: UInt64): UInt64 + return (start !^! value) * UInt64(0x01000193) diff --git a/SparrowImplicitLib/std/hashTable.spr b/SparrowImplicitLib/std/hashTable.spr index 1d5b91f2..a64d5a29 100644 --- a/SparrowImplicitLib/std/hashTable.spr +++ b/SparrowImplicitLib/std/hashTable.spr @@ -21,14 +21,14 @@ datatype HashTable(keyType, valueType, valueToKeyType, traitsType: Type) _buckets: _BucketsType _guard: _MyGuardNode - _numElements: SizeType + _numElements: Int _valToKey: ValueToKeyType _tr: traitsType fun ctor(this: !HashTable) this.ctor(0, _TraitsType()) -fun ctor(this: !HashTable, n: SizeType, traits: this._TraitsType) +fun ctor(this: !HashTable, n: Int, traits: this._TraitsType) _buckets ctor _tr ctor traits _guard ctor @@ -36,7 +36,7 @@ fun ctor(this: !HashTable, n: SizeType, traits: this._TraitsType) if n > 0 this.reserve(n) -fun ctor(this: !HashTable, range: Range, n: SizeType, traits: this._TraitsType) +fun ctor(this: !HashTable, range: Range, n: Int, traits: this._TraitsType) _buckets ctor _tr ctor traits _guard ctor @@ -65,9 +65,9 @@ fun swap(this: !HashTable, other: !typeOf(this)) // Update the buckets pointing to the guard node if _numElements > 0 && !_buckets.isEmpty - _buckets(_guard.next.get().hash % _buckets.size) = this._guardNode + _buckets(_guard.next._tableIndex(_buckets.size)) = this._guardNode if other._numElements > 0 && !other._buckets.isEmpty - other._buckets(other._guard.next.get().hash % other._buckets.size) = other._guardNode + other._buckets(other._guard.next._tableIndex(other._buckets.size)) = other._guardNode [protected] fun =(this: !HashTable, other: typeOf(this)): @typeOf(this) @@ -93,7 +93,7 @@ fun swap(this: !HashTable, other: !typeOf(this)) fun all(this: HashTable) = RangeType(_guard.next, _NodePtr()) - fun reserve(this: !HashTable, n: SizeType) + fun reserve(this: !HashTable, n: Int) // Resize only when we are big enough to re-hash if n <= _buckets.size * _loadFactor return @@ -117,7 +117,7 @@ fun swap(this: !HashTable, other: !typeOf(this)) _guard.next.reset var next: _NodePtr while p.isSet ; p = next - next = p.get().next + next = p.next this._insertNode(p) fun insert(this: !HashTable, value: this.ValueType): this.RangeType @@ -149,16 +149,16 @@ fun swap(this: !HashTable, other: !typeOf(this)) var p = range._startElem while p != range._endElem - let next = p.get().next + let next = p.next this._removeNode(prev, p) p = next fun contains(this: HashTable, key: this.KeyType): Bool = this._findNode(key).isSet - fun count(this: HashTable, key: this.KeyType): SizeType = ife(this._findNode(key).isSet, 1, 0) + fun count(this: HashTable, key: this.KeyType): Int = ife(this._findNode(key).isSet, 1, 0) fun equalRange(this: HashTable, key: this.KeyType): this.RangeType let p = this._findNode(key) - return ife(p.isSet, RangeType(p, p.get().next), RangeType()) + return ife(p.isSet, RangeType(p, p.next), RangeType()) fun find(this: HashTable, key: this.KeyType): this.RangeType let p = this._findNode(key) @@ -177,10 +177,10 @@ fun swap(this: !HashTable, other: !typeOf(this)) return let numBuckets = _buckets.size var prev = this._guardNode - var p = prev.get().next + var p = prev.next var prevBi = numBuckets+1 - while p.isSet ; p = p.get().next - var bi = ife(numBuckets > 0, p.get().hash % numBuckets, 0) + while p.isSet ; p = p.next + var bi = ife(numBuckets > 0, p._tableIndex(numBuckets), 0) if prev == this._guardNode os << bi << ": | " prevBi = bi @@ -199,37 +199,37 @@ fun _guardNode(this: HashTable): this._NodePtr = reinterpretPtr(_MyNode, Ptr(_My fun _findNode(this: HashTable, key: this.KeyType): this._NodePtr return this._findNodeImpl(_tr.hash(key), key) -fun _findNodeImpl(this: HashTable, hashVal: SizeType, key: this.KeyType): this._NodePtr +fun _findNodeImpl(this: HashTable, hashVal: UInt64, key: this.KeyType): this._NodePtr if _numElements == 0 return _NodePtr() let numBuckets = _buckets.size if numBuckets > 0 - let bi = hashVal % numBuckets + let bi = _tableIndex(hashVal, numBuckets) var p: _NodePtr = _buckets(bi) if p.isNull return _NodePtr() // the first element belongs to the previous bucket, skip one element - var next = p.get().next - while next.isSet && (next.get().hash % numBuckets == bi) - if _tr.equal(key, _valToKey(next.get().data)) + var next = p.next + while next.isSet && next._tableIndex(numBuckets) == bi + if _tr.equal(key, _valToKey(next.data)) return next p = next - next = p.get().next + next = p.next else var p: _NodePtr = _guard.next while p.isSet - if _tr.equal(key, _valToKey(p.get().data)) + if _tr.equal(key, _valToKey(p.data)) return p - p = p.get().next + p = p.next return _NodePtr() fun _findPrev(this: HashTable, node: this._NodePtr): this._NodePtr let numBuckets = _buckets.size - var p: _NodePtr = ife(numBuckets==0, this._guardNode, _buckets(node.get().hash % numBuckets)) - while p.get().next != node - p = p.get().next + var p: _NodePtr = ife(numBuckets==0, this._guardNode, _buckets(node._tableIndex(numBuckets))) + while p.next != node + p = p.next return p fun _insertPlain(this: !HashTable, value: this.ValueType): this.RangeType @@ -248,44 +248,44 @@ fun _insertNode(this: !HashTable, node: this._NodePtr) let numBuckets = _buckets.size if numBuckets == 0 // If we have no buckets, put this node in front - node.get().next = _guard.next + node.next = _guard.next _guard.next = node else // If there is no element in the bucket, put this in the bucket, and chain the element at the beginning of the global list // Otherwise, put this after the first element in the bucket - let bi = node.get().hash % numBuckets + let bi = node._tableIndex(numBuckets) if _buckets(bi).isNull - node.get().next = _guard.next + node.next = _guard.next _guard.next = node _buckets(bi) = this._guardNode // fix the bucket of the old start - if node.get().next.isSet - _buckets(node.get().next.get().hash % numBuckets) = node + if node.next.isSet + _buckets(node.next._tableIndex(numBuckets)) = node else - node.get().next = _buckets(bi).get().next - _buckets(bi).get().next = node + node.next = _buckets(bi).next + _buckets(bi).next = node fun _removeNode(this: !HashTable, prev, node: this._NodePtr) let numBuckets = _buckets.size if numBuckets == 0 - prev.get().next = node.get().next + prev.next = node.next else - let bi = node.get().hash % numBuckets - let next = node.get().next + let bi = node._tableIndex(numBuckets) + let next = node.next // If this is the only proper node for this bucket, clear the bucket - if prev == this._guardNode || bi != (prev.get().hash % numBuckets) // this is second - if next.isNull || bi != (next.get().hash % numBuckets) // next is not in this bucket + if prev == this._guardNode || bi != prev._tableIndex(numBuckets) // this is second + if next.isNull || bi != next._tableIndex(numBuckets) // next is not in this bucket _buckets(bi).reset // If the next node is in another bucket, update the first node from that bucket if next.isSet - let nextBi = next.get().hash % numBuckets + let nextBi = next._tableIndex(numBuckets) if bi != nextBi _buckets(nextBi) = prev // Now remove the node - prev.get().next = next + prev.next = next node.release --_numElements @@ -293,19 +293,25 @@ fun _deleteElements(this: !HashTable) var p = _guard.next var next: _NodePtr while p.isSet ; p = next - next = p.get().next + next = p.next p.release _guard.next = _NodePtr() [initCtor] datatype _Node(valueType: Type) next: Ptr(_Node) - hash: SizeType + hash: UInt64 data: valueType fun >> (this: _Node, os: !OutStream) os << data << " <" << UntypedPtr(this) << '>' +fun _tableIndex(this: _Node, tableSize: Int): Int + return Int(hash % UInt64(tableSize)) + +fun _tableIndex(hash: UInt64, tableSize: Int): Int + return Int(hash % UInt64(tableSize)) + [initCtor] datatype _GuardNode(valueType: Type) next: Ptr(_Node(valueType)) @@ -319,10 +325,10 @@ datatype _HashRange(valueType: Type) [protected] fun isEmpty(this: _HashRange) = _startElem == _endElem - fun front(this: _HashRange): this.RetType = _startElem.get().data - fun popFront(this: !_HashRange) { _startElem = _startElem.get().next; } + fun front(this: _HashRange): this.RetType = _startElem.data + fun popFront(this: !_HashRange) { _startElem = _startElem.next; } -var _bucketCounts: StaticArray(SizeType, 31) +var _bucketCounts: StaticArray(Int, 31) using _loadFactor = 1 using _numElementsForBuckets = 10 diff --git a/SparrowImplicitLib/std/list.spr b/SparrowImplicitLib/std/list.spr index a725818f..b444120c 100644 --- a/SparrowImplicitLib/std/list.spr +++ b/SparrowImplicitLib/std/list.spr @@ -12,7 +12,7 @@ datatype List(valueType: Type) using _NodeTypePtr = RawPtr(_MyNodeType) _head: _NodeLinks(valueType) - _listSize: SizeType + _listSize: Int [protected] fun ctor(this: !List) @@ -65,7 +65,7 @@ datatype List(valueType: Type) return true - fun size(this: List): SizeType = _listSize + fun size(this: List): Int = _listSize fun isEmpty(this: List) = _listSize == 0 fun front(this: List): RetType = _head.next.value().data @@ -211,7 +211,7 @@ datatype List(valueType: Type) left.value().next = rc._end rc._end.value().prev = left - fun resize(this: !List, n: SizeType) + fun resize(this: !List, n: Int) if n == _listSize return diff --git a/SparrowImplicitLib/std/map.spr b/SparrowImplicitLib/std/map.spr index d8eaf216..51565b39 100644 --- a/SparrowImplicitLib/std/map.spr +++ b/SparrowImplicitLib/std/map.spr @@ -16,18 +16,18 @@ datatype Map(keyType, dataType: Type, traitsType: Type = DefaultTypeTraits) _hashTable: _ImplTable [protected] - fun ctor(this: !Map, n: SizeType) { _hashTable.ctor(n, TraitsType()); } - fun ctor(this: !Map, n: SizeType, traits: this.TraitsType) { _hashTable.ctor(n, traits); } + fun ctor(this: !Map, n: Int) { _hashTable.ctor(n, TraitsType()); } + fun ctor(this: !Map, n: Int, traits: this.TraitsType) { _hashTable.ctor(n, traits); } fun ctor(this: !Map, range: Range) { _hashTable.ctor(range, 0, TraitsType()); } - fun ctor(this: !Map, range: Range, n: SizeType) { _hashTable.ctor(range, n, HashType(), CompareType()); } - fun ctor(this: !Map, range: Range, n: SizeType, traits: this.TraitsType){ _hashTable.ctor(range, n, traits); } + fun ctor(this: !Map, range: Range, n: Int) { _hashTable.ctor(range, n, HashType(), CompareType()); } + fun ctor(this: !Map, range: Range, n: Int, traits: this.TraitsType){ _hashTable.ctor(range, n, traits); } fun traits(this: Map) = _hashTable.traits fun size(this: Map) = _hashTable.size fun isEmpty(this: Map) = (_hashTable.size == 0) fun bucketCount(this: Map) = _hashTable.bucketCount - fun reserve(this: !Map, n: SizeType) { _hashTable.reserve(n); } + fun reserve(this: !Map, n: Int) { _hashTable.reserve(n); } fun all(this: Map) = _hashTable.all fun keys(this: Map) = transform(_hashTable.all, PairFirst(ValueType)()) diff --git a/SparrowImplicitLib/std/ptr.spr b/SparrowImplicitLib/std/ptr.spr index 74f290c7..2b6ea488 100644 --- a/SparrowImplicitLib/std/ptr.spr +++ b/SparrowImplicitLib/std/ptr.spr @@ -11,7 +11,7 @@ datatype Ptr(type: Type) [protected] fun =(this: !Ptr, ref: this.ValueType) = _ptr := ref - fun < (this, other: Ptr) = (UntypedPtr(_ptr) ptrDiff UntypedPtr(other._ptr)) < DiffType(0) + fun < (this, other: Ptr) = (UntypedPtr(_ptr) ptrDiff UntypedPtr(other._ptr)) < 0 fun get(this: Ptr) = _ptr fun isNull(this: Ptr) = _ptr === null diff --git a/SparrowImplicitLib/std/rMath.spr b/SparrowImplicitLib/std/rMath.spr index 55c0d9dd..b27d2847 100644 --- a/SparrowImplicitLib/std/rMath.spr +++ b/SparrowImplicitLib/std/rMath.spr @@ -7,12 +7,12 @@ fun sqr n = n*n fun sum(r: Range) = foldLeft(r, (fun x,y = x+y), r.RetType(0)) -fun mean(r: Range): Double if Number(#$r.RetType) +fun mean(r: Range): Float if Number(#$r.RetType) var sum: r.RetType = 0 var count = 0 for x = r sum += x ++count - return Double(sum) / Double(count) + return Float(sum) / Float(count) fun rootMeanSquare r = sqrt(mean(r map \sqr)) diff --git a/SparrowImplicitLib/std/ranges.spr b/SparrowImplicitLib/std/ranges.spr index 73d5f9e3..dd190b14 100644 --- a/SparrowImplicitLib/std/ranges.spr +++ b/SparrowImplicitLib/std/ranges.spr @@ -13,7 +13,7 @@ concept BidirRange(x: Range) if ( /// A random access range allows obtaining the size and accessing elements by index concept RandomAccessRange(x: BidirRange) if ( - typeOf(x.size) == SizeType + typeOf(x.size) == Int && typeOf(x(0)) == x.RetType ) @@ -54,19 +54,20 @@ fun pre_*(r: Range): r.RetType = r.front // /// Gets the size of the range -- generic case -fun rangeSize(range: Range): SizeType +fun rangeSize(range: Range): Int var rCopy = range; - var n: SizeType = 0 + var n = 0 while !rCopy.isEmpty ; rCopy.popFront ++n return n /// Gets the size of the range -- random-access-range case -fun rangeSize(range: RandomAccessRange): SizeType +fun rangeSize(range: RandomAccessRange): Int return range.size /// Advances the given number of positions -- does not check for range validity -fun advance(range: !Range, n: SizeType) - while (n--) > 0 +fun advance(range: !Range, n: Int) + var nn = n + while (nn--) > 0 range.popFront /// Advances while the predicate is satisfied; checks the range validity @@ -75,7 +76,7 @@ fun advanceIf(range: !Range, pred: AnyType) if isValid(pred(range.front)) range.popFront /// Removes from back the given number of positions -- does not check for range validity -fun retract(range: !BidirRange, n: SizeType) +fun retract(range: !BidirRange, n: Int) while (n--) > 0 range.popBack @@ -91,8 +92,8 @@ fun retractIf(range: !BidirRange, pred: AnyType) if isValid(pred(range.back)) fun numericRange(start, end: Number) = NumericRangeInc(commonType(typeOf(start), typeOf(end)))(start, end) fun numericRange(start, end, step: Number) = NumericRangeWithStep(commonType(typeOf(start), typeOf(end)))(start, end, step) -fun ..(start, end: Number) = NumericRangeInc(commonType(typeOf(start), typeOf(end)))(start, end) -fun ...(start, end: Number) = NumericRangeInc(commonType(typeOf(start), typeOf(end)))(start, end, true) +fun ..(start: Number, end: typeOf(start)) = NumericRangeInc(commonType(typeOf(start), typeOf(end)))(start, end) +fun ...(start: Number, end: typeOf(start)) = NumericRangeInc(commonType(typeOf(start), typeOf(end)))(start, end, true) fun post_..(start: Number) = NumericRangeInc(typeOf(start))(start, NumericLimits(typeOf(start)).maxValue) fun ../(range: Range, step: Number) = NumericRangeWithStep(range.RetType)(range, step) @@ -105,21 +106,21 @@ fun ../(range: Range, step: Number) = NumericRangeWithStep(range.RetType)(range, fun retro(range: BidirRange) = RetroRange(typeOf(range))(range) /// Restricts the range to the given number of elements -fun take(range: Range, count: SizeType) = TakeRange(typeOf(range))(range, count) +fun take(range: Range, count: Int) = TakeRange(typeOf(range))(range, count) /// Skip the first 'count' elements from the range -fun skip(range: Range, count: SizeType): typeOf(range) +fun skip(range: Range, count: Int): typeOf(range) var rc = range rc advance count return rc /// Take elements from the range while the given predicate is satisfied fun takeWhile(range: Range, pred: AnyType) = TakeWhileRange(typeOf(range), typeOf(pred))(range, pred) -fun takeWhile(range: Range, pred: AnyType, count: SizeType) = take(takeWhile(range, pred), count) +fun takeWhile(range: Range, pred: AnyType, count: Int) = take(takeWhile(range, pred), count) /// Take elements from the range until the predicate is satisfied fun takeUntil(range: Range, pred: AnyType) = TakeUntilRange(typeOf(range), typeOf(pred))(range, pred) -fun takeUntil(range: Range, pred: AnyType, count: SizeType) = take(takeUntil(range, pred), count) +fun takeUntil(range: Range, pred: AnyType, count: Int) = take(takeUntil(range, pred), count) /// Apply a predicate filter to the given range fun filter(range: Range, pred: AnyType) = FilteredRange(typeOf(range), typeOf(pred))(range, pred) @@ -132,34 +133,34 @@ fun map(range: Range, function: AnyType) = TransformedRange(typeOf(range), typeO //[rt] /// Repeats the given value to for a range of the same value fun repeat(value: AnyType) = RepeatRange(typeOf(value))(value) -fun repeat(value: AnyType, count: SizeType) = take(repeat(value), count) +fun repeat(value: AnyType, count: Int) = take(repeat(value), count) /// Chain two ranges together to form a concatenated range fun chain(range1, range2: Range) = ChainRange(typeOf(range1), typeOf(range2))(range1, range2) fun ++(range1, range2: Range) = ChainRange(typeOf(range1), typeOf(range2))(range1, range2) /// Range that takes elements with a give stride (every step skips some elements) -fun stride(range: Range, strideStep: SizeType) = StridedRange(typeOf(range))(range, strideStep) +fun stride(range: Range, strideStep: Int) = StridedRange(typeOf(range))(range, strideStep) /// Range that takes the elements in a radial fashion: i, i+1, i-1, i+2, i-2, ... -fun radial(range: Range, index: SizeType) = RadialRange(typeOf(range))(range, index) +fun radial(range: Range, index: Int) = RadialRange(typeOf(range))(range, index) // TODO: Fix the error that is causing us to make this RT //[rt] /// Creates an infinite/counted range by repeating the elements from the given range /// as long as it takes fun cycle(range: Range) = CyclicRange(typeOf(range))(range) -fun cycle(range: Range, count: SizeType) = CyclicCountedRange(typeOf(range))(range, count) +fun cycle(range: Range, count: Int) = CyclicCountedRange(typeOf(range))(range, count) /// Generate a range by applying the given function to get the values for the range fun generate(function: AnyType) = GeneratedRange(typeOf(function))(function) -fun generate(function: AnyType, count: SizeType) = take(generate(function), count) +fun generate(function: AnyType, count: Int) = take(generate(function), count) /// Generate a chain-reaction range /// Starts with the given value, then calls the given functor on the value to obtain the next value, /// then calls again the functor on the new value, and so on fun generate1(start: AnyType, function: AnyType) = Generated1Range(typeOf(start), typeOf(function))(start, function) -fun generate1(start: AnyType, function: AnyType, count: SizeType) = take(generate1(start, function), count) +fun generate1(start: AnyType, function: AnyType, count: Int) = take(generate1(start, function), count) /// Given two ranges, combine the values from the two ranges together to produce one single range fun zip(range1, range2: Range, function: AnyType) = ZippedRange(typeOf(range1), typeOf(range2), typeOf(function))(range1, range2, function) @@ -197,12 +198,12 @@ fun ctor(this: !NumericRangeInc, start, end: this.RetType, closed: Bool) fun back(this: NumericRangeInc): RetType = _begin + RetType(this.size-1) fun popBack(this: !NumericRangeInc) { _end -= _step } - fun size(this: NumericRangeInc): SizeType = SizeType(ife(_closed, RetType(_end-_begin+1), _end-_begin)) + fun size(this: NumericRangeInc): Int = Int(ife(_closed, RetType(_end-_begin+1), _end-_begin)) - fun popFront(this: !NumericRangeInc, n: SizeType) { _begin += RetType(n) } - fun popBack(this: !NumericRangeInc, n: SizeType) { _end -= RetType(n) } + fun popFront(this: !NumericRangeInc, n: Int) { _begin += RetType(n) } + fun popBack(this: !NumericRangeInc, n: Int) { _end -= RetType(n) } - fun ()(this: NumericRangeInc, n: SizeType): RetType = _begin + RetType(n) + fun ()(this: NumericRangeInc, n: Int): RetType = _begin + RetType(n) datatype NumericRangeWithStep(valueType: Type) if Number(#$valueType) _begin, _end, _step: valueType @@ -260,12 +261,12 @@ fun popFront(this: !NumericRangeWithStep) { _begin += _step } fun back(this: NumericRangeWithStep): RetType = _begin + RetType(this.size-1)*_step fun popBack(this: !NumericRangeWithStep) { _end -= _step } -fun size(this: NumericRangeWithStep): SizeType = SizeType(math.floor(ife(_closed, _end-_begin, _end-_begin+_step)/_step)) +fun size(this: NumericRangeWithStep): Int = Int(math.floor(Float(ife(_closed, _end-_begin, _end-_begin+_step)/_step))) -fun popFront(this: !NumericRangeWithStep, n: SizeType) { _begin += RetType(n*_step) } -fun popBack(this: !NumericRangeWithStep, n: SizeType) { _end -= RetType(n*_step) } +fun popFront(this: !NumericRangeWithStep, n: Int) { _begin += RetType(n*_step) } +fun popBack(this: !NumericRangeWithStep, n: Int) { _end -= RetType(n*_step) } -fun ()(this: NumericRangeWithStep, n: SizeType): RetType = _begin + RetType(n*_step) +fun ()(this: NumericRangeWithStep, n: Int): RetType = _begin + RetType(n*_step) [initCtor] datatype RetroRange(rangeType: Type) if BidirRange(#$rangeType) @@ -284,7 +285,7 @@ datatype RetroRange(rangeType: Type) if BidirRange(#$rangeType) [initCtor] datatype TakeRange(rangeType: Type) if Range(#$rangeType) _range: rangeType - _count: SizeType + _count: Int using RetType = rangeType.RetType @@ -410,7 +411,7 @@ datatype ChainRange(rangeType1: Type, rangeType2: Type) \ [initCtor] datatype StridedRange(rangeType: Type) if Range(#$rangeType) _range: rangeType - _strideStep: SizeType + _strideStep: Int using RetType = rangeType.RetType @@ -426,10 +427,10 @@ datatype StridedRange(rangeType: Type) if Range(#$rangeType) [initCtor] datatype RadialRange(rangeType: Type) if RandomAccessRange(#$rangeType) _range: rangeType - _index: SizeType - _count: SizeType = 0 - _step: DiffType = 1 - _sign: DiffType = 1 + _index: Int + _count: Int = 0 + _step: Int = 1 + _sign: Int = 1 using RetType = rangeType.RetType @@ -466,12 +467,12 @@ fun ctor(this: !CyclicRange, range: this._RangeType) datatype CyclicCountedRange(rangeType: Type) if Range(#$rangeType) _range, _base: rangeType - _count: SizeType + _count: Int using RetType = rangeType.RetType using _RangeType = rangeType -fun ctor(this: !CyclicCountedRange, range: this._RangeType, count: SizeType) +fun ctor(this: !CyclicCountedRange, range: this._RangeType, count: Int) this._range ctor range this._count ctor count this._base ctor range @@ -548,7 +549,7 @@ datatype ScanLeftRange(accType, rangeType: Type, functionType: Type) if Range(#$ [initCtor] datatype ValuesRange(contType: Type) if isValid((#$contType)(1)) _values: contType - _idx: SizeType = 0 + _idx: Int = 0 using RetType = contType.ValueType diff --git a/SparrowImplicitLib/std/rawPtr.spr b/SparrowImplicitLib/std/rawPtr.spr index 10ab95d8..0769fe9e 100644 --- a/SparrowImplicitLib/std/rawPtr.spr +++ b/SparrowImplicitLib/std/rawPtr.spr @@ -10,21 +10,20 @@ fun ctor(this: !RawPtr, p: UntypedPtr) _ptr := p asRefOf ValueType [protected] - fun < (this, other: RawPtr) = (UntypedPtr(_ptr) ptrDiff UntypedPtr(other._ptr)) < DiffType(0) + fun < (this, other: RawPtr) = (UntypedPtr(_ptr) ptrDiff UntypedPtr(other._ptr)) < 0 - fun value(this: RawPtr): @ValueType = _ptr + fun value(this: RawPtr): @ValueType = _ptr - fun advance(this: RawPtr): typeOf(this) = typeOf(this)( UntypedPtr(_ptr) ptrAdd sizeOf(ValueType) ) - fun advance(this: RawPtr, n: SizeType): typeOf(this) = typeOf(this)( UntypedPtr(_ptr) ptrAdd (n * sizeOf(ValueType)) ) - fun advance(this: RawPtr, n: DiffType): typeOf(this) = typeOf(this)( UntypedPtr(_ptr) ptrAdd (n * DiffType(sizeOf(ValueType))) ) - fun diff(this: RawPtr, other: typeOf(this)): DiffType = (UntypedPtr(_ptr) ptrDiff UntypedPtr(other._ptr)) / DiffType(sizeOf(ValueType)) + fun advance(this: RawPtr): typeOf(this) = typeOf(this)( UntypedPtr(_ptr) ptrAdd sizeOf(ValueType) ) + fun advance(this: RawPtr, n: Int): typeOf(this) = typeOf(this)( UntypedPtr(_ptr) ptrAdd (n * sizeOf(ValueType)) ) + fun diff(this: RawPtr, other: typeOf(this)): Int = (UntypedPtr(_ptr) ptrDiff UntypedPtr(other._ptr)) / sizeOf(ValueType) fun isNull(this: RawPtr): Bool = _ptr === null fun isSet(this: RawPtr) = _ptr !== null fun untypedPtr(this: RawPtr): UntypedPtr = UntypedPtr(_ptr) - fun reallocPtr(this: !RawPtr, n: SizeType) + fun reallocPtr(this: !RawPtr, n: Int) _ptr := realloc(UntypedPtr(_ptr), n * sizeOf(ValueType)).asRefOf(ValueType) fun freePtr(this: RawPtr) @@ -40,5 +39,5 @@ fun ctor(this: !RawPtr, p: UntypedPtr) os << "RawPtr(" << UntypedPtr(_ptr) << ")" fun mkRawPtr(ref: !AnyType) = RawPtr(-@typeOf(ref))(ref) -fun allocRawPtr(t: Type, num: SizeType) = RawPtr(t)(reinterpretCast(@t, malloc(num * sizeOf(t)).data)) +fun allocRawPtr(t: Type, num: Int) = RawPtr(t)(reinterpretCast(@t, malloc(num * sizeOf(t)).data)) diff --git a/SparrowImplicitLib/std/set.spr b/SparrowImplicitLib/std/set.spr index 6230b50d..8606b2f1 100644 --- a/SparrowImplicitLib/std/set.spr +++ b/SparrowImplicitLib/std/set.spr @@ -12,11 +12,11 @@ datatype Set(keyType: Type, traitsType: Type = DefaultTypeTraits) _hashTable: _ImplTable -fun ctor(this: !Set, n: SizeType) { _hashTable.ctor(n, TraitsType()) } -fun ctor(this: !Set, n: SizeType, traits: this.TraitsType) { _hashTable.ctor(n, traits) } +fun ctor(this: !Set, n: Int) { _hashTable.ctor(n, TraitsType()) } +fun ctor(this: !Set, n: Int, traits: this.TraitsType) { _hashTable.ctor(n, traits) } fun ctor(this: !Set, range: Range) { _hashTable.ctor(range, 0, TraitsType()) } -fun ctor(this: !Set, range: Range, n: SizeType) { _hashTable.ctor(range, n, HashType(), CompareType()) } -fun ctor(this: !Set, range: Range, n: SizeType, traits: this.TraitsType){ _hashTable.ctor(range, n, traits) } +fun ctor(this: !Set, range: Range, n: Int) { _hashTable.ctor(range, n, HashType(), CompareType()) } +fun ctor(this: !Set, range: Range, n: Int, traits: this.TraitsType){ _hashTable.ctor(range, n, traits) } [protected] fun traits(this: Set) = _hashTable.traits @@ -24,7 +24,7 @@ fun ctor(this: !Set, range: Range, n: SizeType, traits: this.TraitsType){ _hashT fun size(this: Set) = _hashTable.size fun isEmpty(this: Set) = (_hashTable.size == 0) fun bucketCount(this: Set) = _hashTable.bucketCount - fun reserve(this: !Set, n: SizeType) { _hashTable.reserve(n); } + fun reserve(this: !Set, n: Int) { _hashTable.reserve(n); } fun all(this: Set) = _hashTable.all diff --git a/SparrowImplicitLib/std/sharedPtr.spr b/SparrowImplicitLib/std/sharedPtr.spr index 439639e4..8ecf9173 100644 --- a/SparrowImplicitLib/std/sharedPtr.spr +++ b/SparrowImplicitLib/std/sharedPtr.spr @@ -8,7 +8,7 @@ datatype SharedPtr(type: Type) using _MyAllocData = _AllocData(type) _ref: @ValueType - _count: @UInt + _count: @Int [protected] fun ctor(this: !SharedPtr) @@ -48,7 +48,7 @@ datatype SharedPtr(type: Type) fun get(this: SharedPtr): @ValueType = _ref fun isUnique(this: SharedPtr) = _count !== null && _count == 1 - fun useCount(this: SharedPtr): UInt = ife(_count !== null, UInt(_count), UInt(0)) + fun useCount(this: SharedPtr): Int = ife(_count !== null, Int(_count), 0) fun isNull(this: SharedPtr) = _ref === null fun isSet(this: SharedPtr) = _ref !== null @@ -62,7 +62,7 @@ datatype SharedPtr(type: Type) other._ref := _ref _ref := tmpr - let tmpc: @UInt = other._count + let tmpc: @Int = other._count other._count := _count _count := tmpc @@ -73,7 +73,7 @@ datatype SharedPtr(type: Type) os << "SharedPtr(null)" datatype _AllocData(type: Type) - _count: UInt + _count: Int data: type fun ctor(this: !_AllocData) diff --git a/SparrowImplicitLib/std/sortedMap.spr b/SparrowImplicitLib/std/sortedMap.spr index 8be375fd..329b6bf1 100644 --- a/SparrowImplicitLib/std/sortedMap.spr +++ b/SparrowImplicitLib/std/sortedMap.spr @@ -17,13 +17,13 @@ datatype SortedMap(keyType, dataType, lessType, compareType: Type) _sortedTable: _ImplTable [protected] - fun ctor(this: !SortedMap, n: SizeType) { _sortedTable.ctor(n, LessType(), CompareType()); } - fun ctor(this: !SortedMap, n: SizeType, less: this.LessType) { _sortedTable.ctor(n, less, CompareType()); } - fun ctor(this: !SortedMap, n: SizeType, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(n, less, comp); } + fun ctor(this: !SortedMap, n: Int) { _sortedTable.ctor(n, LessType(), CompareType()); } + fun ctor(this: !SortedMap, n: Int, less: this.LessType) { _sortedTable.ctor(n, less, CompareType()); } + fun ctor(this: !SortedMap, n: Int, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(n, less, comp); } fun ctor(this: !SortedMap, range: Range) { _sortedTable.ctor(range, 0, LessType(), CompareType()); } - fun ctor(this: !SortedMap, range: Range, n: SizeType) { _sortedTable.ctor(range, n, LessType(), CompareType()); } - fun ctor(this: !SortedMap, range: Range, n: SizeType, less: this.LessType) { _sortedTable.ctor(range, n, less, CompareType()); } - fun ctor(this: !SortedMap, range: Range, n: SizeType, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(range, n, less, comp); } + fun ctor(this: !SortedMap, range: Range, n: Int) { _sortedTable.ctor(range, n, LessType(), CompareType()); } + fun ctor(this: !SortedMap, range: Range, n: Int, less: this.LessType) { _sortedTable.ctor(range, n, less, CompareType()); } + fun ctor(this: !SortedMap, range: Range, n: Int, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(range, n, less, comp); } fun ctor(this: !SortedMap, other: typeOf(this)) { this._sortedTable ctor other._sortedTable; } fun lessFunction(this: SortedMap) = _sortedTable.lessFunction @@ -32,7 +32,7 @@ datatype SortedMap(keyType, dataType, lessType, compareType: Type) fun size(this: SortedMap) = _sortedTable.size() fun isEmpty(this: SortedMap) = _sortedTable.isEmpty() fun capacity(this: SortedMap) = _sortedTable.capacity - fun reserve(this: !SortedMap, n: SizeType) { _sortedTable.reserve(n); } + fun reserve(this: !SortedMap, n: Int) { _sortedTable.reserve(n); } fun all(this: SortedMap) = _sortedTable.all fun keys(this: SortedMap) = transform(_sortedTable.all, PairFirst(ValueType)()) diff --git a/SparrowImplicitLib/std/sortedSet.spr b/SparrowImplicitLib/std/sortedSet.spr index c8a5dcab..c8754d87 100644 --- a/SparrowImplicitLib/std/sortedSet.spr +++ b/SparrowImplicitLib/std/sortedSet.spr @@ -13,13 +13,13 @@ datatype SortedSet(keyType, lessType, compareType: Type) _sortedTable: _ImplTable [protected] - fun ctor(this: !SortedSet, n: SizeType) { _sortedTable.ctor(n, LessType(), CompareType()) } - fun ctor(this: !SortedSet, n: SizeType, less: this.LessType) { _sortedTable.ctor(n, less, CompareType()) } - fun ctor(this: !SortedSet, n: SizeType, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(n, less, comp) } + fun ctor(this: !SortedSet, n: Int) { _sortedTable.ctor(n, LessType(), CompareType()) } + fun ctor(this: !SortedSet, n: Int, less: this.LessType) { _sortedTable.ctor(n, less, CompareType()) } + fun ctor(this: !SortedSet, n: Int, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(n, less, comp) } fun ctor(this: !SortedSet, range: Range) { _sortedTable.ctor(range, 0, LessType(), CompareType()) } - fun ctor(this: !SortedSet, range: Range, n: SizeType) { _sortedTable.ctor(range, n, LessType(), CompareType()) } - fun ctor(this: !SortedSet, range: Range, n: SizeType, less: this.LessType) { _sortedTable.ctor(range, n, less, CompareType()) } - fun ctor(this: !SortedSet, range: Range, n: SizeType, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(range, n, less, comp) } + fun ctor(this: !SortedSet, range: Range, n: Int) { _sortedTable.ctor(range, n, LessType(), CompareType()) } + fun ctor(this: !SortedSet, range: Range, n: Int, less: this.LessType) { _sortedTable.ctor(range, n, less, CompareType()) } + fun ctor(this: !SortedSet, range: Range, n: Int, less: this.LessType, comp: this.CompareType) { _sortedTable.ctor(range, n, less, comp) } fun ctor(this: !SortedSet, other: SortedSet) { this._sortedTable ctor other._sortedTable } fun lessFunction(this: SortedSet) = _sortedTable.lessFunction @@ -28,7 +28,7 @@ datatype SortedSet(keyType, lessType, compareType: Type) fun size(this: SortedSet) = _sortedTable.size fun isEmpty(this: SortedSet) = _sortedTable.isEmpty fun capacity(this: SortedSet) = _sortedTable.capacity - fun reserve(this: !SortedSet, n: SizeType) { _sortedTable.reserve(n) } + fun reserve(this: !SortedSet, n: Int) { _sortedTable.reserve(n) } fun all(this: SortedSet) = _sortedTable.all diff --git a/SparrowImplicitLib/std/sortedTable.spr b/SparrowImplicitLib/std/sortedTable.spr index 805cb813..907779d9 100644 --- a/SparrowImplicitLib/std/sortedTable.spr +++ b/SparrowImplicitLib/std/sortedTable.spr @@ -20,7 +20,7 @@ datatype SortedTable(keyType, valueType, valueToKeyType, lessType, compareType: fun ctor(this: !SortedTable) this.ctor(0, LessType(), CompareType()) - fun ctor(this: !SortedTable, n: SizeType, less: this.LessType, comp: this.CompareType) + fun ctor(this: !SortedTable, n: Int, less: this.LessType, comp: this.CompareType) this._table ctor this._valToKey ctor this._less ctor less @@ -28,7 +28,7 @@ datatype SortedTable(keyType, valueType, valueToKeyType, lessType, compareType: if n > 0 this.reserve(n) - fun ctor(this: !SortedTable, range: Range, n: SizeType, less: this.LessType, comp: this.CompareType) + fun ctor(this: !SortedTable, range: Range, n: Int, less: this.LessType, comp: this.CompareType) this._table ctor if n > 0 _table.reserve(n) @@ -86,7 +86,7 @@ datatype SortedTable(keyType, valueType, valueToKeyType, lessType, compareType: fun all(this: SortedTable) = _table.all - fun reserve(this: !SortedTable, n: SizeType) + fun reserve(this: !SortedTable, n: Int) _table.reserve(n) fun insert(this: !SortedTable, value: this.ValueType): RangeType @@ -119,10 +119,10 @@ datatype SortedTable(keyType, valueType, valueToKeyType, lessType, compareType: _table.remove(range) fun contains(this: SortedTable, key: this.KeyType): Bool = !this.find(key).isEmpty - fun count(this: SortedTable, key: this.KeyType): SizeType = ife(this.find(key).isEmpty, 0, 1) + fun count(this: SortedTable, key: this.KeyType): Int = ife(this.find(key).isEmpty, 0, 1) fun lowerBound(this: SortedTable, key: this.KeyType): RangeType - var first: SizeType = 0 + var first = 0 var len = _table.size while len > 0 let l2 = len / 2 @@ -137,7 +137,7 @@ datatype SortedTable(keyType, valueType, valueToKeyType, lessType, compareType: return r fun upperBound(this: SortedTable, key: this.KeyType): RangeType - var first: SizeType = 0 + var first = 0 var len = _table.size while len > 0 let l2 = len / 2 diff --git a/SparrowImplicitLib/std/staticArray.spr b/SparrowImplicitLib/std/staticArray.spr index 2c312fb0..e675ddc4 100644 --- a/SparrowImplicitLib/std/staticArray.spr +++ b/SparrowImplicitLib/std/staticArray.spr @@ -5,7 +5,7 @@ import rawPtr(RawPtr) import ranges [noDefault] -datatype StaticArray(valueType: Type, arraySize: SizeType ct) +datatype StaticArray(valueType: Type, arraySize: Int ct) using ValueType = valueType using RangeType = ContiguousMemoryRange(valueType) using _arraySize = arraySize @@ -112,7 +112,7 @@ datatype StaticArray(valueType: Type, arraySize: SizeType ct) return false return true - fun size(this: StaticArray): SizeType + fun size(this: StaticArray): Int return _arraySize fun isEmpty(this: StaticArray): Bool @@ -132,13 +132,13 @@ datatype StaticArray(valueType: Type, arraySize: SizeType ct) this(i) = other(i) other(i) = tmp - fun at(this: StaticArray, index: SizeType): @ValueType = this._asPtr().advance(DiffType(index)).value - fun ()(this: StaticArray, index: SizeType): @ValueType = this._asPtr().advance(DiffType(index)).value + fun at(this: StaticArray, index: Int): @ValueType = this._asPtr().advance(index).value + fun ()(this: StaticArray, index: Int): @ValueType = this._asPtr().advance(index).value - fun all(this: StaticArray) = RangeType(this._asPtr, this._asPtr().advance(DiffType(_arraySize))) + fun all(this: StaticArray) = RangeType(this._asPtr, this._asPtr().advance(_arraySize)) - fun subrange(this: StaticArray, index: SizeType, num: SizeType) \ - = RangeType(this._asPtr().advance(DiffType(index)), this._asPtr().advance(DiffType(index + num))) + fun subrange(this: StaticArray, index: Int, num: Int) \ + = RangeType(this._asPtr().advance(index), this._asPtr().advance(index + num)) fun _asPtr(this: StaticArray) = RawPtr(ValueType)(UntypedPtr(_buf)) @@ -153,14 +153,14 @@ fun mkValues(v0,v1,v2,v3,v4,v5,v6,v7,v8: AnyType) = StaticArray(typeOf(v0), 9)(v fun mkValues(v0,v1,v2,v3,v4,v5,v6,v7,v8,v9: AnyType) = StaticArray(typeOf(v0), 10)(v0,v1,v2,v3,v4,v5,v6,v7,v8,v9) [ctGeneric] -fun StaticArray2d(baseType: Type, d1, d2: SizeType ct) \ +fun StaticArray2d(baseType: Type, d1, d2: Int ct) \ = StaticArray(StaticArray(baseType, d2), d1) [ctGeneric] -fun StaticArray3d(baseType: Type, d1, d2, d3: SizeType ct) \ +fun StaticArray3d(baseType: Type, d1, d2, d3: Int ct) \ = StaticArray(StaticArray(StaticArray(baseType, d3), d2), d1) [ctGeneric] -fun StaticArray4d(baseType: Type, d1, d2, d3, d4: SizeType ct) \ +fun StaticArray4d(baseType: Type, d1, d2, d3, d4: Int ct) \ = StaticArray(StaticArray(StaticArray(StaticArray(baseType, d4), d3), d2), d1) diff --git a/SparrowImplicitLib/std/string.spr b/SparrowImplicitLib/std/string.spr index aafee197..19f50f7e 100644 --- a/SparrowImplicitLib/std/string.spr +++ b/SparrowImplicitLib/std/string.spr @@ -15,7 +15,7 @@ datatype String using ValuePassType = Char using RangeType = StringRef - using _initialCapacity = SizeType(16) + using _initialCapacity = 16 using _growthFactor = 1.5 using _PtrType = RawPtr(Char) @@ -25,14 +25,14 @@ fun ctor(this: !String) _begin ctor _end ctor _endOfStore ctor -fun ctor(this: !String, size: SizeType) +fun ctor(this: !String, size: Int) _begin ctor allocRawPtr(Char, size+1) - _end ctor _begin.advance(DiffType(size)) + _end ctor _begin.advance(size) _endOfStore ctor _end _end.value = Char(0) -fun ctor(this: !String, count: SizeType, ch: Char) +fun ctor(this: !String, count: Int, ch: Char) this.ctor(count) - memset(_begin.untypedPtr, Byte(ch), count) + memset(_begin.untypedPtr, Int8(ch), count) fun ctor(this: !String, other: String) let size = other size this.ctor(size) @@ -50,7 +50,7 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String this.ctor(rangeSize(range)) var i=0 for ch = range - _begin.advance(DiffType(i++)).value = ch + _begin.advance(i++).value = ch [protected] fun ctorFromCt(this: !String, src: String ct) @@ -68,7 +68,7 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String if this.size != other.size return false - var i: SizeType = 0 + var i = 0 let s = this.size while i < s ; i++ @@ -85,17 +85,17 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String fun asStringRef(this: String) = StringRef(_begin.untypedPtr, _end.untypedPtr) - fun size(this: String): SizeType = _end.diff(_begin) + fun size(this: String): Int = _end.diff(_begin) fun isEmpty(this: String) = _begin == _end - fun capacity(this: String): SizeType = _endOfStore.diff(_begin) + fun capacity(this: String): Int = _endOfStore.diff(_begin) - fun at(this: String, index: SizeType) = _begin.advance(DiffType(index)).value - fun ()(this: String, index: SizeType) = _begin.advance(DiffType(index)).value + fun at(this: String, index: Int) = _begin.advance(index).value + fun ()(this: String, index: Int) = _begin.advance(index).value fun front(this: String) = _begin.value fun back(this: String) = _end.advance(-1).value fun all(this: String) = StringRef(_begin.untypedPtr, _end.untypedPtr) - fun subrange(this: String, index: SizeType, num: SizeType): StringRef \ - = StringRef(_begin.advance(DiffType(index)).untypedPtr, _begin.advance(DiffType(index + num)).untypedPtr) + fun subrange(this: String, index: Int, num: Int): StringRef \ + = StringRef(_begin.advance(index).untypedPtr, _begin.advance(index + num).untypedPtr) fun pushBack(this: !String, value: Char) if _end == _endOfStore @@ -113,14 +113,14 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String _end = _end advance -1 _end.value dtor - fun resize(this: !String, n: SizeType) + fun resize(this: !String, n: Int) let oldSize = this.size if n == oldSize return if n < oldSize - let newEnd = _begin.advance(DiffType(n)) + let newEnd = _begin.advance(n) while _end != newEnd _end = _end.advance(-1) @@ -128,13 +128,13 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String else this.reserve(n) - let newEnd = _begin.advance(DiffType(n)) + let newEnd = _begin.advance(n) while _end != newEnd _end.value ctor _end = _end.advance - fun reserve(this: !String, n: SizeType) + fun reserve(this: !String, n: Int) let curCapacity = this.capacity if n <= curCapacity @@ -142,14 +142,14 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String if n < _initialCapacity n = _initialCapacity - if n <_growthFactor*curCapacity - n = SizeType(_growthFactor*curCapacity) + if n < Int(_growthFactor*Float(curCapacity)) + n = Int(_growthFactor*Float(curCapacity)) let curSize = this.size _begin.reallocPtr(n) - _end = _begin.advance(DiffType(curSize)) - _endOfStore = _begin.advance(DiffType(n)) + _end = _begin.advance(curSize) + _endOfStore = _begin.advance(n) fun clear(this: !String) this.remove(StringRef(_begin.untypedPtr, _end.untypedPtr)) @@ -160,7 +160,7 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String this.reserve(this.size + 1) var p = _end.advance(-1) - var q = _begin.advance(posCount - DiffType(1)) + var q = _begin.advance(posCount - 1) while p != q ; p = p.advance(-1) p.advance().value ctor p.value @@ -176,17 +176,17 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String this.reserve(this.size + n) var p = _end.advance(-1) - let q = _begin.advance(index - DiffType(1)) + let q = _begin.advance(index - 1) while p != q ; p = p.advance(-1) - p.advance(DiffType(n)).value ctor p.value + p.advance(n).value ctor p.value p.value dtor p = p.advance while !rc.isEmpty p.value ctor rc.front p = p.advance rc.popFront - _end = _end.advance(DiffType(n)) + _end = _end.advance(n) fun insertAfter(this: !String, value: Char, pos: StringRef) this.insertBefore(value, StringRef(_backPtr(pos).untypedPtr, _end.untypedPtr)) @@ -202,7 +202,7 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String fun remove(this: !String, range: StringRef) let rSize = range.size var rBegin = _frontPtr(range) - let rEnd = rBegin.advance(DiffType(rSize)) + let rEnd = rBegin.advance(rSize) while rEnd != _end rBegin.value dtor @@ -211,7 +211,7 @@ fun ctor(this: !String, range: Range) if typeOf(range) != String rEnd = rEnd.advance _end = rBegin - fun remove(this: !String, index: SizeType) + fun remove(this: !String, index: Int) var r = this.all r.popFront(index) @@ -252,7 +252,7 @@ fun intToString(x: Int): String var buf: static_buffer(12) _intToCString(x, reinterpretCast(@Char, buf)) return String(fromCString(reinterpretCast(@Char, buf))) -fun ulongToString(x: ULong): String +fun ulongToString(x: UInt64): String var buf: static_buffer(16) _ulongToCString(x, reinterpretCast(@Char, buf)) return String(fromCString(reinterpretCast(@Char, buf))) @@ -266,9 +266,12 @@ datatype StringOutputStream fun <<<(this: !StringOutputStream, s: String) { result.append(s.all) } fun <<<(this: !StringOutputStream, s: StringRef) { result.append(s) } fun <<<(this: !StringOutputStream, x: Char) { result.append(x) } - fun <<<(this: !StringOutputStream, x: Int) { result.append(intToString(x).all) } - fun <<<(this: !StringOutputStream, x: ULong) { result.append(ulongToString(x).all) } - fun <<<(this: !StringOutputStream, x: Double) { result.append(ulongToString(ULong(x)).all) } // Not properly supported + fun <<<(this: !StringOutputStream, x: Int32) { result.append(intToString(x).all) } + fun <<<(this: !StringOutputStream, x: UInt32) { result.append(ulongToString(UInt64(x)).all) } + fun <<<(this: !StringOutputStream, x: Int64) { result.append(ulongToString(UInt64(x)).all) } + fun <<<(this: !StringOutputStream, x: UInt64) { result.append(ulongToString(UInt64(x)).all) } + fun <<<(this: !StringOutputStream, x: Float32) { result.append(ulongToString(UInt64(x)).all) } // Not properly supported + fun <<<(this: !StringOutputStream, x: Float) { result.append(ulongToString(UInt64(x)).all) } // Not properly supported fun toString = String() fun toString(a1: AnyType): String @@ -301,4 +304,4 @@ fun toString(a1, a2, a3, a4, a5, a6, a7: AnyType): String return s.result [native("_Int_to_CString")] fun _intToCString(x: Int, buffer: @Char) -[native("_ULong_to_CString")] fun _ulongToCString(x: ULong, buffer: @Char) +[native("_ULong_to_CString")] fun _ulongToCString(x: UInt64, buffer: @Char) diff --git a/SparrowImplicitLib/std/tuple.spr b/SparrowImplicitLib/std/tuple.spr index 762cb490..a4e1afab 100644 --- a/SparrowImplicitLib/std/tuple.spr +++ b/SparrowImplicitLib/std/tuple.spr @@ -152,15 +152,13 @@ datatype PairFirst(pairType: Type) using PairType = pairType [protected] - fun ()(this: PairFirst, pair: this.PairType): @typeOf(pair.v1) - return pair.v1 + fun ()(this: PairFirst, pair: this.PairType) = pair.v1 datatype PairSecond(pairType: Type) using PairType = pairType [protected] - fun ()(this: PairSecond, pair: this.PairType): @typeOf(pair.v2) - return pair.v2 + fun ()(this: PairSecond, pair: this.PairType) = pair.v2 fun _dumpTail(t: TupleType, os: !OutStream) if t.arity == 2 os << ',' << t.v2 diff --git a/SparrowImplicitLib/std/typeTraits.spr b/SparrowImplicitLib/std/typeTraits.spr index e31e673a..8b55eeea 100644 --- a/SparrowImplicitLib/std/typeTraits.spr +++ b/SparrowImplicitLib/std/typeTraits.spr @@ -8,11 +8,11 @@ datatype DefaultTypeTraits [protected] fun equal(this: DefaultTypeTraits, l, r: AnyType) = l == r fun less(this: DefaultTypeTraits, l, r: AnyType) = l < r - fun hash(this: DefaultTypeTraits, val: AnyType): SizeType - [ct] if ( isValid(SizeType(val hash)) ) - return val hash - else [ct] if ( isValid(SizeType(val.get hash)) ) - return val.get hash + fun hash(this: DefaultTypeTraits, val: AnyType): UInt64 + [ct] if ( isValid(UInt64(val hash)) ) + return UInt64(val hash) + else [ct] if ( isValid(UInt64(val.get hash)) ) + return UInt64(val.get hash) else return defaultHash(val) diff --git a/SparrowImplicitLib/std/union.spr b/SparrowImplicitLib/std/union.spr index b8c23d29..e4712e51 100644 --- a/SparrowImplicitLib/std/union.spr +++ b/SparrowImplicitLib/std/union.spr @@ -3,7 +3,7 @@ module std.union import std.staticArray [ct] -fun _max(value1, value2: SizeType): SizeType +fun _max(value1, value2: Int): Int if value1 < value2 return value2 return value1 diff --git a/SparrowImplicitLib/std/vector.spr b/SparrowImplicitLib/std/vector.spr index bcbb4382..f552210b 100644 --- a/SparrowImplicitLib/std/vector.spr +++ b/SparrowImplicitLib/std/vector.spr @@ -41,7 +41,7 @@ datatype Vector(valueType: Type) dst = dst.advance() src = src.advance() - fun ctor(this: !Vector, size: SizeType) + fun ctor(this: !Vector, size: Int) // Allocate the buffer _begin = allocRawPtr(ValueType, size) _end = _begin.advance(size) @@ -107,11 +107,11 @@ datatype Vector(valueType: Type) _endOfStore = other._endOfStore other._endOfStore = tmp - fun size(this: Vector): SizeType = _end.diff(_begin) + fun size(this: Vector): Int = _end.diff(_begin) fun isEmpty(this: Vector) = _begin == _end - fun capacity(this: Vector): SizeType = _endOfStore.diff(_begin) + fun capacity(this: Vector): Int = _endOfStore.diff(_begin) - fun reserve(this: !Vector, n: SizeType) + fun reserve(this: !Vector, n: Int) let curCapacity = this.capacity() if n <= curCapacity @@ -119,8 +119,8 @@ datatype Vector(valueType: Type) if n < _initialCapacity n = _initialCapacity - if n < _growthFactor*curCapacity - n = SizeType(_growthFactor*curCapacity) + if n < Int(_growthFactor*Float(curCapacity)) + n = Int(_growthFactor*Float(curCapacity)) let curSize = this.size() @@ -128,13 +128,13 @@ datatype Vector(valueType: Type) _end = _begin.advance(curSize) _endOfStore = _begin.advance(n) - fun at(this: Vector, index: SizeType) = _begin.advance(index).value() - fun ()(this: Vector, index: SizeType) = _begin.advance(index).value() + fun at(this: Vector, index: Int) = _begin.advance(index).value() + fun ()(this: Vector, index: Int) = _begin.advance(index).value() fun front(this: Vector) = _begin.value() fun back(this: Vector) = _end.advance(-1).value() fun all(this: Vector) = RangeType(_begin, _end) - fun subrange(this: Vector, index: SizeType, num: SizeType): RangeType = RangeType(_begin.advance(index), _begin.advance(index + num)) - fun subrange(this: Vector, index: SizeType): RangeType = RangeType(_begin.advance(index), _end) + fun subrange(this: Vector, index: Int, num: Int): RangeType = RangeType(_begin.advance(index), _begin.advance(index + num)) + fun subrange(this: Vector, index: Int): RangeType = RangeType(_begin.advance(index), _end) fun insertBefore(this: !Vector, value: this.ValueType, pos: this.RangeType) let posCount = pos.frontPtr().diff(_begin) @@ -209,14 +209,14 @@ datatype Vector(valueType: Type) rEnd = rEnd.advance() _end = rBegin - fun remove(this: !Vector, index: SizeType) + fun remove(this: !Vector, index: Int) var r = this.all() r.popFront(index) r.popBack(this.size() - index - 1) this.remove(r) - fun resize(this: !Vector, n: SizeType) + fun resize(this: !Vector, n: Int) let oldSize = this.size() if n == oldSize diff --git a/SparrowImplicitLib/time.spr b/SparrowImplicitLib/time.spr index ef8f3f45..3da07d16 100644 --- a/SparrowImplicitLib/time.spr +++ b/SparrowImplicitLib/time.spr @@ -1,11 +1,11 @@ module time -[native("clock")] fun clock: Int +[native("clock")] fun clock: Int32 datatype Timer - _startTime: Int + _startTime: Int32 fun ctor(this: !Timer) { _startTime = clock } -fun elapsed(this: Timer) = Double(clock - _startTime) / 1000.0 +fun elapsed(this: Timer) = Float(clock - _startTime) / 1000.0 fun restart(this: !Timer) { _startTime = clock } diff --git a/docs/lang/declarations.rst b/docs/lang/declarations.rst index 14ca3b7a..c7f59d2f 100644 --- a/docs/lang/declarations.rst +++ b/docs/lang/declarations.rst @@ -119,7 +119,7 @@ There are two main forms of declaring datatypes: an explicit one, and a simple o datatype MyType x: Int - y: Double + y: Float name: String using BaseType = Int @@ -129,7 +129,7 @@ The simple form of declaring datatypes is illustrated by the following example: :: datatype Type1 = Int - datatype Type2 = Int*Double // Pair of Int & Double + datatype Type2 = Int*Float // Pair of Int & Float This is a shortcut for the following code: :: @@ -137,7 +137,7 @@ This is a shortcut for the following code: datatype Type1 data: Int datatype Type2 - data: Int*Double + data: Int*Float In addition to this, the compiler will also generate a constructor that can covert the type given after ``=`` to the new type. diff --git a/docs/lang/modifiers.rst b/docs/lang/modifiers.rst index 50e577ec..cecddce0 100644 --- a/docs/lang/modifiers.rst +++ b/docs/lang/modifiers.rst @@ -94,10 +94,10 @@ Semantics [ct] fun addRef(t: Type): Type // function is available only at compile-time [ct] - if sizeOf(t) <= sizeOf(Int) - var storage: Int + if sizeOf(t) <= sizeOf(Int32) + var storage: Int32 else - var storage: Long + var storage: Int64 // Depending on the size of 't', this will create different 'storage' variables [ct] diff --git a/docs/lang/operators.rst b/docs/lang/operators.rst index 62d4b701..ff4c5d99 100644 --- a/docs/lang/operators.rst +++ b/docs/lang/operators.rst @@ -77,7 +77,7 @@ Defining operators Defining an operator is identical to defining a regular function. Example: :: - datatype Complex {re, im: Double} + datatype Complex {re, im: Float} fun + (x, y: Complex) = Complex(x.re+y.re, x.im+y.im) fun - (x: Complex) = Complex(-x.re, -x.im) @@ -208,7 +208,7 @@ Whenever the compiler needs to know the associativity of an operator ```` it Example of using precedence and associativity for a new operator: :: - fun **(x, y: Double) = Math.pow(x, y) + fun **(x, y: Float) = Math.pow(x, y) using oper_precedence_** = 1 + oper_precedence_* // higher precedence than multiplication using oper_assoc_** = -1 // right associativity diff --git a/docs/tut/beginnerIntoToSparrow.rst b/docs/tut/beginnerIntoToSparrow.rst index e7e68868..9c2447d1 100644 --- a/docs/tut/beginnerIntoToSparrow.rst +++ b/docs/tut/beginnerIntoToSparrow.rst @@ -64,7 +64,7 @@ An important concept of imperative programming languages is the variable. A vari var m: Int = 15 var f: Float = 0.3 var greet = "Hello, world!" - var k: Long + var k: Int64 var p1, p2, p3: String When declaring a variable one needs to supply the name of the new variable (or variables), an optional type, and an optional initial value. It is not possible to have a variable definition that lacks both the type and the initial value. If the variable receives an initial value without a type, the type of the value will be taken from the initializer. If the variable does not have an initial value, the variable will be *default constructed* (more precisely, the default constructor will be called for the variable); this assures that the variable is initialized. @@ -104,36 +104,15 @@ Basic types In Sparrow, any value, variable, or expression needs to have a well defined type. A type determines the way a value can be encoded in the system's memory and what operations are valid for that variable. -The standard library defines a series of integer types: ``Byte``, ``UByte``, ``Short``, ``UShort``, ``Int``, ``UInt``, ``Long`` and ``ULong`` of sizes 8, 16, 32 and 64 bits, signed and unsigned. Two additional integer types are defined to contain at least as many bits as a pointer: ``SizeType`` and ``DiffType``; the first one is unsigned and the second one is a signed type. To represent floating point numbers, the language defines the types ``Float`` (32 bits) and ``Double`` (64 bits). +The standard library defines ``Int`` as the main type to be used for storing signed integers; it has 32 bits. For better control, it also defines ``Int8``, ``UInt8``, ``Int16``, ``UInt16``, ``Int32``, ``UInt32``, ``Int64``, ``UInt64``; as their name implies, these cover both signed and unsigned, of sizez 8, 16, 32 and 64 bit. ``Int`` and ``Int32`` are aliases. + +To represent floating point numbers, the language defines the type ``Float``; this is 64 bit. For better control, the language also defines ``Float32`` and ``Float64``. In this case too, ``Float`` is an alias to ``Float64``. To represent booleans the language defines the ``Bool`` type. To represent characters we have the ``Char`` type. In Sparrow, strings use UTF-8 encoding, so setting the ``Char`` to 8 bits is an obvious choice. In the most basic form, strings can be represented as a ``StringRef`` type. This just refers to the string, but does not hold ownership of the string data. To use a string with ownership of data, one can use the ``String`` type. String literals have the type ``StringRef``, but there is an implicit conversion between a ``StringRef`` and ``String``. -Certain implicit conversions (called *type coercions*) can be made between these types. An integer type can always be converted into an integer type of a larger size. An unsigned type can be converted into a signed type of the same size, and vice-versa. Any integer type can be implicitly converted into a floating point type. - -Here are some implicit conversion examples: - -:: - - var b: Byte = 1 - var ub: UByte = 2 - var i: Int = 3 - var ui: UInt = 4 - var l: Long = 5 - var f: Float = 3.14f - var d: Double = 3.14159265359 - - i = b // OK: Byte -> Int - i = ub // OK: UByte -> Int - ui = i // OK: Int -> UInt - i = ui // OK: UInt -> Int - // b = i // ERROR: cannot convert wider to narrower type - f = l // OK: Long -> Float - d = b // OK: Byte -> Double - - -Note that some of these conversions can loose precision (e.g., large integers to floating points), and sometimes can even dramatically change the actual value (negative number to unsigned or large number to signed). The user must be careful when performing such conversions. As the benefits provided by these conversions are typically more significant than the drawbacks, they are allowed. +Sparrow does not allow implicit conversion (called *type coercions*) between numeric types. However, explicit conversions can be made between any numeric types. With the assumption that most of the times ``Int`` will be used for integers and ``Float`` for floating-points, having implicit conversions has more downsides than positives. References ---------- @@ -291,7 +270,7 @@ So far, we have shown function definitions that operate on concrete data types. fun sum(x, y: Numeric) = x+y; -The ``Numeric`` name refers to a *concept* defined in the standard library that accepts any numeric type (e.g., ``Int``, ``ULong``, ``Double``). +The ``Numeric`` name refers to a *concept* defined in the standard library that accepts any numeric type (e.g., ``Int``, ``UInt64``, ``Float``). There is a special concept in Sparrow called ``AnyType`` that is compatible with any type. Here is an example of a function that prints to the console the value given as parameter: @@ -301,10 +280,10 @@ There is a special concept in Sparrow called ``AnyType`` that is compatible with cout << x << endl writeLn(10); // prints an Int value - writeLn(3.14); // prints a Double value + writeLn(3.14); // prints a Float value writeLn("Pretty cool, huh?"); // prints a StringRef value -Both the ``sum`` function above and this ``writeLn`` function are generics, template functions, just like C++ template functions. This means, that the compiler will actually generate three ``writeLn`` functions for the three instantiations shown here: one with a ``Int`` parameter, one with a ``Double`` parameter, and one with a ``StringRef`` parameter. All these three functions will be compiled independently of each other. +Both the ``sum`` function above and this ``writeLn`` function are generics, template functions, just like C++ template functions. This means, that the compiler will actually generate three ``writeLn`` functions for the three instantiations shown here: one with a ``Int`` parameter, one with a ``Float`` parameter, and one with a ``StringRef`` parameter. All these three functions will be compiled independently of each other. In cases where all parameters are ``AnyType``, the parentheses and the type specifications can be omitted: @@ -378,7 +357,7 @@ Defining an operator is very similar to defining a function. Here is an example :: - fun **(x: Double, p: Int): Double + fun **(x: Float, p: Int): Float var res = 1.0 for i = 0..p res *= x @@ -568,15 +547,15 @@ All the parameters to a datatype need to be compile-time. For example, a datatyp :: - var p1: Pair(Int, Float) // call default constructor - var p2 = Pair(Int, Double)(1, 3.14) // call initialization constructor + var p1: Pair(Int, Float32) // call default constructor + var p2 = Pair(Int, Float)(1, 3.14) // call initialization constructor p1.first = 10 p1.second = 2.34 cout << "(" << p2.first << ", " << p2.second << ")" << endl On the first line we are telling the compiler that ``t1`` is ``Int`` and ``t2`` is ``Float``, and we ask it to instantiate a ``Pair`` with these two types. This is not a constructor call, it's a generic instantiation. -On the second line, we ask the compiler to generate another type, one that is parameterized with valued ``Int`` and ``Double``. But this, time, after specifying the parameter values for the generic, we are specifying arguments for a constructor call (``1`` and ``3.14``). +On the second line, we ask the compiler to generate another type, one that is parameterized with valued ``Int`` and ``Float32``. But this, time, after specifying the parameter values for the generic, we are specifying arguments for a constructor call (``1`` and ``3.14``). In our case, we haven't manually created a constructor associated with our generic datatype. But, we specified the ``[initCtor]`` modifier. This will tell the compiler to generate a constructor withe the right number of parameters to initialize all the fields. diff --git a/src/Feather/Utils/FeatherUtils.h b/src/Feather/Utils/FeatherUtils.h index f8210e07..c24b78dd 100644 --- a/src/Feather/Utils/FeatherUtils.h +++ b/src/Feather/Utils/FeatherUtils.h @@ -62,6 +62,7 @@ extern const char* propEvalMode; extern const char* propResultingDecl; extern const char* propNoInline; extern const char* propEmptyBody; ///< Node will not generate meaningful instructions +extern const char* propTypeCat; /// Getter for the class that introduces this data type - can be null /// Works for only for storage types (data-like and array) diff --git a/src/Feather/Utils/cppif/FeatherNodes.hpp b/src/Feather/Utils/cppif/FeatherNodes.hpp index 61e18402..e24faaa3 100644 --- a/src/Feather/Utils/cppif/FeatherNodes.hpp +++ b/src/Feather/Utils/cppif/FeatherNodes.hpp @@ -604,10 +604,14 @@ struct VarRefExp : NodeHandle { * * @param[in] loc The location of the node * @param[in] varDecl The declaration of the variable we are referring to + * @param[in] typeCat The category to apply to the type (optional) + * + * If the category type is given, it needs to be a type kind value. + * If it's not given, mutable will be assumed. * * @return The desired variable ref node */ - static VarRefExp create(const Location& loc, VarDecl varDecl); + static VarRefExp create(const Location& loc, VarDecl varDecl, int typeCat = 0); //! Get the variable declaration that this wants to access VarDecl varDecl() const; diff --git a/src/Feather/Utils/cppif/FeatherTypes.hpp b/src/Feather/Utils/cppif/FeatherTypes.hpp index f5299743..92920b12 100644 --- a/src/Feather/Utils/cppif/FeatherTypes.hpp +++ b/src/Feather/Utils/cppif/FeatherTypes.hpp @@ -318,4 +318,19 @@ TypeWithStorage removeCategoryIfPresent(TypeWithStorage type); */ Type categoryToRefIfPresent(Type type); +/** + * @brief Change the category of the given type + * + * @param[in] type The type to change the category for + * @param[in] newCatKind The kind representing the new category + * + * @return The type with the category changed. + * + * The @a newCatKind must match a category type. + * The given type must have at least one reference. + * + * The resulting type will have the same number of references as the original type. + */ +TypeWithStorage changeCat(TypeWithStorage type, int newCatKind); + } // namespace Feather diff --git a/src/Feather/src/Utils/FeatherUtils.c b/src/Feather/src/Utils/FeatherUtils.c index 40de2d66..6f52ac49 100644 --- a/src/Feather/src/Utils/FeatherUtils.c +++ b/src/Feather/src/Utils/FeatherUtils.c @@ -15,6 +15,7 @@ const char* propEvalMode = "evalMode"; const char* propResultingDecl = "resultingDecl"; const char* propNoInline = "noInline"; const char* propEmptyBody = "emptyBody"; +const char* propTypeCat = "typeCat"; /// Tests if the given node is a declaration (a node that will expand to a Feather declaration) int _isDecl(Nest_Node* node) { diff --git a/src/Feather/src/Utils/cppif/FeatherNodes.cpp b/src/Feather/src/Utils/cppif/FeatherNodes.cpp index bb5594e1..4d34fcdb 100644 --- a/src/Feather/src/Utils/cppif/FeatherNodes.cpp +++ b/src/Feather/src/Utils/cppif/FeatherNodes.cpp @@ -692,11 +692,13 @@ const char* NullExp::toStringImpl(NullExp node) { } DEFINE_NODE_COMMON_IMPL(VarRefExp, NodeHandle); -VarRefExp VarRefExp::create(const Location& loc, VarDecl varDecl) { +VarRefExp VarRefExp::create(const Location& loc, VarDecl varDecl, int typeCat) { REQUIRE_NODE(loc, varDecl); VarRefExp res = createNode(loc); res.setReferredNodes(NodeRange{varDecl}); + if (typeCat != 0) + res.setProperty(propTypeCat, typeCat); return res; } VarDecl VarRefExp::varDecl() const { return {referredNodes()[0]}; } @@ -713,8 +715,15 @@ NodeHandle VarRefExp::semanticCheckImpl(VarRefExp node) { nullptr, node.location(), "Variable type doesn't have a storage type (type: %1%)") % var.type(); TypeWithStorage t = var.type(); - if (!Feather::isCategoryType(t)) - t = MutableType::get(t); + int typeCat = node.getPropertyDefaultInt(propTypeCat, 0); + if (!Feather::isCategoryType(t)) { + if (typeCat == typeKindTemp) + t = TempType::get(t); + else if (typeCat == typeKindConst) + t = ConstType::get(t); + else + t = MutableType::get(t); + } node.setType(Feather_adjustMode(t, node.context(), node.location())); Feather_checkEvalModeWithExpected(node, var.type().mode()); return node; diff --git a/src/Feather/src/Utils/cppif/FeatherTypes.cpp b/src/Feather/src/Utils/cppif/FeatherTypes.cpp index e1219586..55a167c3 100644 --- a/src/Feather/src/Utils/cppif/FeatherTypes.cpp +++ b/src/Feather/src/Utils/cppif/FeatherTypes.cpp @@ -216,4 +216,29 @@ Type categoryToRefIfPresent(Type type) { return type; } +TypeWithStorage changeCat(TypeWithStorage type, int newCatKind) { + if (!type) + REP_INTERNAL(NOLOC, "Null type passed to changeCat"); + if (type.numReferences() < 1) + REP_INTERNAL(NOLOC, "Cannot change cat of non-reference type %1%") % type; + + int baseKind = type.kind(); + if (baseKind != typeKindData && baseKind != typeKindConst && baseKind != typeKindMutable && + baseKind != typeKindTemp) + REP_INTERNAL(NOLOC, "Invalid type given to change category: %1%") % type; + + TypeWithStorage base = + DataType::get(type.referredNode(), type.numReferences() - 1, type.mode()); + + if (newCatKind == typeKindConst) + return ConstType::get(base); + else if (newCatKind == typeKindMutable) + return MutableType::get(base); + else if (newCatKind == typeKindTemp) + return TempType::get(base); + + REP_INTERNAL(NOLOC, "Invalid type kind given when changing category(%1%)") % newCatKind; + return {}; +} + } // namespace Feather diff --git a/src/Nest/src/Api/Compiler.cpp b/src/Nest/src/Api/Compiler.cpp index dde73de6..534a8107 100644 --- a/src/Nest/src/Api/Compiler.cpp +++ b/src/Nest/src/Api/Compiler.cpp @@ -178,20 +178,22 @@ Nest_SourceCode* _handleImport(const ImportInfo& import) { } } - // Test to see if the file is relative to some of the import paths - for (const string& importPath : _settings.importPaths_) { - ImportInfo importRel = import; - importRel.filename_ = path(importPath) / p; - res = _handleImportFile(importRel); - if (res.first) - return res.second; - } - // Test to see if the file is relative to the current path ImportInfo importRel = import; importRel.filename_ = _curPath / p; res = _handleImportFile(importRel); + // Test to see if the file is relative to some of the import paths + if (!res.first) { + for (const string& importPath : _settings.importPaths_) { + ImportInfo importRel = import; + importRel.filename_ = path(importPath) / p; + res = _handleImportFile(importRel); + if (res.first) + return res.second; + } + } + if (!res.first) REP_ERROR(NOLOC, "Cannot find input file: %1%") % import.filename_.string(); return res.second; diff --git a/src/SparrowFrontend/Grammar/ext.spr b/src/SparrowFrontend/Grammar/ext.spr index 6f10cae5..bbfd0cf9 100644 --- a/src/SparrowFrontend/Grammar/ext.spr +++ b/src/SparrowFrontend/Grammar/ext.spr @@ -21,7 +21,7 @@ datatype CharSource readCharsFn: FunctionPtr(VoidType, UntypedPtr, !String, Int) concept CharSourceType(x) \ - if isValid(x.readChars(StringRef(), 0)) + if isValid(TypeOp.copyVal(x).readChars(tmpToMut(String()), 0)) fun mkCharSource(obj: !CharSourceType): CharSource var res: CharSource @@ -87,11 +87,11 @@ datatype AstBuilder mkNullLiteralFn: FunctionPtr(Node, UntypedPtr, Location const) mkBoolLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Bool) mkIntLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Int) - mkUIntLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, UInt) - mkLongLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Long) - mkULongLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, ULong) - mkFloatLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Float) - mkDoubleLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Double) + mkUIntLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, UInt32) + mkLongLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Int64) + mkULongLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, UInt64) + mkFloatLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Float32) + mkDoubleLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Float) mkCharLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, Char) mkStringLiteralFn: FunctionPtr(Node, UntypedPtr, Location const, StringRef) @@ -207,15 +207,15 @@ fun mkBoolLiteral(obj: !AstBuilder, loc: Location, val: Bool): Node return obj.mkBoolLiteralFn(obj.userData, loc, val) fun mkIntLiteral(obj: !AstBuilder, loc: Location, val: Int): Node return obj.mkIntLiteralFn(obj.userData, loc, val) -fun mkUIntLiteral(obj: !AstBuilder, loc: Location, val: UInt): Node +fun mkUIntLiteral(obj: !AstBuilder, loc: Location, val: UInt32): Node return obj.mkUIntLiteralFn(obj.userData, loc, val) -fun mkLongLiteral(obj: !AstBuilder, loc: Location, val: Long): Node +fun mkLongLiteral(obj: !AstBuilder, loc: Location, val: Int64): Node return obj.mkLongLiteralFn(obj.userData, loc, val) -fun mkULongLiteral(obj: !AstBuilder, loc: Location, val: ULong): Node +fun mkULongLiteral(obj: !AstBuilder, loc: Location, val: UInt64): Node return obj.mkULongLiteralFn(obj.userData, loc, val) -fun mkFloatLiteral(obj: !AstBuilder, loc: Location, val: Float): Node +fun mkFloatLiteral(obj: !AstBuilder, loc: Location, val: Float32): Node return obj.mkFloatLiteralFn(obj.userData, loc, val) -fun mkDoubleLiteral(obj: !AstBuilder, loc: Location, val: Double): Node +fun mkDoubleLiteral(obj: !AstBuilder, loc: Location, val: Float): Node return obj.mkDoubleLiteralFn(obj.userData, loc, val) fun mkCharLiteral(obj: !AstBuilder, loc: Location, val: Char): Node return obj.mkCharLiteralFn(obj.userData, loc, val) diff --git a/src/SparrowFrontend/Grammar/layoutDecoder.spr b/src/SparrowFrontend/Grammar/layoutDecoder.spr index c8e6ce94..8181e82b 100644 --- a/src/SparrowFrontend/Grammar/layoutDecoder.spr +++ b/src/SparrowFrontend/Grammar/layoutDecoder.spr @@ -29,7 +29,7 @@ datatype SparrowLayoutDecoder(tokensRangeType: Type) \ /// Object used to report errors _errorReporter: ErrorReporter /// The vector containing the current indents levels - _indents: UInt Vector + _indents: Int Vector /// The vector of currently open parenthesis and brackets _parens: Char Vector /// Indicates what and how many tokens we should inject in the stream diff --git a/src/SparrowFrontend/Grammar/parser.spr b/src/SparrowFrontend/Grammar/parser.spr index 5bc13ac3..7879e8f0 100644 --- a/src/SparrowFrontend/Grammar/parser.spr +++ b/src/SparrowFrontend/Grammar/parser.spr @@ -571,15 +571,15 @@ package _Impl else if this accept tkINT_LITERAL res = _astBuilder.mkIntLiteral(_lastToken.loc, Int(_lastToken.intData)) else if this accept tkUINT_LITERAL - res = _astBuilder.mkUIntLiteral(_lastToken.loc, UInt(_lastToken.intData)) + res = _astBuilder.mkUIntLiteral(_lastToken.loc, UInt32(_lastToken.intData)) else if this accept tkLONG_LITERAL - res = _astBuilder.mkLongLiteral(_lastToken.loc, Long(_lastToken.intData)) + res = _astBuilder.mkLongLiteral(_lastToken.loc, Int64(_lastToken.intData)) else if this accept tkULONG_LITERAL - res = _astBuilder.mkULongLiteral(_lastToken.loc, ULong(_lastToken.intData)) + res = _astBuilder.mkULongLiteral(_lastToken.loc, UInt64(_lastToken.intData)) else if this accept tkFLOAT_LITERAL - res = _astBuilder.mkFloatLiteral(_lastToken.loc, Float(_lastToken.floatData)) + res = _astBuilder.mkFloatLiteral(_lastToken.loc, Float32(_lastToken.floatData)) else if this accept tkDOUBLE_LITERAL - res = _astBuilder.mkDoubleLiteral(_lastToken.loc, Double(_lastToken.floatData)) + res = _astBuilder.mkDoubleLiteral(_lastToken.loc, Float64(_lastToken.floatData)) else if this accept tkCHAR_LITERAL res = _astBuilder.mkCharLiteral(_lastToken.loc, _lastToken.data(0)) else if this accept tkSTRING_LITERAL diff --git a/src/SparrowFrontend/Grammar/parserIf.ll b/src/SparrowFrontend/Grammar/parserIf.ll index dd795850..36b664f0 100644 --- a/src/SparrowFrontend/Grammar/parserIf.ll +++ b/src/SparrowFrontend/Grammar/parserIf.ll @@ -31,15 +31,15 @@ target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" %TokenType = type { i32 } %ErrorReporter = type { %UntypedPtr, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]" } %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]" = type { %UntypedPtr } -%"SparrowLayoutDecoder[SparrowScanner]" = type { %"RangeWithLookahead[SparrowScanner]", %ErrorReporter, %"Vector[UInt]", %"Vector[Char]", %TokenType, i32 } +%"SparrowLayoutDecoder[SparrowScanner]" = type { %"RangeWithLookahead[SparrowScanner]", %ErrorReporter, %"Vector[Int]", %"Vector[Char]", %TokenType, i32 } %"RangeWithLookahead[SparrowScanner]" = type { %SparrowScanner, %"Vector[Token]" } %"Vector[Token]" = type { %"RawPtr[Token]", %"RawPtr[Token]", %"RawPtr[Token]" } %"RawPtr[Token]" = type { %Token* } -%"Vector[UInt]" = type { %"RawPtr[UInt]", %"RawPtr[UInt]", %"RawPtr[UInt]" } -%"RawPtr[UInt]" = type { i32* } +%"Vector[Int]" = type { %"RawPtr[Int]", %"RawPtr[Int]", %"RawPtr[Int]" } +%"RawPtr[Int]" = type { i32* } %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]" = type { %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %Token, i1, %AstBuilder, %ErrorReporter } %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]" = type { %"SparrowLayoutDecoder[SparrowScanner]", %"Vector[Token]" } -%AstBuilder = type { %UntypedPtr, %"FunctionPtr3[Node, UntypedPtr, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]", %"FunctionPtr2[Node, UntypedPtr, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]", %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Char]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]" } +%AstBuilder = type { %UntypedPtr, %"FunctionPtr3[Node, UntypedPtr, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]", %"FunctionPtr2[Node, UntypedPtr, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]", %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Char]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]" } %"FunctionPtr3[Node, UntypedPtr, Node, Node]" = type { %UntypedPtr } %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]" = type { %UntypedPtr } %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]" = type { %UntypedPtr } @@ -53,11 +53,11 @@ target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]" = type { %UntypedPtr } %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]" = type { %UntypedPtr } %"FunctionPtr3[Node, UntypedPtr, Location const, Int]" = type { %UntypedPtr } -%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]" = type { %UntypedPtr } -%"FunctionPtr3[Node, UntypedPtr, Location const, Long]" = type { %UntypedPtr } -%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]" = type { %UntypedPtr } +%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]" = type { %UntypedPtr } +%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]" = type { %UntypedPtr } +%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]" = type { %UntypedPtr } +%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]" = type { %UntypedPtr } %"FunctionPtr3[Node, UntypedPtr, Location const, Float]" = type { %UntypedPtr } -%"FunctionPtr3[Node, UntypedPtr, Location const, Double]" = type { %UntypedPtr } %"FunctionPtr3[Node, UntypedPtr, Location const, Char]" = type { %UntypedPtr } %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]" = type { %UntypedPtr } %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]" = type { %UntypedPtr } @@ -84,15 +84,15 @@ target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" %LocString = type { %"Tuple[Location, String]" } %"Tuple[Location, String]" = type { %Location, %String } %"ContiguousMemoryRange[LocString]" = type { %"RawPtr[LocString]", %"RawPtr[LocString]" } -%"ContiguousMemoryRange[UInt]" = type { %"RawPtr[UInt]", %"RawPtr[UInt]" } +%"ContiguousMemoryRange[Int]" = type { %"RawPtr[Int]", %"RawPtr[Int]" } %FileRange = type { %File*, i1, i8 } -@.fmtInt = private unnamed_addr constant [3 x i8] c"%d\00", align 1 -@.fmtUInt = private unnamed_addr constant [3 x i8] c"%u\00", align 1 -@.fmtLong = private unnamed_addr constant [5 x i8] c"%lld\00", align 1 -@.fmtULong = private unnamed_addr constant [5 x i8] c"%llu\00", align 1 +@.fmtInt32 = private unnamed_addr constant [3 x i8] c"%d\00", align 1 +@.fmtUInt32 = private unnamed_addr constant [3 x i8] c"%u\00", align 1 +@.fmtInt64 = private unnamed_addr constant [5 x i8] c"%lld\00", align 1 +@.fmtUInt64 = private unnamed_addr constant [5 x i8] c"%llu\00", align 1 @.fmtChar = private unnamed_addr constant [3 x i8] c"%c\00", align 1 -@.fmtDouble = private unnamed_addr constant [3 x i8] c"%g\00", align 1 +@.fmtFloat64 = private unnamed_addr constant [3 x i8] c"%g\00", align 1 @.fmtPointer = private unnamed_addr constant [3 x i8] c"%p\00", align 1 @endl.0 = global %EndLineHelperClass zeroinitializer @flush.1 = global %FlushHelperClass zeroinitializer @@ -697,795 +697,795 @@ define i1 @_Bool_opNeg(i1 %x) #0 { } ; Function Attrs: alwaysinline -define i8 @_Byte_opAssign(i8* %x, i8 %y) #0 { +define i8 @_Int8_opAssign(i8* %x, i8 %y) #0 { store i8 %y, i8* %x ret i8 %y } ; Function Attrs: alwaysinline -define i1 @_Byte_opEQ(i8 %x, i8 %y) #0 { +define i1 @_Int8_opEQ(i8 %x, i8 %y) #0 { %1 = icmp eq i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Byte_opNE(i8 %x, i8 %y) #0 { +define i1 @_Int8_opNE(i8 %x, i8 %y) #0 { %1 = icmp ne i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Byte_opLT(i8 %x, i8 %y) #0 { +define i1 @_Int8_opLT(i8 %x, i8 %y) #0 { %1 = icmp slt i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Byte_opGT(i8 %x, i8 %y) #0 { +define i1 @_Int8_opGT(i8 %x, i8 %y) #0 { %1 = icmp sgt i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Byte_opLE(i8 %x, i8 %y) #0 { +define i1 @_Int8_opLE(i8 %x, i8 %y) #0 { %1 = icmp sle i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Byte_opGE(i8 %x, i8 %y) #0 { +define i1 @_Int8_opGE(i8 %x, i8 %y) #0 { %1 = icmp sge i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i8 @_Byte_opPlus(i8 %x, i8 %y) #0 { +define i8 @_Int8_opPlus(i8 %x, i8 %y) #0 { %1 = add i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_Byte_opMinus(i8 %x, i8 %y) #0 { +define i8 @_Int8_opMinus(i8 %x, i8 %y) #0 { %1 = sub i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_Byte_opMul(i8 %x, i8 %y) #0 { +define i8 @_Int8_opMul(i8 %x, i8 %y) #0 { %1 = mul i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_Byte_opDiv(i8 %x, i8 %y) #0 { +define i8 @_Int8_opDiv(i8 %x, i8 %y) #0 { %1 = sdiv i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_Byte_opMod(i8 %x, i8 %y) #0 { +define i8 @_Int8_opMod(i8 %x, i8 %y) #0 { %1 = srem i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_Byte_opPlus1(i8 %x) #0 { +define i8 @_Int8_opPlus1(i8 %x) #0 { ret i8 %x } ; Function Attrs: alwaysinline -define i8 @_Byte_opMinus1(i8 %x) #0 { +define i8 @_Int8_opMinus1(i8 %x) #0 { %1 = sub i8 0, %x ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_UByte_opAssign(i8* %x, i8 %y) #0 { +define i8 @_UInt8_opAssign(i8* %x, i8 %y) #0 { store i8 %y, i8* %x ret i8 %y } ; Function Attrs: alwaysinline -define i1 @_UByte_opEQ(i8 %x, i8 %y) #0 { +define i1 @_UInt8_opEQ(i8 %x, i8 %y) #0 { %1 = icmp eq i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UByte_opNE(i8 %x, i8 %y) #0 { +define i1 @_UInt8_opNE(i8 %x, i8 %y) #0 { %1 = icmp ne i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UByte_opLT(i8 %x, i8 %y) #0 { +define i1 @_UInt8_opLT(i8 %x, i8 %y) #0 { %1 = icmp ult i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UByte_opGT(i8 %x, i8 %y) #0 { +define i1 @_UInt8_opGT(i8 %x, i8 %y) #0 { %1 = icmp ugt i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UByte_opLE(i8 %x, i8 %y) #0 { +define i1 @_UInt8_opLE(i8 %x, i8 %y) #0 { %1 = icmp ule i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UByte_opGE(i8 %x, i8 %y) #0 { +define i1 @_UInt8_opGE(i8 %x, i8 %y) #0 { %1 = icmp uge i8 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i8 @_UByte_opPlus(i8 %x, i8 %y) #0 { +define i8 @_UInt8_opPlus(i8 %x, i8 %y) #0 { %1 = add i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_UByte_opMinus(i8 %x, i8 %y) #0 { +define i8 @_UInt8_opMinus(i8 %x, i8 %y) #0 { %1 = sub i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_UByte_opMul(i8 %x, i8 %y) #0 { +define i8 @_UInt8_opMul(i8 %x, i8 %y) #0 { %1 = mul i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_UByte_opDiv(i8 %x, i8 %y) #0 { +define i8 @_UInt8_opDiv(i8 %x, i8 %y) #0 { %1 = udiv i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_UByte_opMod(i8 %x, i8 %y) #0 { +define i8 @_UInt8_opMod(i8 %x, i8 %y) #0 { %1 = urem i8 %x, %y ret i8 %1 } ; Function Attrs: alwaysinline -define i8 @_UByte_opPlus1(i8 %x) #0 { +define i8 @_UInt8_opPlus1(i8 %x) #0 { ret i8 %x } ; Function Attrs: alwaysinline -define i16 @_Short_opAssign(i16* %x, i16 %y) #0 { +define i16 @_Int16_opAssign(i16* %x, i16 %y) #0 { store i16 %y, i16* %x ret i16 %y } ; Function Attrs: alwaysinline -define i1 @_Short_opEQ(i16 %x, i16 %y) #0 { +define i1 @_Int16_opEQ(i16 %x, i16 %y) #0 { %1 = icmp eq i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Short_opNE(i16 %x, i16 %y) #0 { +define i1 @_Int16_opNE(i16 %x, i16 %y) #0 { %1 = icmp ne i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Short_opLT(i16 %x, i16 %y) #0 { +define i1 @_Int16_opLT(i16 %x, i16 %y) #0 { %1 = icmp slt i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Short_opGT(i16 %x, i16 %y) #0 { +define i1 @_Int16_opGT(i16 %x, i16 %y) #0 { %1 = icmp sgt i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Short_opLE(i16 %x, i16 %y) #0 { +define i1 @_Int16_opLE(i16 %x, i16 %y) #0 { %1 = icmp sle i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Short_opGE(i16 %x, i16 %y) #0 { +define i1 @_Int16_opGE(i16 %x, i16 %y) #0 { %1 = icmp sge i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i16 @_Short_opPlus(i16 %x, i16 %y) #0 { +define i16 @_Int16_opPlus(i16 %x, i16 %y) #0 { %1 = add i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_Short_opMinus(i16 %x, i16 %y) #0 { +define i16 @_Int16_opMinus(i16 %x, i16 %y) #0 { %1 = sub i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_Short_opMul(i16 %x, i16 %y) #0 { +define i16 @_Int16_opMul(i16 %x, i16 %y) #0 { %1 = mul i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_Short_opDiv(i16 %x, i16 %y) #0 { +define i16 @_Int16_opDiv(i16 %x, i16 %y) #0 { %1 = sdiv i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_Short_opMod(i16 %x, i16 %y) #0 { +define i16 @_Int16_opMod(i16 %x, i16 %y) #0 { %1 = srem i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_Short_opPlus1(i16 %x) #0 { +define i16 @_Int16_opPlus1(i16 %x) #0 { ret i16 %x } ; Function Attrs: alwaysinline -define i16 @_Short_opMinus1(i16 %x) #0 { +define i16 @_Int16_opMinus1(i16 %x) #0 { %1 = sub i16 0, %x ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_UShort_opAssign(i16* %x, i16 %y) #0 { +define i16 @_UInt16_opAssign(i16* %x, i16 %y) #0 { store i16 %y, i16* %x ret i16 %y } ; Function Attrs: alwaysinline -define i1 @_UShort_opEQ(i16 %x, i16 %y) #0 { +define i1 @_UInt16_opEQ(i16 %x, i16 %y) #0 { %1 = icmp eq i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UShort_opNE(i16 %x, i16 %y) #0 { +define i1 @_UInt16_opNE(i16 %x, i16 %y) #0 { %1 = icmp ne i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UShort_opLT(i16 %x, i16 %y) #0 { +define i1 @_UInt16_opLT(i16 %x, i16 %y) #0 { %1 = icmp ult i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UShort_opGT(i16 %x, i16 %y) #0 { +define i1 @_UInt16_opGT(i16 %x, i16 %y) #0 { %1 = icmp ugt i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UShort_opLE(i16 %x, i16 %y) #0 { +define i1 @_UInt16_opLE(i16 %x, i16 %y) #0 { %1 = icmp ule i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UShort_opGE(i16 %x, i16 %y) #0 { +define i1 @_UInt16_opGE(i16 %x, i16 %y) #0 { %1 = icmp uge i16 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i16 @_UShort_opPlus(i16 %x, i16 %y) #0 { +define i16 @_UInt16_opPlus(i16 %x, i16 %y) #0 { %1 = add i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_UShort_opMinus(i16 %x, i16 %y) #0 { +define i16 @_UInt16_opMinus(i16 %x, i16 %y) #0 { %1 = sub i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_UShort_opMul(i16 %x, i16 %y) #0 { +define i16 @_UInt16_opMul(i16 %x, i16 %y) #0 { %1 = mul i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_UShort_opDiv(i16 %x, i16 %y) #0 { +define i16 @_UInt16_opDiv(i16 %x, i16 %y) #0 { %1 = udiv i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_UShort_opMod(i16 %x, i16 %y) #0 { +define i16 @_UInt16_opMod(i16 %x, i16 %y) #0 { %1 = urem i16 %x, %y ret i16 %1 } ; Function Attrs: alwaysinline -define i16 @_UShort_opPlus1(i16 %x) #0 { +define i16 @_UInt16_opPlus1(i16 %x) #0 { ret i16 %x } ; Function Attrs: alwaysinline -define i32 @_Int_opAssign(i32* %x, i32 %y) #0 { +define i32 @_Int32_opAssign(i32* %x, i32 %y) #0 { store i32 %y, i32* %x ret i32 %y } ; Function Attrs: alwaysinline -define i1 @_Int_opEQ(i32 %x, i32 %y) #0 { +define i1 @_Int32_opEQ(i32 %x, i32 %y) #0 { %1 = icmp eq i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Int_opNE(i32 %x, i32 %y) #0 { +define i1 @_Int32_opNE(i32 %x, i32 %y) #0 { %1 = icmp ne i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Int_opLT(i32 %x, i32 %y) #0 { +define i1 @_Int32_opLT(i32 %x, i32 %y) #0 { %1 = icmp slt i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Int_opGT(i32 %x, i32 %y) #0 { +define i1 @_Int32_opGT(i32 %x, i32 %y) #0 { %1 = icmp sgt i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Int_opLE(i32 %x, i32 %y) #0 { +define i1 @_Int32_opLE(i32 %x, i32 %y) #0 { %1 = icmp sle i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Int_opGE(i32 %x, i32 %y) #0 { +define i1 @_Int32_opGE(i32 %x, i32 %y) #0 { %1 = icmp sge i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i32 @_Int_opPlus(i32 %x, i32 %y) #0 { +define i32 @_Int32_opPlus(i32 %x, i32 %y) #0 { %1 = add i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_Int_opMinus(i32 %x, i32 %y) #0 { +define i32 @_Int32_opMinus(i32 %x, i32 %y) #0 { %1 = sub i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_Int_opMul(i32 %x, i32 %y) #0 { +define i32 @_Int32_opMul(i32 %x, i32 %y) #0 { %1 = mul i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_Int_opDiv(i32 %x, i32 %y) #0 { +define i32 @_Int32_opDiv(i32 %x, i32 %y) #0 { %1 = sdiv i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_Int_opMod(i32 %x, i32 %y) #0 { +define i32 @_Int32_opMod(i32 %x, i32 %y) #0 { %1 = srem i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_Int_opPlus1(i32 %x) #0 { +define i32 @_Int32_opPlus1(i32 %x) #0 { ret i32 %x } ; Function Attrs: alwaysinline -define i32 @_Int_opMinus1(i32 %x) #0 { +define i32 @_Int32_opMinus1(i32 %x) #0 { %1 = sub i32 0, %x ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_UInt_opAssign(i32* %x, i32 %y) #0 { +define i32 @_UInt32_opAssign(i32* %x, i32 %y) #0 { store i32 %y, i32* %x ret i32 %y } ; Function Attrs: alwaysinline -define i1 @_UInt_opEQ(i32 %x, i32 %y) #0 { +define i1 @_UInt32_opEQ(i32 %x, i32 %y) #0 { %1 = icmp eq i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UInt_opNE(i32 %x, i32 %y) #0 { +define i1 @_UInt32_opNE(i32 %x, i32 %y) #0 { %1 = icmp ne i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UInt_opLT(i32 %x, i32 %y) #0 { +define i1 @_UInt32_opLT(i32 %x, i32 %y) #0 { %1 = icmp ult i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UInt_opGT(i32 %x, i32 %y) #0 { +define i1 @_UInt32_opGT(i32 %x, i32 %y) #0 { %1 = icmp ugt i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UInt_opLE(i32 %x, i32 %y) #0 { +define i1 @_UInt32_opLE(i32 %x, i32 %y) #0 { %1 = icmp ule i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_UInt_opGE(i32 %x, i32 %y) #0 { +define i1 @_UInt32_opGE(i32 %x, i32 %y) #0 { %1 = icmp uge i32 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i32 @_UInt_opPlus(i32 %x, i32 %y) #0 { +define i32 @_UInt32_opPlus(i32 %x, i32 %y) #0 { %1 = add i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_UInt_opMinus(i32 %x, i32 %y) #0 { +define i32 @_UInt32_opMinus(i32 %x, i32 %y) #0 { %1 = sub i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_UInt_opMul(i32 %x, i32 %y) #0 { +define i32 @_UInt32_opMul(i32 %x, i32 %y) #0 { %1 = mul i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_UInt_opDiv(i32 %x, i32 %y) #0 { +define i32 @_UInt32_opDiv(i32 %x, i32 %y) #0 { %1 = udiv i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_UInt_opMod(i32 %x, i32 %y) #0 { +define i32 @_UInt32_opMod(i32 %x, i32 %y) #0 { %1 = urem i32 %x, %y ret i32 %1 } ; Function Attrs: alwaysinline -define i32 @_UInt_opPlus1(i32 %x) #0 { +define i32 @_UInt32_opPlus1(i32 %x) #0 { ret i32 %x } ; Function Attrs: alwaysinline -define i64 @_Long_opAssign(i64* %x, i64 %y) #0 { +define i64 @_Int64_opAssign(i64* %x, i64 %y) #0 { store i64 %y, i64* %x ret i64 %y } ; Function Attrs: alwaysinline -define i1 @_Long_opEQ(i64 %x, i64 %y) #0 { +define i1 @_Int64_opEQ(i64 %x, i64 %y) #0 { %1 = icmp eq i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Long_opNE(i64 %x, i64 %y) #0 { +define i1 @_Int64_opNE(i64 %x, i64 %y) #0 { %1 = icmp ne i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Long_opLT(i64 %x, i64 %y) #0 { +define i1 @_Int64_opLT(i64 %x, i64 %y) #0 { %1 = icmp slt i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Long_opGT(i64 %x, i64 %y) #0 { +define i1 @_Int64_opGT(i64 %x, i64 %y) #0 { %1 = icmp sgt i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Long_opLE(i64 %x, i64 %y) #0 { +define i1 @_Int64_opLE(i64 %x, i64 %y) #0 { %1 = icmp sle i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Long_opGE(i64 %x, i64 %y) #0 { +define i1 @_Int64_opGE(i64 %x, i64 %y) #0 { %1 = icmp sge i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i64 @_Long_opPlus(i64 %x, i64 %y) #0 { +define i64 @_Int64_opPlus(i64 %x, i64 %y) #0 { %1 = add i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_Long_opMinus(i64 %x, i64 %y) #0 { +define i64 @_Int64_opMinus(i64 %x, i64 %y) #0 { %1 = sub i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_Long_opMul(i64 %x, i64 %y) #0 { +define i64 @_Int64_opMul(i64 %x, i64 %y) #0 { %1 = mul i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_Long_opDiv(i64 %x, i64 %y) #0 { +define i64 @_Int64_opDiv(i64 %x, i64 %y) #0 { %1 = sdiv i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_Long_opMod(i64 %x, i64 %y) #0 { +define i64 @_Int64_opMod(i64 %x, i64 %y) #0 { %1 = srem i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_Long_opPlus1(i64 %x) #0 { +define i64 @_Int64_opPlus1(i64 %x) #0 { ret i64 %x } ; Function Attrs: alwaysinline -define i64 @_Long_opMinus1(i64 %x) #0 { +define i64 @_Int64_opMinus1(i64 %x) #0 { %1 = sub i64 0, %x ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_ULong_opAssign(i64* %x, i64 %y) #0 { +define i64 @_UInt64_opAssign(i64* %x, i64 %y) #0 { store i64 %y, i64* %x ret i64 %y } ; Function Attrs: alwaysinline -define i1 @_ULong_opEQ(i64 %x, i64 %y) #0 { +define i1 @_UInt64_opEQ(i64 %x, i64 %y) #0 { %1 = icmp eq i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_ULong_opNE(i64 %x, i64 %y) #0 { +define i1 @_UInt64_opNE(i64 %x, i64 %y) #0 { %1 = icmp ne i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_ULong_opLT(i64 %x, i64 %y) #0 { +define i1 @_UInt64_opLT(i64 %x, i64 %y) #0 { %1 = icmp ult i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_ULong_opGT(i64 %x, i64 %y) #0 { +define i1 @_UInt64_opGT(i64 %x, i64 %y) #0 { %1 = icmp ugt i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_ULong_opLE(i64 %x, i64 %y) #0 { +define i1 @_UInt64_opLE(i64 %x, i64 %y) #0 { %1 = icmp ule i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_ULong_opGE(i64 %x, i64 %y) #0 { +define i1 @_UInt64_opGE(i64 %x, i64 %y) #0 { %1 = icmp uge i64 %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i64 @_ULong_opPlus(i64 %x, i64 %y) #0 { +define i64 @_UInt64_opPlus(i64 %x, i64 %y) #0 { %1 = add i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_ULong_opMinus(i64 %x, i64 %y) #0 { +define i64 @_UInt64_opMinus(i64 %x, i64 %y) #0 { %1 = sub i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_ULong_opMul(i64 %x, i64 %y) #0 { +define i64 @_UInt64_opMul(i64 %x, i64 %y) #0 { %1 = mul i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_ULong_opDiv(i64 %x, i64 %y) #0 { +define i64 @_UInt64_opDiv(i64 %x, i64 %y) #0 { %1 = udiv i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_ULong_opMod(i64 %x, i64 %y) #0 { +define i64 @_UInt64_opMod(i64 %x, i64 %y) #0 { %1 = urem i64 %x, %y ret i64 %1 } ; Function Attrs: alwaysinline -define i64 @_ULong_opPlus1(i64 %x) #0 { +define i64 @_UInt64_opPlus1(i64 %x) #0 { ret i64 %x } ; Function Attrs: alwaysinline -define float @_Float_opAssign(float* %x, float %y) #0 { +define float @_Float32_opAssign(float* %x, float %y) #0 { store float %y, float* %x ret float %y } ; Function Attrs: alwaysinline -define i1 @_Float_opEQ(float %x, float %y) #0 { +define i1 @_Float32_opEQ(float %x, float %y) #0 { %1 = fcmp ueq float %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Float_opNE(float %x, float %y) #0 { +define i1 @_Float32_opNE(float %x, float %y) #0 { %1 = fcmp une float %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Float_opLT(float %x, float %y) #0 { +define i1 @_Float32_opLT(float %x, float %y) #0 { %1 = fcmp ult float %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Float_opGT(float %x, float %y) #0 { +define i1 @_Float32_opGT(float %x, float %y) #0 { %1 = fcmp ugt float %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Float_opLE(float %x, float %y) #0 { +define i1 @_Float32_opLE(float %x, float %y) #0 { %1 = fcmp ule float %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Float_opGE(float %x, float %y) #0 { +define i1 @_Float32_opGE(float %x, float %y) #0 { %1 = fcmp uge float %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define float @_Float_opPlus(float %x, float %y) #0 { +define float @_Float32_opPlus(float %x, float %y) #0 { %1 = fadd float %x, %y ret float %1 } ; Function Attrs: alwaysinline -define float @_Float_opMinus(float %x, float %y) #0 { +define float @_Float32_opMinus(float %x, float %y) #0 { %1 = fsub float %x, %y ret float %1 } ; Function Attrs: alwaysinline -define float @_Float_opMul(float %x, float %y) #0 { +define float @_Float32_opMul(float %x, float %y) #0 { %1 = fmul float %x, %y ret float %1 } ; Function Attrs: alwaysinline -define float @_Float_opDiv(float %x, float %y) #0 { +define float @_Float32_opDiv(float %x, float %y) #0 { %1 = fdiv float %x, %y ret float %1 } ; Function Attrs: alwaysinline -define float @_Float_opPlus1(float %x) #0 { +define float @_Float32_opPlus1(float %x) #0 { ret float %x } ; Function Attrs: alwaysinline -define float @_Float_opMinus1(float %x) #0 { +define float @_Float32_opMinus1(float %x) #0 { %1 = fsub float 0.000000e+00, %x ret float %1 } ; Function Attrs: alwaysinline -define double @_Double_opAssign(double* %x, double %y) #0 { +define double @_Float64_opAssign(double* %x, double %y) #0 { store double %y, double* %x ret double %y } ; Function Attrs: alwaysinline -define i1 @_Double_opEQ(double %x, double %y) #0 { +define i1 @_Float64_opEQ(double %x, double %y) #0 { %1 = fcmp ueq double %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Double_opNE(double %x, double %y) #0 { +define i1 @_Float64_opNE(double %x, double %y) #0 { %1 = fcmp une double %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Double_opLT(double %x, double %y) #0 { +define i1 @_Float64_opLT(double %x, double %y) #0 { %1 = fcmp ult double %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Double_opGT(double %x, double %y) #0 { +define i1 @_Float64_opGT(double %x, double %y) #0 { %1 = fcmp ugt double %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Double_opLE(double %x, double %y) #0 { +define i1 @_Float64_opLE(double %x, double %y) #0 { %1 = fcmp ule double %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define i1 @_Double_opGE(double %x, double %y) #0 { +define i1 @_Float64_opGE(double %x, double %y) #0 { %1 = fcmp uge double %x, %y ret i1 %1 } ; Function Attrs: alwaysinline -define double @_Double_opPlus(double %x, double %y) #0 { +define double @_Float64_opPlus(double %x, double %y) #0 { %1 = fadd double %x, %y ret double %1 } ; Function Attrs: alwaysinline -define double @_Double_opMinus(double %x, double %y) #0 { +define double @_Float64_opMinus(double %x, double %y) #0 { %1 = fsub double %x, %y ret double %1 } ; Function Attrs: alwaysinline -define double @_Double_opMul(double %x, double %y) #0 { +define double @_Float64_opMul(double %x, double %y) #0 { %1 = fmul double %x, %y ret double %1 } ; Function Attrs: alwaysinline -define double @_Double_opDiv(double %x, double %y) #0 { +define double @_Float64_opDiv(double %x, double %y) #0 { %1 = fdiv double %x, %y ret double %1 } ; Function Attrs: alwaysinline -define double @_Double_opPlus1(double %x) #0 { +define double @_Float64_opPlus1(double %x) #0 { ret double %x } ; Function Attrs: alwaysinline -define double @_Double_opMinus1(double %x) #0 { +define double @_Float64_opMinus1(double %x) #0 { %1 = fsub double 0.000000e+00, %x ret double %1 } @@ -1777,24 +1777,25 @@ define void @_Type_copy_ctor(i8** %"$this", i8* %other) { } ; Function Attrs: alwaysinline -define i8* @ptrAdd(i8* %p, i64 %n) #0 { - %1 = getelementptr i8, i8* %p, i64 %n +define i8* @ptrAdd(i8* %p, i32 %n) #0 { + %1 = getelementptr i8, i8* %p, i32 %n ret i8* %1 } ; Function Attrs: alwaysinline -define i8* @ptrSub(i8* %p, i64 %n) #0 { - %1 = sub i64 0, %n - %2 = getelementptr i8, i8* %p, i64 %1 +define i8* @ptrSub(i8* %p, i32 %n) #0 { + %1 = sub i32 0, %n + %2 = getelementptr i8, i8* %p, i32 %1 ret i8* %2 } ; Function Attrs: alwaysinline -define i64 @ptrDiff(i8* %p1, i8* %p2) #0 { +define i32 @ptrDiff(i8* %p1, i8* %p2) #0 { %1 = ptrtoint i8* %p1 to i64 %2 = ptrtoint i8* %p2 to i64 %3 = sub i64 %1, %2 - ret i64 %3 + %4 = trunc i64 %3 to i32 + ret i32 %4 } ; Function Attrs: alwaysinline @@ -1834,46 +1835,69 @@ define void @flushOutput() #0 { declare i32 @fflush(%struct._IO_FILE*) #2 ; Function Attrs: alwaysinline -define void @writeByte(i8 %val) #0 { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i8 %val) +define void @writeInt8(i8 %val) #0 { + %1 = sext i8 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) ret void } declare i32 @printf(i8*, ...) ; Function Attrs: alwaysinline -define void @writeShort(i16 %val) #0 { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i16 %val) +define void @writeUInt8(i8 %val) #0 { + %1 = zext i8 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) + ret void +} + +; Function Attrs: alwaysinline +define void @writeInt16(i16 %val) #0 { + %1 = sext i16 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) + ret void +} + +; Function Attrs: alwaysinline +define void @writeUInt16(i16 %val) #0 { + %1 = zext i16 %val to i32 + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %1) + ret void +} + +; Function Attrs: alwaysinline +define void @writeInt32(i32 %val) #0 { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %val) ret void } ; Function Attrs: alwaysinline -define void @writeInt(i32 %val) #0 { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i32 %val) +define void @writeUInt32(i32 %val) #0 { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtUInt32, i32 0, i32 0), i32 %val) ret void } ; Function Attrs: alwaysinline -define void @writeUInt(i32 %val) #0 { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtUInt, i32 0, i32 0), i32 %val) +define void @writeInt64(i64 %val) #0 { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtInt64, i32 0, i32 0), i64 %val) ret void } ; Function Attrs: alwaysinline -define void @writeLong(i64 %val) #0 { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtLong, i32 0, i32 0), i64 %val) +define void @writeUInt64(i64 %val) #0 { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtUInt64, i32 0, i32 0), i64 %val) ret void } ; Function Attrs: alwaysinline -define void @writeULong(i64 %val) #0 { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtULong, i32 0, i32 0), i64 %val) +define void @writeFloat32(float %val) #0 { + %1 = fpext float %val to double + %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtFloat64, i32 0, i32 0), double %1) ret void } ; Function Attrs: alwaysinline -define void @writeDouble(double %val) #0 { - %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtDouble, i32 0, i32 0), double %val) +define void @writeFloat64(double %val) #0 { + %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtFloat64, i32 0, i32 0), double %val) ret void } @@ -1891,7 +1915,7 @@ define void @writePointer(i8* %val) #0 { ; Function Attrs: alwaysinline define void @_Int_to_CString(i32 %val, i8* %buffer) #0 { - %1 = call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i32 %val) #2 + %1 = call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt32, i32 0, i32 0), i32 %val) #2 ret void } @@ -1900,7 +1924,7 @@ declare i32 @sprintf(i8*, i8*, ...) #2 ; Function Attrs: alwaysinline define void @_ULong_to_CString(i64 %val, i8* %buffer) #0 { - %1 = call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtULong, i32 0, i32 0), i64 %val) #2 + %1 = call i32 (i8*, i8*, ...) @sprintf(i8* %buffer, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.fmtUInt64, i32 0, i32 0), i64 %val) #2 ret void } @@ -2227,27 +2251,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.13(i64 %this) #3 { - %this.addr = alloca i64 - store i64 %this, i64* %this.addr - br label %code - -code: ; preds = %0 - ret void -} - -; Function Attrs: alwaysinline nounwind -define internal void @dtor.14(i64 %this) #3 { - %this.addr = alloca i64 - store i64 %this, i64* %this.addr - br label %code - -code: ; preds = %0 - ret void -} - -; Function Attrs: alwaysinline nounwind -define internal void @dtor.15(float %this) #3 { +define internal void @dtor.13(float %this) #3 { %this.addr = alloca float store float %this, float* %this.addr br label %code @@ -2257,7 +2261,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.16(double %this) #3 { +define internal void @dtor.14(double %this) #3 { %this.addr = alloca double store double %this, double* %this.addr br label %code @@ -2267,7 +2271,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.17(i8 %this) #3 { +define internal void @dtor.15(i8 %this) #3 { %this.addr = alloca i8 store i8 %this, i8* %this.addr br label %code @@ -2280,9 +2284,9 @@ declare i1 @"$logicalOr"(i1, i1) declare i1 @"$logicalAnd"(i1, i1) -declare float @_Float_opMod(float, float) +declare float @_Float32_opMod(float, float) -declare double @_Double_opMod(double, double) +declare double @_Float64_opMod(double, double) ; Function Attrs: alwaysinline nounwind define internal i8 @"pre_++"(i8* %n) #3 { @@ -2293,14 +2297,14 @@ code: ; preds = %0 %1 = load i8, i8* %n store i8 1, i8* %tmp.this %2 = load i8, i8* %tmp.this - %3 = add i8 %1, %2 + %3 = call i8 @_Int8_opPlus(i8 %1, i8 %2) store i8 %3, i8* %n %4 = load i8, i8* %n ret i8 %4 } ; Function Attrs: alwaysinline nounwind -define internal i8 @"pre_++.18"(i8* %n) #3 { +define internal i8 @"pre_++.16"(i8* %n) #3 { %tmp.this = alloca i8 br label %code @@ -2308,14 +2312,14 @@ code: ; preds = %0 %1 = load i8, i8* %n store i8 1, i8* %tmp.this %2 = load i8, i8* %tmp.this - %3 = add i8 %1, %2 + %3 = call i8 @_UInt8_opPlus(i8 %1, i8 %2) store i8 %3, i8* %n %4 = load i8, i8* %n ret i8 %4 } ; Function Attrs: alwaysinline nounwind -define internal i16 @"pre_++.19"(i16* %n) #3 { +define internal i16 @"pre_++.17"(i16* %n) #3 { %tmp.this = alloca i16 br label %code @@ -2323,14 +2327,14 @@ code: ; preds = %0 %1 = load i16, i16* %n store i16 1, i16* %tmp.this %2 = load i16, i16* %tmp.this - %3 = add i16 %1, %2 + %3 = call i16 @_Int16_opPlus(i16 %1, i16 %2) store i16 %3, i16* %n %4 = load i16, i16* %n ret i16 %4 } ; Function Attrs: alwaysinline nounwind -define internal i16 @"pre_++.20"(i16* %n) #3 { +define internal i16 @"pre_++.18"(i16* %n) #3 { %tmp.this = alloca i16 br label %code @@ -2338,26 +2342,26 @@ code: ; preds = %0 %1 = load i16, i16* %n store i16 1, i16* %tmp.this %2 = load i16, i16* %tmp.this - %3 = add i16 %1, %2 + %3 = call i16 @_UInt16_opPlus(i16 %1, i16 %2) store i16 %3, i16* %n %4 = load i16, i16* %n ret i16 %4 } ; Function Attrs: alwaysinline nounwind -define internal i32 @"pre_++.21"(i32* %n) #3 { +define internal i32 @"pre_++.19"(i32* %n) #3 { br label %code code: ; preds = %0 %1 = load i32, i32* %n - %2 = add i32 %1, 1 + %2 = call i32 @_Int32_opPlus(i32 %1, i32 1) store i32 %2, i32* %n %3 = load i32, i32* %n ret i32 %3 } ; Function Attrs: alwaysinline nounwind -define internal i32 @"pre_++.22"(i32* %n) #3 { +define internal i32 @"pre_++.20"(i32* %n) #3 { %tmp.this = alloca i32 br label %code @@ -2365,44 +2369,14 @@ code: ; preds = %0 %1 = load i32, i32* %n store i32 1, i32* %tmp.this %2 = load i32, i32* %tmp.this - %3 = add i32 %1, %2 + %3 = call i32 @_UInt32_opPlus(i32 %1, i32 %2) store i32 %3, i32* %n %4 = load i32, i32* %n ret i32 %4 } ; Function Attrs: alwaysinline nounwind -define internal i64 @"pre_++.23"(i64* %n) #3 { - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 1, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = add i64 %1, %2 - store i64 %3, i64* %n - %4 = load i64, i64* %n - ret i64 %4 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @"pre_++.24"(i64* %n) #3 { - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 1, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = add i64 %1, %2 - store i64 %3, i64* %n - %4 = load i64, i64* %n - ret i64 %4 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @"pre_++.25"(i64* %n) #3 { +define internal i64 @"pre_++.21"(i64* %n) #3 { %tmp.this = alloca i64 br label %code @@ -2410,14 +2384,14 @@ code: ; preds = %0 %1 = load i64, i64* %n store i64 1, i64* %tmp.this %2 = load i64, i64* %tmp.this - %3 = add i64 %1, %2 + %3 = call i64 @_Int64_opPlus(i64 %1, i64 %2) store i64 %3, i64* %n %4 = load i64, i64* %n ret i64 %4 } ; Function Attrs: alwaysinline nounwind -define internal i64 @"pre_++.26"(i64* %n) #3 { +define internal i64 @"pre_++.22"(i64* %n) #3 { %tmp.this = alloca i64 br label %code @@ -2425,7 +2399,7 @@ code: ; preds = %0 %1 = load i64, i64* %n store i64 1, i64* %tmp.this %2 = load i64, i64* %tmp.this - %3 = add i64 %1, %2 + %3 = call i64 @_UInt64_opPlus(i64 %1, i64 %2) store i64 %3, i64* %n %4 = load i64, i64* %n ret i64 %4 @@ -2440,14 +2414,14 @@ code: ; preds = %0 %1 = load i8, i8* %n store i8 1, i8* %tmp.this %2 = load i8, i8* %tmp.this - %3 = sub i8 %1, %2 + %3 = call i8 @_Int8_opMinus(i8 %1, i8 %2) store i8 %3, i8* %n %4 = load i8, i8* %n ret i8 %4 } ; Function Attrs: alwaysinline nounwind -define internal i8 @pre_--.27(i8* %n) #3 { +define internal i8 @pre_--.23(i8* %n) #3 { %tmp.this = alloca i8 br label %code @@ -2455,14 +2429,14 @@ code: ; preds = %0 %1 = load i8, i8* %n store i8 1, i8* %tmp.this %2 = load i8, i8* %tmp.this - %3 = sub i8 %1, %2 + %3 = call i8 @_UInt8_opMinus(i8 %1, i8 %2) store i8 %3, i8* %n %4 = load i8, i8* %n ret i8 %4 } ; Function Attrs: alwaysinline nounwind -define internal i16 @pre_--.28(i16* %n) #3 { +define internal i16 @pre_--.24(i16* %n) #3 { %tmp.this = alloca i16 br label %code @@ -2470,14 +2444,14 @@ code: ; preds = %0 %1 = load i16, i16* %n store i16 1, i16* %tmp.this %2 = load i16, i16* %tmp.this - %3 = sub i16 %1, %2 + %3 = call i16 @_Int16_opMinus(i16 %1, i16 %2) store i16 %3, i16* %n %4 = load i16, i16* %n ret i16 %4 } ; Function Attrs: alwaysinline nounwind -define internal i16 @pre_--.29(i16* %n) #3 { +define internal i16 @pre_--.25(i16* %n) #3 { %tmp.this = alloca i16 br label %code @@ -2485,26 +2459,26 @@ code: ; preds = %0 %1 = load i16, i16* %n store i16 1, i16* %tmp.this %2 = load i16, i16* %tmp.this - %3 = sub i16 %1, %2 + %3 = call i16 @_UInt16_opMinus(i16 %1, i16 %2) store i16 %3, i16* %n %4 = load i16, i16* %n ret i16 %4 } ; Function Attrs: alwaysinline nounwind -define internal i32 @pre_--.30(i32* %n) #3 { +define internal i32 @pre_--.26(i32* %n) #3 { br label %code code: ; preds = %0 %1 = load i32, i32* %n - %2 = sub i32 %1, 1 + %2 = call i32 @_Int32_opMinus(i32 %1, i32 1) store i32 %2, i32* %n %3 = load i32, i32* %n ret i32 %3 } ; Function Attrs: alwaysinline nounwind -define internal i32 @pre_--.31(i32* %n) #3 { +define internal i32 @pre_--.27(i32* %n) #3 { %tmp.this = alloca i32 br label %code @@ -2512,44 +2486,14 @@ code: ; preds = %0 %1 = load i32, i32* %n store i32 1, i32* %tmp.this %2 = load i32, i32* %tmp.this - %3 = sub i32 %1, %2 + %3 = call i32 @_UInt32_opMinus(i32 %1, i32 %2) store i32 %3, i32* %n %4 = load i32, i32* %n ret i32 %4 } ; Function Attrs: alwaysinline nounwind -define internal i64 @pre_--.32(i64* %n) #3 { - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 1, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = sub i64 %1, %2 - store i64 %3, i64* %n - %4 = load i64, i64* %n - ret i64 %4 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @pre_--.33(i64* %n) #3 { - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 1, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = sub i64 %1, %2 - store i64 %3, i64* %n - %4 = load i64, i64* %n - ret i64 %4 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @pre_--.34(i64* %n) #3 { +define internal i64 @pre_--.28(i64* %n) #3 { %tmp.this = alloca i64 br label %code @@ -2557,14 +2501,14 @@ code: ; preds = %0 %1 = load i64, i64* %n store i64 1, i64* %tmp.this %2 = load i64, i64* %tmp.this - %3 = call i64 @_SizeType_opMinus(i64 %1, i64 %2) + %3 = call i64 @_Int64_opMinus(i64 %1, i64 %2) store i64 %3, i64* %n %4 = load i64, i64* %n ret i64 %4 } ; Function Attrs: alwaysinline nounwind -define internal i64 @pre_--.35(i64* %n) #3 { +define internal i64 @pre_--.29(i64* %n) #3 { %tmp.this = alloca i64 br label %code @@ -2572,7 +2516,7 @@ code: ; preds = %0 %1 = load i64, i64* %n store i64 1, i64* %tmp.this %2 = load i64, i64* %tmp.this - %3 = call i64 @_DiffType_opMinus(i64 %1, i64 %2) + %3 = call i64 @_UInt64_opMinus(i64 %1, i64 %2) store i64 %3, i64* %n %4 = load i64, i64* %n ret i64 %4 @@ -2590,14 +2534,14 @@ code: ; preds = %0 %2 = load i8, i8* %n store i8 1, i8* %tmp.this %3 = load i8, i8* %tmp.this - %4 = add i8 %2, %3 + %4 = call i8 @_Int8_opPlus(i8 %2, i8 %3) store i8 %4, i8* %n %5 = load i8, i8* %old ret i8 %5 } ; Function Attrs: alwaysinline nounwind -define internal i8 @"post_++.36"(i8* %n) #3 { +define internal i8 @"post_++.30"(i8* %n) #3 { %old = alloca i8 %tmp.this = alloca i8 br label %code @@ -2608,14 +2552,14 @@ code: ; preds = %0 %2 = load i8, i8* %n store i8 1, i8* %tmp.this %3 = load i8, i8* %tmp.this - %4 = add i8 %2, %3 + %4 = call i8 @_UInt8_opPlus(i8 %2, i8 %3) store i8 %4, i8* %n %5 = load i8, i8* %old ret i8 %5 } ; Function Attrs: alwaysinline nounwind -define internal i16 @"post_++.37"(i16* %n) #3 { +define internal i16 @"post_++.31"(i16* %n) #3 { %old = alloca i16 %tmp.this = alloca i16 br label %code @@ -2626,14 +2570,14 @@ code: ; preds = %0 %2 = load i16, i16* %n store i16 1, i16* %tmp.this %3 = load i16, i16* %tmp.this - %4 = add i16 %2, %3 + %4 = call i16 @_Int16_opPlus(i16 %2, i16 %3) store i16 %4, i16* %n %5 = load i16, i16* %old ret i16 %5 } ; Function Attrs: alwaysinline nounwind -define internal i16 @"post_++.38"(i16* %n) #3 { +define internal i16 @"post_++.32"(i16* %n) #3 { %old = alloca i16 %tmp.this = alloca i16 br label %code @@ -2644,14 +2588,14 @@ code: ; preds = %0 %2 = load i16, i16* %n store i16 1, i16* %tmp.this %3 = load i16, i16* %tmp.this - %4 = add i16 %2, %3 + %4 = call i16 @_UInt16_opPlus(i16 %2, i16 %3) store i16 %4, i16* %n %5 = load i16, i16* %old ret i16 %5 } ; Function Attrs: alwaysinline nounwind -define internal i32 @"post_++.39"(i32* %n) #3 { +define internal i32 @"post_++.33"(i32* %n) #3 { %old = alloca i32 br label %code @@ -2659,14 +2603,14 @@ code: ; preds = %0 %1 = load i32, i32* %n store i32 %1, i32* %old %2 = load i32, i32* %n - %3 = add i32 %2, 1 + %3 = call i32 @_Int32_opPlus(i32 %2, i32 1) store i32 %3, i32* %n %4 = load i32, i32* %old ret i32 %4 } ; Function Attrs: alwaysinline nounwind -define internal i32 @"post_++.40"(i32* %n) #3 { +define internal i32 @"post_++.34"(i32* %n) #3 { %old = alloca i32 %tmp.this = alloca i32 br label %code @@ -2677,50 +2621,14 @@ code: ; preds = %0 %2 = load i32, i32* %n store i32 1, i32* %tmp.this %3 = load i32, i32* %tmp.this - %4 = add i32 %2, %3 + %4 = call i32 @_UInt32_opPlus(i32 %2, i32 %3) store i32 %4, i32* %n %5 = load i32, i32* %old ret i32 %5 } ; Function Attrs: alwaysinline nounwind -define internal i64 @"post_++.41"(i64* %n) #3 { - %old = alloca i64 - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 %1, i64* %old - %2 = load i64, i64* %n - store i64 1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = add i64 %2, %3 - store i64 %4, i64* %n - %5 = load i64, i64* %old - ret i64 %5 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @"post_++.42"(i64* %n) #3 { - %old = alloca i64 - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 %1, i64* %old - %2 = load i64, i64* %n - store i64 1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = add i64 %2, %3 - store i64 %4, i64* %n - %5 = load i64, i64* %old - ret i64 %5 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @"post_++.43"(i64* %n) #3 { +define internal i64 @"post_++.35"(i64* %n) #3 { %old = alloca i64 %tmp.this = alloca i64 br label %code @@ -2731,14 +2639,14 @@ code: ; preds = %0 %2 = load i64, i64* %n store i64 1, i64* %tmp.this %3 = load i64, i64* %tmp.this - %4 = add i64 %2, %3 + %4 = call i64 @_Int64_opPlus(i64 %2, i64 %3) store i64 %4, i64* %n %5 = load i64, i64* %old ret i64 %5 } ; Function Attrs: alwaysinline nounwind -define internal i64 @"post_++.44"(i64* %n) #3 { +define internal i64 @"post_++.36"(i64* %n) #3 { %old = alloca i64 %tmp.this = alloca i64 br label %code @@ -2749,7 +2657,7 @@ code: ; preds = %0 %2 = load i64, i64* %n store i64 1, i64* %tmp.this %3 = load i64, i64* %tmp.this - %4 = add i64 %2, %3 + %4 = call i64 @_UInt64_opPlus(i64 %2, i64 %3) store i64 %4, i64* %n %5 = load i64, i64* %old ret i64 %5 @@ -2767,14 +2675,14 @@ code: ; preds = %0 %2 = load i8, i8* %n store i8 1, i8* %tmp.this %3 = load i8, i8* %tmp.this - %4 = sub i8 %2, %3 + %4 = call i8 @_Int8_opMinus(i8 %2, i8 %3) store i8 %4, i8* %n %5 = load i8, i8* %old ret i8 %5 } ; Function Attrs: alwaysinline nounwind -define internal i8 @post_--.45(i8* %n) #3 { +define internal i8 @post_--.37(i8* %n) #3 { %old = alloca i8 %tmp.this = alloca i8 br label %code @@ -2785,14 +2693,14 @@ code: ; preds = %0 %2 = load i8, i8* %n store i8 1, i8* %tmp.this %3 = load i8, i8* %tmp.this - %4 = sub i8 %2, %3 + %4 = call i8 @_UInt8_opMinus(i8 %2, i8 %3) store i8 %4, i8* %n %5 = load i8, i8* %old ret i8 %5 } ; Function Attrs: alwaysinline nounwind -define internal i16 @post_--.46(i16* %n) #3 { +define internal i16 @post_--.38(i16* %n) #3 { %old = alloca i16 %tmp.this = alloca i16 br label %code @@ -2803,14 +2711,14 @@ code: ; preds = %0 %2 = load i16, i16* %n store i16 1, i16* %tmp.this %3 = load i16, i16* %tmp.this - %4 = sub i16 %2, %3 + %4 = call i16 @_Int16_opMinus(i16 %2, i16 %3) store i16 %4, i16* %n %5 = load i16, i16* %old ret i16 %5 } ; Function Attrs: alwaysinline nounwind -define internal i16 @post_--.47(i16* %n) #3 { +define internal i16 @post_--.39(i16* %n) #3 { %old = alloca i16 %tmp.this = alloca i16 br label %code @@ -2821,14 +2729,14 @@ code: ; preds = %0 %2 = load i16, i16* %n store i16 1, i16* %tmp.this %3 = load i16, i16* %tmp.this - %4 = sub i16 %2, %3 + %4 = call i16 @_UInt16_opMinus(i16 %2, i16 %3) store i16 %4, i16* %n %5 = load i16, i16* %old ret i16 %5 } ; Function Attrs: alwaysinline nounwind -define internal i32 @post_--.48(i32* %n) #3 { +define internal i32 @post_--.40(i32* %n) #3 { %old = alloca i32 br label %code @@ -2836,14 +2744,14 @@ code: ; preds = %0 %1 = load i32, i32* %n store i32 %1, i32* %old %2 = load i32, i32* %n - %3 = sub i32 %2, 1 + %3 = call i32 @_Int32_opMinus(i32 %2, i32 1) store i32 %3, i32* %n %4 = load i32, i32* %old ret i32 %4 } ; Function Attrs: alwaysinline nounwind -define internal i32 @post_--.49(i32* %n) #3 { +define internal i32 @post_--.41(i32* %n) #3 { %old = alloca i32 %tmp.this = alloca i32 br label %code @@ -2854,50 +2762,14 @@ code: ; preds = %0 %2 = load i32, i32* %n store i32 1, i32* %tmp.this %3 = load i32, i32* %tmp.this - %4 = sub i32 %2, %3 + %4 = call i32 @_UInt32_opMinus(i32 %2, i32 %3) store i32 %4, i32* %n %5 = load i32, i32* %old ret i32 %5 } ; Function Attrs: alwaysinline nounwind -define internal i64 @post_--.50(i64* %n) #3 { - %old = alloca i64 - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 %1, i64* %old - %2 = load i64, i64* %n - store i64 1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = sub i64 %2, %3 - store i64 %4, i64* %n - %5 = load i64, i64* %old - ret i64 %5 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @post_--.51(i64* %n) #3 { - %old = alloca i64 - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %n - store i64 %1, i64* %old - %2 = load i64, i64* %n - store i64 1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = sub i64 %2, %3 - store i64 %4, i64* %n - %5 = load i64, i64* %old - ret i64 %5 -} - -; Function Attrs: alwaysinline nounwind -define internal i64 @post_--.52(i64* %n) #3 { +define internal i64 @post_--.42(i64* %n) #3 { %old = alloca i64 %tmp.this = alloca i64 br label %code @@ -2908,14 +2780,14 @@ code: ; preds = %0 %2 = load i64, i64* %n store i64 1, i64* %tmp.this %3 = load i64, i64* %tmp.this - %4 = call i64 @_SizeType_opMinus(i64 %2, i64 %3) + %4 = call i64 @_Int64_opMinus(i64 %2, i64 %3) store i64 %4, i64* %n %5 = load i64, i64* %old ret i64 %5 } ; Function Attrs: alwaysinline nounwind -define internal i64 @post_--.53(i64* %n) #3 { +define internal i64 @post_--.43(i64* %n) #3 { %old = alloca i64 %tmp.this = alloca i64 br label %code @@ -2926,32 +2798,32 @@ code: ; preds = %0 %2 = load i64, i64* %n store i64 1, i64* %tmp.this %3 = load i64, i64* %tmp.this - %4 = call i64 @_DiffType_opMinus(i64 %2, i64 %3) + %4 = call i64 @_UInt64_opMinus(i64 %2, i64 %3) store i64 %4, i64* %n %5 = load i64, i64* %old ret i64 %5 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.54(%StringRef* %this) #4 { +define internal void @ctor.44(%StringRef* %this) #4 { %tmp.this = alloca %UntypedPtr %tmp.this1 = alloca %UntypedPtr br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %tmp.this) + call void @ctor.46(%UntypedPtr* %tmp.this) %2 = load %UntypedPtr, %UntypedPtr* %tmp.this - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %2) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %2) %3 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 - call void @ctor.56(%UntypedPtr* %tmp.this1) + call void @ctor.46(%UntypedPtr* %tmp.this1) %4 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - call void @ctor.55(%UntypedPtr* %3, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %3, %UntypedPtr %4) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.55(%UntypedPtr* %this, %UntypedPtr %other) #4 { +define internal void @ctor.45(%UntypedPtr* %this, %UntypedPtr %other) #4 { %other.addr = alloca %UntypedPtr store %UntypedPtr %other, %UntypedPtr* %other.addr br label %code @@ -2967,7 +2839,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.56(%UntypedPtr* %this) #4 { +define internal void @ctor.46(%UntypedPtr* %this) #4 { br label %code code: ; preds = %0 @@ -2979,7 +2851,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.57(%UntypedPtr* %this) #3 { +define internal void @dtor.47(%UntypedPtr* %this) #3 { br label %code code: ; preds = %0 @@ -2987,41 +2859,38 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.58(%StringRef* %this, i64 %size) #4 { - %size.addr = alloca i64 - store i64 %size, i64* %size.addr +define internal void @ctor.48(%StringRef* %this, i32 %size) #4 { + %size.addr = alloca i32 + store i32 %size, i32* %size.addr %"$tmpForRef" = alloca %UntypedPtr - %tmp.this = alloca i64 %"$tmpForRef1" = alloca %UntypedPtr - %tmp.this2 = alloca i8 + %tmp.this = alloca i8 br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 - call void @ctor.56(%UntypedPtr* %2) + call void @ctor.46(%UntypedPtr* %2) %3 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 - %4 = load i64, i64* %size.addr - store i64 1, i64* %tmp.this - %5 = load i64, i64* %tmp.this - %6 = add i64 %4, %5 - %7 = call %UntypedPtr @malloc(i64 %6) - store %UntypedPtr %7, %UntypedPtr* %"$tmpForRef" + %4 = load i32, i32* %size.addr + %5 = call i32 @_Int32_opPlus(i32 %4, i32 1) + %6 = call %UntypedPtr @malloc(i32 %5) + store %UntypedPtr %6, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %3, %UntypedPtr* %"$tmpForRef") - %8 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 - %9 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 - %10 = load %UntypedPtr, %UntypedPtr* %9 - %11 = load i64, i64* %size.addr - %12 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %10, i64 %11) - store %UntypedPtr %12, %UntypedPtr* %"$tmpForRef1" - call void @"="(%UntypedPtr* %8, %UntypedPtr* %"$tmpForRef1") - store i8 0, i8* %tmp.this2 - %13 = load i8, i8* %tmp.this2 - %14 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 - %15 = load %UntypedPtr, %UntypedPtr* %14 - %16 = call i8* @asRefOf(%UntypedPtr %15) - store i8 %13, i8* %16 + %7 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 + %8 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 + %9 = load %UntypedPtr, %UntypedPtr* %8 + %10 = load i32, i32* %size.addr + %11 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %9, i32 %10) + store %UntypedPtr %11, %UntypedPtr* %"$tmpForRef1" + call void @"="(%UntypedPtr* %7, %UntypedPtr* %"$tmpForRef1") + store i8 0, i8* %tmp.this + %12 = load i8, i8* %tmp.this + %13 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 + %14 = load %UntypedPtr, %UntypedPtr* %13 + %15 = call i8* @asRefOf(%UntypedPtr %14) + store i8 %12, i8* %15 ret void } @@ -3040,7 +2909,7 @@ code: ; preds = %0 ret void } -declare %UntypedPtr @malloc(i64) +declare %UntypedPtr @malloc(i32) ; Function Attrs: inlinehint nounwind define internal i8* @asRefOf(%UntypedPtr %this) #4 { @@ -3055,16 +2924,16 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.59(%StringRef* %this, %StringRef %other) #4 { +define internal void @ctor.49(%StringRef* %this, %StringRef %other) #4 { %other.addr = alloca %StringRef store %StringRef %other, %StringRef* %other.addr br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 - call void @ctor.56(%UntypedPtr* %2) + call void @ctor.46(%UntypedPtr* %2) %3 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 %4 = getelementptr inbounds %StringRef, %StringRef* %other.addr, i32 0, i32 0 call void @"="(%UntypedPtr* %3, %UntypedPtr* %4) @@ -3075,7 +2944,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.60(%StringRef* %this, %UntypedPtr %begin, %UntypedPtr %end) #4 { +define internal void @ctor.50(%StringRef* %this, %UntypedPtr %begin, %UntypedPtr %end) #4 { %begin.addr = alloca %UntypedPtr store %UntypedPtr %begin, %UntypedPtr* %begin.addr %end.addr = alloca %UntypedPtr @@ -3084,9 +2953,9 @@ define internal void @ctor.60(%StringRef* %this, %UntypedPtr %begin, %UntypedPtr code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 - call void @ctor.56(%UntypedPtr* %2) + call void @ctor.46(%UntypedPtr* %2) %3 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 call void @"="(%UntypedPtr* %3, %UntypedPtr* %begin.addr) %4 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 @@ -3095,7 +2964,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.61(%StringRef %this) #3 { +define internal void @dtor.51(%StringRef %this) #3 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr br label %code @@ -3110,7 +2979,6 @@ code: ; preds = %0 define internal i1 @isEmpty(%StringRef %this) #4 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr - %tmp.this = alloca i64 br label %code code: ; preds = %0 @@ -3118,23 +2986,15 @@ code: ; preds = %0 %2 = load %UntypedPtr, %UntypedPtr* %1 %3 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - %5 = call i64 bitcast (i64 (i8*, i8*)* @ptrDiff to i64 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %2, %UntypedPtr %4) - store i64 0, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = icmp eq i64 %5, %6 - %8 = load i64, i64* %tmp.this - ret i1 %7 - -dumy_block: ; No predecessors! - %9 = load i64, i64* %tmp.this - unreachable + %5 = call i32 bitcast (i32 (i8*, i8*)* @ptrDiff to i32 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %2, %UntypedPtr %4) + %6 = call i1 @_Int32_opEQ(i32 %5, i32 0) + ret i1 %6 } ; Function Attrs: inlinehint nounwind -define internal i64 @size(%StringRef %this) #4 { +define internal i32 @size(%StringRef %this) #4 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr - %tmp.this = alloca i64 br label %code code: ; preds = %0 @@ -3142,10 +3002,8 @@ code: ; preds = %0 %2 = load %UntypedPtr, %UntypedPtr* %1 %3 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - %5 = call i64 bitcast (i64 (i8*, i8*)* @ptrDiff to i64 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %2, %UntypedPtr %4) - store i64 %5, i64* %tmp.this - %6 = load i64, i64* %tmp.this - ret i64 %6 + %5 = call i32 bitcast (i32 (i8*, i8*)* @ptrDiff to i32 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %2, %UntypedPtr %4) + ret i32 %5 } ; Function Attrs: inlinehint nounwind @@ -3157,12 +3015,12 @@ define internal i8* @front(%StringRef %this) #4 { code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - %3 = call i8* @asRefOf.62(%UntypedPtr %2) + %3 = call i8* @asRefOf.52(%UntypedPtr %2) ret i8* %3 } ; Function Attrs: inlinehint nounwind -define internal i8* @asRefOf.62(%UntypedPtr %this) #4 { +define internal i8* @asRefOf.52(%UntypedPtr %this) #4 { %this.addr = alloca %UntypedPtr store %UntypedPtr %this, %UntypedPtr* %this.addr br label %code @@ -3177,17 +3035,14 @@ code: ; preds = %0 define internal i8* @back(%StringRef %this) #4 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 1 %2 = load %UntypedPtr, %UntypedPtr* %1 - store i64 1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrSub to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %2, i64 %3) - %5 = call i8* @asRefOf.62(%UntypedPtr %4) - ret i8* %5 + %3 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrSub to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %2, i32 1) + %4 = call i8* @asRefOf.52(%UntypedPtr %3) + ret i8* %4 } ; Function Attrs: inlinehint nounwind @@ -3199,58 +3054,55 @@ define internal i8* @"()"(%StringRef %this) #4 { code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - %3 = call i8* @asRefOf.62(%UntypedPtr %2) + %3 = call i8* @asRefOf.52(%UntypedPtr %2) ret i8* %3 } ; Function Attrs: inlinehint nounwind -define internal i8* @"().63"(%StringRef %this, i64 %index) #4 { +define internal i8* @"().53"(%StringRef %this, i32 %index) #4 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr - %index.addr = alloca i64 - store i64 %index, i64* %index.addr + %index.addr = alloca i32 + store i32 %index, i32* %index.addr br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - %3 = load i64, i64* %index.addr - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %2, i64 %3) - %5 = call i8* @asRefOf.62(%UntypedPtr %4) + %3 = load i32, i32* %index.addr + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %2, i32 %3) + %5 = call i8* @asRefOf.52(%UntypedPtr %4) ret i8* %5 } ; Function Attrs: inlinehint nounwind -define internal i8* @at(%StringRef %this, i64 %index) #4 { +define internal i8* @at(%StringRef %this, i32 %index) #4 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr - %index.addr = alloca i64 - store i64 %index, i64* %index.addr + %index.addr = alloca i32 + store i32 %index, i32* %index.addr br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - %3 = load i64, i64* %index.addr - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %2, i64 %3) - %5 = call i8* @asRefOf.62(%UntypedPtr %4) + %3 = load i32, i32* %index.addr + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %2, i32 %3) + %5 = call i8* @asRefOf.52(%UntypedPtr %4) ret i8* %5 } ; Function Attrs: alwaysinline nounwind define internal void @popFront(%StringRef* %this) #3 { %"$tmpForRef" = alloca %UntypedPtr - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 %2 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 - store i64 1, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %4) - store %UntypedPtr %5, %UntypedPtr* %"$tmpForRef" + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 1) + store %UntypedPtr %4, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %1, %UntypedPtr* %"$tmpForRef") ret void } @@ -3258,25 +3110,22 @@ code: ; preds = %0 ; Function Attrs: alwaysinline nounwind define internal void @popBack(%StringRef* %this) #3 { %"$tmpForRef" = alloca %UntypedPtr - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 %2 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 - store i64 1, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrSub to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %4) - store %UntypedPtr %5, %UntypedPtr* %"$tmpForRef" + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrSub to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 1) + store %UntypedPtr %4, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %1, %UntypedPtr* %"$tmpForRef") ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.64(%StringRef* %this, i64 %n) #3 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @popFront.54(%StringRef* %this, i32 %n) #3 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %UntypedPtr br label %code @@ -3284,17 +3133,17 @@ code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 %2 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 - %4 = load i64, i64* %n.addr - %5 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %4) + %4 = load i32, i32* %n.addr + %5 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 %4) store %UntypedPtr %5, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %1, %UntypedPtr* %"$tmpForRef") ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popBack.65(%StringRef* %this, i64 %n) #3 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @popBack.55(%StringRef* %this, i32 %n) #3 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %UntypedPtr br label %code @@ -3302,44 +3151,44 @@ code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 1 %2 = getelementptr inbounds %StringRef, %StringRef* %this, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 - %4 = load i64, i64* %n.addr - %5 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %4) + %4 = load i32, i32* %n.addr + %5 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 %4) store %UntypedPtr %5, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %1, %UntypedPtr* %"$tmpForRef") ret void } ; Function Attrs: inlinehint nounwind -define internal %StringRef @subrange(%StringRef %this, i64 %index, i64 %num) #4 { +define internal %StringRef @subrange(%StringRef %this, i32 %index, i32 %num) #4 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr - %index.addr = alloca i64 - store i64 %index, i64* %index.addr - %num.addr = alloca i64 - store i64 %num, i64* %num.addr + %index.addr = alloca i32 + store i32 %index, i32* %index.addr + %num.addr = alloca i32 + store i32 %num, i32* %num.addr %tmp.this = alloca %StringRef br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - %3 = load i64, i64* %index.addr - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %2, i64 %3) + %3 = load i32, i32* %index.addr + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %2, i32 %3) %5 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %6 = load %UntypedPtr, %UntypedPtr* %5 - %7 = load i64, i64* %index.addr - %8 = load i64, i64* %num.addr - %9 = add i64 %7, %8 - %10 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %6, i64 %9) - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %4, %UntypedPtr %10) + %7 = load i32, i32* %index.addr + %8 = load i32, i32* %num.addr + %9 = call i32 @_Int32_opPlus(i32 %7, i32 %8) + %10 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %6, i32 %9) + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %4, %UntypedPtr %10) %11 = load %StringRef, %StringRef* %tmp.this %12 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %12) + call void @dtor.51(%StringRef %12) ret %StringRef %11 dumy_block: ; No predecessors! %13 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %13) + call void @dtor.51(%StringRef %13) unreachable } @@ -3352,12 +3201,12 @@ define internal i8* @cStr(%StringRef %this) #4 { code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %this.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - %3 = call i8* @asRefOf.62(%UntypedPtr %2) + %3 = call i8* @asRefOf.52(%UntypedPtr %2) ret i8* %3 } ; Function Attrs: inlinehint nounwind -define internal %StringRef* @"=.66"(%StringRef* %this, %StringRef %src) #4 { +define internal %StringRef* @"=.56"(%StringRef* %this, %StringRef %src) #4 { %src.addr = alloca %StringRef store %StringRef %src, %StringRef* %src.addr br label %code @@ -3378,65 +3227,62 @@ define internal i1 @"=="(%StringRef %this, %StringRef %other) #4 { store %StringRef %this, %StringRef* %this.addr %other.addr = alloca %StringRef store %StringRef %other, %StringRef* %other.addr - %s = alloca i64 - %i = alloca i64 - %tmp.this = alloca i64 + %s = alloca i32 + %i = alloca i32 br label %code code: ; preds = %0 %1 = load %StringRef, %StringRef* %this.addr - %2 = call i64 @size(%StringRef %1) - store i64 %2, i64* %s + %2 = call i32 @size(%StringRef %1) + store i32 %2, i32* %s br label %if_block if_block: ; preds = %code - %3 = load i64, i64* %s + %3 = load i32, i32* %s %4 = load %StringRef, %StringRef* %other.addr - %5 = call i64 @size(%StringRef %4) - %6 = icmp ne i64 %3, %5 + %5 = call i32 @size(%StringRef %4) + %6 = call i1 @_Int32_opNE(i32 %3, i32 %5) br i1 %6, label %if_then, label %if_end if_then: ; preds = %if_block ret i1 false if_end: ; preds = %dumy_block, %if_block - store i64 0, i64* %i + store i32 0, i32* %i br label %while_block dumy_block: ; No predecessors! br label %if_end while_block: ; preds = %while_step, %if_end - %7 = load i64, i64* %i - %8 = load i64, i64* %s - %9 = icmp slt i64 %7, %8 + %7 = load i32, i32* %i + %8 = load i32, i32* %s + %9 = call i1 @_Int32_opLT(i32 %7, i32 %8) br i1 %9, label %while_body, label %while_end while_body: ; preds = %while_block br label %if_block1 while_step: ; preds = %if_end3 - %10 = load i64, i64* %i - store i64 1, i64* %tmp.this - %11 = load i64, i64* %tmp.this - %12 = add i64 %10, %11 - store i64 %12, i64* %i + %10 = load i32, i32* %i + %11 = call i32 @_Int32_opPlus(i32 %10, i32 1) + store i32 %11, i32* %i br label %while_block while_end: ; preds = %while_block ret i1 true if_block1: ; preds = %while_body - %13 = load %StringRef, %StringRef* %this.addr - %14 = load i64, i64* %i - %15 = call i8* @at(%StringRef %13, i64 %14) - %16 = load i8, i8* %15 - %17 = load %StringRef, %StringRef* %other.addr - %18 = load i64, i64* %i - %19 = call i8* @at(%StringRef %17, i64 %18) - %20 = load i8, i8* %19 - %21 = icmp ne i8 %16, %20 - br i1 %21, label %if_then2, label %if_end3 + %12 = load %StringRef, %StringRef* %this.addr + %13 = load i32, i32* %i + %14 = call i8* @at(%StringRef %12, i32 %13) + %15 = load i8, i8* %14 + %16 = load %StringRef, %StringRef* %other.addr + %17 = load i32, i32* %i + %18 = call i8* @at(%StringRef %16, i32 %17) + %19 = load i8, i8* %18 + %20 = icmp ne i8 %15, %19 + br i1 %20, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 ret i1 false @@ -3452,7 +3298,7 @@ dumy_block4: ; No predecessors! define internal %StringRef @_String_fromCString(i8* %s) #4 { %s.addr = alloca i8* store i8* %s, i8** %s.addr - %len = alloca i64 + %len = alloca i32 %res = alloca %StringRef %tmp.this = alloca %UntypedPtr %"$tmpForRef" = alloca %UntypedPtr @@ -3460,46 +3306,45 @@ define internal %StringRef @_String_fromCString(i8* %s) #4 { code: ; preds = %0 %1 = load i8*, i8** %s.addr - %2 = call i64 @cStringLen(i8* %1) - store i64 %2, i64* %len - call void @ctor.54(%StringRef* %res) + %2 = call i32 @cStringLen(i8* %1) + store i32 %2, i32* %len + call void @ctor.44(%StringRef* %res) %3 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 %4 = load i8*, i8** %s.addr - call void @ctor.67(%UntypedPtr* %tmp.this, i8* %4) + call void @ctor.57(%UntypedPtr* %tmp.this, i8* %4) call void @"="(%UntypedPtr* %3, %UntypedPtr* %tmp.this) %5 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 1 %6 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 %7 = load %UntypedPtr, %UntypedPtr* %6 - %8 = load i64, i64* %len - %9 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %7, i64 %8) + %8 = load i32, i32* %len + %9 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %7, i32 %8) store %UntypedPtr %9, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %5, %UntypedPtr* %"$tmpForRef") %10 = load %StringRef, %StringRef* %res %11 = load %StringRef, %StringRef* %res - call void @dtor.61(%StringRef %11) + call void @dtor.51(%StringRef %11) ret %StringRef %10 dumy_block: ; No predecessors! %12 = load %StringRef, %StringRef* %res - call void @dtor.61(%StringRef %12) + call void @dtor.51(%StringRef %12) unreachable } ; Function Attrs: inlinehint nounwind -define internal i64 @cStringLen(i8* %s) #4 { +define internal i32 @cStringLen(i8* %s) #4 { %s.addr = alloca i8* store i8* %s, i8** %s.addr - %len = alloca i64 + %len = alloca i32 %p = alloca %UntypedPtr %tmp.this = alloca i8 %"$tmpForRef" = alloca %UntypedPtr - %tmp.this1 = alloca i64 br label %code code: ; preds = %0 - store i64 0, i64* %len + store i32 0, i32* %len %1 = load i8*, i8** %s.addr - call void @ctor.67(%UntypedPtr* %p, i8* %1) + call void @ctor.57(%UntypedPtr* %p, i8* %1) br label %while_block while_block: ; preds = %while_step, %code @@ -3508,29 +3353,27 @@ while_block: ; preds = %while_step, %code %4 = load i8, i8* %3 store i8 0, i8* %tmp.this %5 = load i8, i8* %tmp.this - %6 = icmp ne i8 %4, %5 + %6 = call i1 @_Int8_opNE(i8 %4, i8 %5) br i1 %6, label %while_body, label %while_end while_body: ; preds = %while_block - %7 = call i64 @"post_++.43"(i64* %len) + %7 = call i32 @"post_++.33"(i32* %len) br label %while_step while_step: ; preds = %while_body %8 = load %UntypedPtr, %UntypedPtr* %p - store i64 1, i64* %tmp.this1 - %9 = load i64, i64* %tmp.this1 - %10 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %8, i64 %9) - store %UntypedPtr %10, %UntypedPtr* %"$tmpForRef" + %9 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %8, i32 1) + store %UntypedPtr %9, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %p, %UntypedPtr* %"$tmpForRef") br label %while_block while_end: ; preds = %while_block - %11 = load i64, i64* %len - ret i64 %11 + %10 = load i32, i32* %len + ret i32 %10 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.67(%UntypedPtr* %this, i8* %val) #4 { +define internal void @ctor.57(%UntypedPtr* %this, i8* %val) #4 { %val.addr = alloca i8* store i8* %val, i8** %val.addr br label %code @@ -3549,7 +3392,6 @@ define internal i8 @char(%StringRef %this) #4 { %this.addr = alloca %StringRef store %StringRef %this, %StringRef* %this.addr %tmp.this = alloca i8 - %tmp.this1 = alloca i64 br label %code code: ; preds = %0 @@ -3567,19 +3409,17 @@ if_then: ; preds = %if_block if_else: ; preds = %if_block %4 = load %StringRef, %StringRef* %this.addr - store i64 0, i64* %tmp.this1 - %5 = load i64, i64* %tmp.this1 - %6 = call i8* @at(%StringRef %4, i64 %5) - %7 = load i8, i8* %6 - ret i8 %7 + %5 = call i8* @at(%StringRef %4, i32 0) + %6 = load i8, i8* %5 + ret i8 %6 -if_end: ; preds = %dumy_block2, %dumy_block +if_end: ; preds = %dumy_block1, %dumy_block unreachable dumy_block: ; No predecessors! br label %if_end -dumy_block2: ; No predecessors! +dumy_block1: ; No predecessors! br label %if_end } @@ -3589,98 +3429,90 @@ define internal %StringRef @"+"(%StringRef %x, %StringRef %y) #4 { store %StringRef %x, %StringRef* %x.addr %y.addr = alloca %StringRef store %StringRef %y, %StringRef* %y.addr - %sz1 = alloca i64 - %sz2 = alloca i64 + %sz1 = alloca i32 + %sz2 = alloca i32 %res = alloca %StringRef br label %code code: ; preds = %0 %1 = load %StringRef, %StringRef* %x.addr - %2 = call i64 @size(%StringRef %1) - store i64 %2, i64* %sz1 + %2 = call i32 @size(%StringRef %1) + store i32 %2, i32* %sz1 %3 = load %StringRef, %StringRef* %y.addr - %4 = call i64 @size(%StringRef %3) - store i64 %4, i64* %sz2 - %5 = load i64, i64* %sz1 - %6 = load i64, i64* %sz2 - %7 = add i64 %5, %6 - call void @ctor.58(%StringRef* %res, i64 %7) + %4 = call i32 @size(%StringRef %3) + store i32 %4, i32* %sz2 + %5 = load i32, i32* %sz1 + %6 = load i32, i32* %sz2 + %7 = call i32 @_Int32_opPlus(i32 %5, i32 %6) + call void @ctor.48(%StringRef* %res, i32 %7) %8 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 %9 = load %UntypedPtr, %UntypedPtr* %8 %10 = getelementptr inbounds %StringRef, %StringRef* %x.addr, i32 0, i32 0 %11 = load %UntypedPtr, %UntypedPtr* %10 - %12 = load i64, i64* %sz1 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %9, %UntypedPtr %11, i64 %12) + %12 = load i32, i32* %sz1 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %9, %UntypedPtr %11, i32 %12) %13 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 %14 = load %UntypedPtr, %UntypedPtr* %13 - %15 = load i64, i64* %sz1 - %16 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %14, i64 %15) + %15 = load i32, i32* %sz1 + %16 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %14, i32 %15) %17 = getelementptr inbounds %StringRef, %StringRef* %y.addr, i32 0, i32 0 %18 = load %UntypedPtr, %UntypedPtr* %17 - %19 = load i64, i64* %sz2 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %16, %UntypedPtr %18, i64 %19) + %19 = load i32, i32* %sz2 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %16, %UntypedPtr %18, i32 %19) %20 = load %StringRef, %StringRef* %res %21 = load %StringRef, %StringRef* %res - call void @dtor.61(%StringRef %21) + call void @dtor.51(%StringRef %21) ret %StringRef %20 dumy_block: ; No predecessors! %22 = load %StringRef, %StringRef* %res - call void @dtor.61(%StringRef %22) + call void @dtor.51(%StringRef %22) unreachable } ; Function Attrs: inlinehint nounwind -define internal %StringRef @"+.68"(%StringRef %x, i8 %y) #4 { +define internal %StringRef @"+.58"(%StringRef %x, i8 %y) #4 { %x.addr = alloca %StringRef store %StringRef %x, %StringRef* %x.addr %y.addr = alloca i8 store i8 %y, i8* %y.addr - %sz1 = alloca i64 + %sz1 = alloca i32 %sz2 = alloca i32 %res = alloca %StringRef - %tmp.this = alloca i64 - %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 + %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 %1 = load %StringRef, %StringRef* %x.addr - %2 = call i64 @size(%StringRef %1) - store i64 %2, i64* %sz1 + %2 = call i32 @size(%StringRef %1) + store i32 %2, i32* %sz1 store i32 1, i32* %sz2 - %3 = load i64, i64* %sz1 + %3 = load i32, i32* %sz1 %4 = load i32, i32* %sz2 - %5 = zext i32 %4 to i64 - store i64 %5, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = add i64 %3, %6 - call void @ctor.58(%StringRef* %res, i64 %7) - %8 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 + %5 = call i32 @_Int32_opPlus(i32 %3, i32 %4) + call void @ctor.48(%StringRef* %res, i32 %5) + %6 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 + %7 = load %UntypedPtr, %UntypedPtr* %6 + %8 = getelementptr inbounds %StringRef, %StringRef* %x.addr, i32 0, i32 0 %9 = load %UntypedPtr, %UntypedPtr* %8 - %10 = getelementptr inbounds %StringRef, %StringRef* %x.addr, i32 0, i32 0 - %11 = load %UntypedPtr, %UntypedPtr* %10 - %12 = load i64, i64* %sz1 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %9, %UntypedPtr %11, i64 %12) - %13 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 - %14 = load %UntypedPtr, %UntypedPtr* %13 - %15 = load i64, i64* %sz1 - %16 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %14, i64 %15) - call void @ctor.67(%UntypedPtr* %tmp.this1, i8* %y.addr) - %17 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %18 = load i32, i32* %sz2 - %19 = zext i32 %18 to i64 - store i64 %19, i64* %tmp.this2 - %20 = load i64, i64* %tmp.this2 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %16, %UntypedPtr %17, i64 %20) - %21 = load %StringRef, %StringRef* %res - %22 = load %StringRef, %StringRef* %res - call void @dtor.61(%StringRef %22) - ret %StringRef %21 + %10 = load i32, i32* %sz1 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %7, %UntypedPtr %9, i32 %10) + %11 = getelementptr inbounds %StringRef, %StringRef* %res, i32 0, i32 0 + %12 = load %UntypedPtr, %UntypedPtr* %11 + %13 = load i32, i32* %sz1 + %14 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %12, i32 %13) + call void @ctor.57(%UntypedPtr* %tmp.this, i8* %y.addr) + %15 = load %UntypedPtr, %UntypedPtr* %tmp.this + %16 = load i32, i32* %sz2 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %14, %UntypedPtr %15, i32 %16) + %17 = load %StringRef, %StringRef* %res + %18 = load %StringRef, %StringRef* %res + call void @dtor.51(%StringRef %18) + ret %StringRef %17 dumy_block: ; No predecessors! - %23 = load %StringRef, %StringRef* %res - call void @dtor.61(%StringRef %23) + %19 = load %StringRef, %StringRef* %res + call void @dtor.51(%StringRef %19) unreachable } @@ -3694,7 +3526,7 @@ declare void @reinterpretCast() #2 declare void @construct() #2 ; Function Attrs: inlinehint nounwind -define internal void @ctor.69(%UntypedPtr* %this, %Null %nullptr) #4 { +define internal void @ctor.59(%UntypedPtr* %this, %Null %nullptr) #4 { %nullptr.addr = alloca %Null store %Null %nullptr, %Null* %nullptr.addr br label %code @@ -3707,9 +3539,9 @@ code: ; preds = %0 ret void } -declare %UntypedPtr @calloc(i64, i64) +declare %UntypedPtr @calloc(i32, i32) -declare %UntypedPtr @realloc(%UntypedPtr, i64) +declare %UntypedPtr @realloc(%UntypedPtr, i32) declare void @free(%UntypedPtr) @@ -3725,7 +3557,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.70(%EndLineHelperClass* %this) #3 { +define internal void @ctor.60(%EndLineHelperClass* %this) #3 { br label %code code: ; preds = %0 @@ -3740,7 +3572,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.71(%EndLineHelperClass* %this) #3 { +define internal void @dtor.61(%EndLineHelperClass* %this) #3 { br label %code code: ; preds = %0 @@ -3755,7 +3587,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.72(%FlushHelperClass* %this) #3 { +define internal void @ctor.62(%FlushHelperClass* %this) #3 { br label %code code: ; preds = %0 @@ -3770,7 +3602,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.73(%FlushHelperClass* %this) #3 { +define internal void @dtor.63(%FlushHelperClass* %this) #3 { br label %code code: ; preds = %0 @@ -3778,7 +3610,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.74(%EndLineHelperClass* %this, %EndLineHelperClass* %other) #3 { +define internal void @ctor.64(%EndLineHelperClass* %this, %EndLineHelperClass* %other) #3 { %other.addr = alloca %EndLineHelperClass* store %EndLineHelperClass* %other, %EndLineHelperClass** %other.addr br label %code @@ -3788,7 +3620,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.75"(%EndLineHelperClass* %this, %EndLineHelperClass* %other) #3 { +define internal void @"=.65"(%EndLineHelperClass* %this, %EndLineHelperClass* %other) #3 { %other.addr = alloca %EndLineHelperClass* store %EndLineHelperClass* %other, %EndLineHelperClass** %other.addr br label %code @@ -3798,7 +3630,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.76"(%EndLineHelperClass* %this, %EndLineHelperClass* %other) #3 { +define internal i1 @"==.66"(%EndLineHelperClass* %this, %EndLineHelperClass* %other) #3 { %this.addr = alloca %EndLineHelperClass* store %EndLineHelperClass* %this, %EndLineHelperClass** %this.addr %other.addr = alloca %EndLineHelperClass* @@ -3810,7 +3642,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.77(%FlushHelperClass* %this, %FlushHelperClass* %other) #3 { +define internal void @ctor.67(%FlushHelperClass* %this, %FlushHelperClass* %other) #3 { %other.addr = alloca %FlushHelperClass* store %FlushHelperClass* %other, %FlushHelperClass** %other.addr br label %code @@ -3820,7 +3652,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.78"(%FlushHelperClass* %this, %FlushHelperClass* %other) #3 { +define internal void @"=.68"(%FlushHelperClass* %this, %FlushHelperClass* %other) #3 { %other.addr = alloca %FlushHelperClass* store %FlushHelperClass* %other, %FlushHelperClass** %other.addr br label %code @@ -3830,7 +3662,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.79"(%FlushHelperClass* %this, %FlushHelperClass* %other) #3 { +define internal i1 @"==.69"(%FlushHelperClass* %this, %FlushHelperClass* %other) #3 { %this.addr = alloca %FlushHelperClass* store %FlushHelperClass* %this, %FlushHelperClass** %this.addr %other.addr = alloca %FlushHelperClass* @@ -3849,7 +3681,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.80(%ConsoleOutputStream* %this) #3 { +define internal void @ctor.70(%ConsoleOutputStream* %this) #3 { br label %code code: ; preds = %0 @@ -3864,7 +3696,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.81(%ConsoleOutputStream* %this) #3 { +define internal void @dtor.71(%ConsoleOutputStream* %this) #3 { br label %code code: ; preds = %0 @@ -3872,7 +3704,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.82(%ConsoleOutputStream* %this, %ConsoleOutputStream* %other) #3 { +define internal void @ctor.72(%ConsoleOutputStream* %this, %ConsoleOutputStream* %other) #3 { %other.addr = alloca %ConsoleOutputStream* store %ConsoleOutputStream* %other, %ConsoleOutputStream** %other.addr br label %code @@ -3882,7 +3714,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.83"(%ConsoleOutputStream* %this, %ConsoleOutputStream* %other) #3 { +define internal void @"=.73"(%ConsoleOutputStream* %this, %ConsoleOutputStream* %other) #3 { %other.addr = alloca %ConsoleOutputStream* store %ConsoleOutputStream* %other, %ConsoleOutputStream** %other.addr br label %code @@ -3892,7 +3724,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.84"(%ConsoleOutputStream* %this, %ConsoleOutputStream* %other) #3 { +define internal i1 @"==.74"(%ConsoleOutputStream* %this, %ConsoleOutputStream* %other) #3 { %this.addr = alloca %ConsoleOutputStream* store %ConsoleOutputStream* %this, %ConsoleOutputStream** %this.addr %other.addr = alloca %ConsoleOutputStream* @@ -3916,7 +3748,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"<<<.85"(%ConsoleOutputStream* %this, i1 %x) #3 { +define internal void @"<<<.75"(%ConsoleOutputStream* %this, i1 %x) #3 { %x.addr = alloca i1 store i1 %x, i1* %x.addr %tmp.StringRef = alloca %StringRef @@ -3938,7 +3770,7 @@ if_then: ; preds = %if_block store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @str, i32 0, i32 0), i8** %4 store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @str, i32 0, i32 4), i8** %5 %6 = load %StringRef, %StringRef* %tmp.StringRef - call void @"<<<.86"(%ConsoleOutputStream* %this, %StringRef %6) + call void @"<<<.76"(%ConsoleOutputStream* %this, %StringRef %6) br label %if_end if_else: ; preds = %if_block @@ -3949,7 +3781,7 @@ if_else: ; preds = %if_block store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.5, i32 0, i32 0), i8** %9 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.5, i32 0, i32 5), i8** %10 %11 = load %StringRef, %StringRef* %tmp.StringRef1 - call void @"<<<.86"(%ConsoleOutputStream* %this, %StringRef %11) + call void @"<<<.76"(%ConsoleOutputStream* %this, %StringRef %11) br label %if_end if_end: ; preds = %if_else, %if_then @@ -3957,7 +3789,7 @@ if_end: ; preds = %if_else, %if_then } ; Function Attrs: alwaysinline nounwind -define internal void @"<<<.86"(%ConsoleOutputStream* %this, %StringRef %x) #3 { +define internal void @"<<<.76"(%ConsoleOutputStream* %this, %StringRef %x) #3 { %x.addr = alloca %StringRef store %StringRef %x, %StringRef* %x.addr %"$rangeVar" = alloca %StringRef @@ -3966,7 +3798,7 @@ define internal void @"<<<.86"(%ConsoleOutputStream* %this, %StringRef %x) #3 { code: ; preds = %0 %1 = load %StringRef, %StringRef* %x.addr - call void @ctor.59(%StringRef* %"$rangeVar", %StringRef %1) + call void @ctor.49(%StringRef* %"$rangeVar", %StringRef %1) br label %while_block while_block: ; preds = %while_step, %code @@ -3990,7 +3822,7 @@ while_step: ; preds = %while_body while_end: ; preds = %while_block %9 = load %StringRef, %StringRef* %"$rangeVar" - call void @dtor.61(%StringRef %9) + call void @dtor.51(%StringRef %9) ret void } @@ -4004,19 +3836,19 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.87(%MainParameters* %this) #3 { +define internal void @ctor.77(%MainParameters* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 0 - call void @ctor.88(%CStrPtr* %1) + call void @ctor.78(%CStrPtr* %1) %2 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 1 - call void @ctor.88(%CStrPtr* %2) + call void @ctor.78(%CStrPtr* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.88(%CStrPtr* %this) #3 { +define internal void @ctor.78(%CStrPtr* %this) #3 { br label %code code: ; preds = %0 @@ -4026,7 +3858,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.89(%MainParameters* %this, %MainParameters* %other) #3 { +define internal void @ctor.79(%MainParameters* %this, %MainParameters* %other) #3 { %other.addr = alloca %MainParameters* store %MainParameters* %other, %MainParameters** %other.addr br label %code @@ -4035,16 +3867,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 0 %2 = load %MainParameters*, %MainParameters** %other.addr %3 = getelementptr inbounds %MainParameters, %MainParameters* %2, i32 0, i32 0 - call void @ctor.90(%CStrPtr* %1, %CStrPtr* %3) + call void @ctor.80(%CStrPtr* %1, %CStrPtr* %3) %4 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 1 %5 = load %MainParameters*, %MainParameters** %other.addr %6 = getelementptr inbounds %MainParameters, %MainParameters* %5, i32 0, i32 1 - call void @ctor.90(%CStrPtr* %4, %CStrPtr* %6) + call void @ctor.80(%CStrPtr* %4, %CStrPtr* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.90(%CStrPtr* %this, %CStrPtr* %other) #3 { +define internal void @ctor.80(%CStrPtr* %this, %CStrPtr* %other) #3 { %other.addr = alloca %CStrPtr* store %CStrPtr* %other, %CStrPtr** %other.addr br label %code @@ -4059,7 +3891,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.91(%MainParameters* %this) #3 { +define internal void @dtor.81(%MainParameters* %this) #3 { br label %code code: ; preds = %0 @@ -4067,7 +3899,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.92"(%MainParameters* %this, %MainParameters* %other) #3 { +define internal void @"=.82"(%MainParameters* %this, %MainParameters* %other) #3 { %other.addr = alloca %MainParameters* store %MainParameters* %other, %MainParameters** %other.addr br label %code @@ -4076,16 +3908,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 0 %2 = load %MainParameters*, %MainParameters** %other.addr %3 = getelementptr inbounds %MainParameters, %MainParameters* %2, i32 0, i32 0 - call void @"=.93"(%CStrPtr* %1, %CStrPtr* %3) + call void @"=.83"(%CStrPtr* %1, %CStrPtr* %3) %4 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 1 %5 = load %MainParameters*, %MainParameters** %other.addr %6 = getelementptr inbounds %MainParameters, %MainParameters* %5, i32 0, i32 1 - call void @"=.93"(%CStrPtr* %4, %CStrPtr* %6) + call void @"=.83"(%CStrPtr* %4, %CStrPtr* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.93"(%CStrPtr* %this, %CStrPtr* %other) #3 { +define internal void @"=.83"(%CStrPtr* %this, %CStrPtr* %other) #3 { %other.addr = alloca %CStrPtr* store %CStrPtr* %other, %CStrPtr** %other.addr br label %code @@ -4100,7 +3932,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.94"(%MainParameters* %this, %MainParameters* %other) #3 { +define internal i1 @"==.84"(%MainParameters* %this, %MainParameters* %other) #3 { %this.addr = alloca %MainParameters* store %MainParameters* %this, %MainParameters** %this.addr %other.addr = alloca %MainParameters* @@ -4112,7 +3944,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %MainParameters, %MainParameters* %1, i32 0, i32 0 %3 = load %MainParameters*, %MainParameters** %other.addr %4 = getelementptr inbounds %MainParameters, %MainParameters* %3, i32 0, i32 0 - %5 = call i1 @"==.95"(%CStrPtr* %2, %CStrPtr* %4) + %5 = call i1 @"==.85"(%CStrPtr* %2, %CStrPtr* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -4120,7 +3952,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %MainParameters, %MainParameters* %6, i32 0, i32 1 %8 = load %MainParameters*, %MainParameters** %other.addr %9 = getelementptr inbounds %MainParameters, %MainParameters* %8, i32 0, i32 1 - %10 = call i1 @"==.95"(%CStrPtr* %7, %CStrPtr* %9) + %10 = call i1 @"==.85"(%CStrPtr* %7, %CStrPtr* %9) br label %cond.end cond.false: ; preds = %code @@ -4132,7 +3964,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.95"(%CStrPtr* %this, %CStrPtr* %other) #3 { +define internal i1 @"==.85"(%CStrPtr* %this, %CStrPtr* %other) #3 { %this.addr = alloca %CStrPtr* store %CStrPtr* %this, %CStrPtr** %this.addr %other.addr = alloca %CStrPtr* @@ -4153,7 +3985,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.96(%MainParameters* %this, i32 %argc, i8** %argv) #4 { +define internal void @ctor.86(%MainParameters* %this, i32 %argc, i8** %argv) #4 { %this.addr = alloca %MainParameters* store %MainParameters* %this, %MainParameters** %this.addr %argc.addr = alloca i32 @@ -4162,34 +3994,30 @@ define internal void @ctor.96(%MainParameters* %this, i32 %argc, i8** %argv) #4 store i8** %argv, i8*** %argv.addr %"$tmpForRef" = alloca %CStrPtr %"$tmpForRef1" = alloca %CStrPtr - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = load %MainParameters*, %MainParameters** %this.addr %2 = getelementptr inbounds %MainParameters, %MainParameters* %1, i32 0, i32 0 - call void @ctor.88(%CStrPtr* %2) + call void @ctor.78(%CStrPtr* %2) %3 = load %MainParameters*, %MainParameters** %this.addr %4 = getelementptr inbounds %MainParameters, %MainParameters* %3, i32 0, i32 1 - call void @ctor.88(%CStrPtr* %4) + call void @ctor.78(%CStrPtr* %4) %5 = load %MainParameters*, %MainParameters** %this.addr %6 = getelementptr inbounds %MainParameters, %MainParameters* %5, i32 0, i32 0 %7 = load i8**, i8*** %argv.addr %8 = call %CStrPtr @fromArgvPtr(i8** %7) store %CStrPtr %8, %CStrPtr* %"$tmpForRef" - call void @"=.93"(%CStrPtr* %6, %CStrPtr* %"$tmpForRef") + call void @"=.83"(%CStrPtr* %6, %CStrPtr* %"$tmpForRef") %9 = load %MainParameters*, %MainParameters** %this.addr %10 = getelementptr inbounds %MainParameters, %MainParameters* %9, i32 0, i32 1 %11 = load %MainParameters*, %MainParameters** %this.addr %12 = getelementptr inbounds %MainParameters, %MainParameters* %11, i32 0, i32 0 %13 = load %CStrPtr, %CStrPtr* %12 %14 = load i32, i32* %argc.addr - %15 = zext i32 %14 to i64 - store i64 %15, i64* %tmp.this - %16 = load i64, i64* %tmp.this - %17 = call %CStrPtr @"+.99"(%CStrPtr %13, i64 %16) - store %CStrPtr %17, %CStrPtr* %"$tmpForRef1" - call void @"=.93"(%CStrPtr* %10, %CStrPtr* %"$tmpForRef1") + %15 = call %CStrPtr @"+.89"(%CStrPtr %13, i32 %14) + store %CStrPtr %15, %CStrPtr* %"$tmpForRef1" + call void @"=.83"(%CStrPtr* %10, %CStrPtr* %"$tmpForRef1") ret void } @@ -4203,13 +4031,13 @@ define internal %CStrPtr @fromArgvPtr(i8** %argv) #4 { code: ; preds = %0 %1 = load i8**, i8*** %argv.addr %2 = bitcast i8** %1 to %CStr* - call void @ctor.97(%CStrPtr* %tmp.this, %CStr* %2) + call void @ctor.87(%CStrPtr* %tmp.this, %CStr* %2) %3 = load %CStrPtr, %CStrPtr* %tmp.this ret %CStrPtr %3 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.97(%CStrPtr* %this, %CStr* %fptr) #3 { +define internal void @ctor.87(%CStrPtr* %this, %CStr* %fptr) #3 { %this.addr = alloca %CStrPtr* store %CStrPtr* %this, %CStrPtr** %this.addr %fptr.addr = alloca %CStr* @@ -4225,7 +4053,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.98(%CStrPtr* %this) #3 { +define internal void @dtor.88(%CStrPtr* %this) #3 { br label %code code: ; preds = %0 @@ -4233,19 +4061,19 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %CStrPtr @"+.99"(%CStrPtr %p, i64 %n) #4 { +define internal %CStrPtr @"+.89"(%CStrPtr %p, i32 %n) #4 { %p.addr = alloca %CStrPtr store %CStrPtr %p, %CStrPtr* %p.addr - %n.addr = alloca i64 - store i64 %n, i64* %n.addr + %n.addr = alloca i32 + store i32 %n, i32* %n.addr br label %code code: ; preds = %0 %1 = load %CStrPtr, %CStrPtr* %p.addr %2 = call %UntypedPtr @toUntypedPtr(%CStrPtr %1) - %3 = load i64, i64* %n.addr - %4 = mul i64 %3, 8 - %5 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %2, i64 %4) + %3 = load i32, i32* %n.addr + %4 = call i32 @_Int32_opMul(i32 %3, i32 8) + %5 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %2, i32 %4) %6 = call %CStrPtr @toCStrPtr(%UntypedPtr %5) ret %CStrPtr %6 } @@ -4259,14 +4087,14 @@ define internal %CStrPtr @toCStrPtr(%UntypedPtr %p) #4 { code: ; preds = %0 %1 = load %UntypedPtr, %UntypedPtr* %p.addr - %2 = call %CStr* @asRefOf.100(%UntypedPtr %1) - call void @ctor.97(%CStrPtr* %tmp.this, %CStr* %2) + %2 = call %CStr* @asRefOf.90(%UntypedPtr %1) + call void @ctor.87(%CStrPtr* %tmp.this, %CStr* %2) %3 = load %CStrPtr, %CStrPtr* %tmp.this ret %CStrPtr %3 } ; Function Attrs: inlinehint nounwind -define internal %CStr* @asRefOf.100(%UntypedPtr %this) #4 { +define internal %CStr* @asRefOf.90(%UntypedPtr %this) #4 { %this.addr = alloca %UntypedPtr store %UntypedPtr %this, %UntypedPtr* %this.addr br label %code @@ -4288,13 +4116,13 @@ define internal %UntypedPtr @toUntypedPtr(%CStrPtr %p) #4 { code: ; preds = %0 %1 = getelementptr inbounds %CStrPtr, %CStrPtr* %p.addr, i32 0, i32 0 %2 = load %CStr*, %CStr** %1 - call void @ctor.101(%UntypedPtr* %tmp.this, %CStr* %2) + call void @ctor.91(%UntypedPtr* %tmp.this, %CStr* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this ret %UntypedPtr %3 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.101(%UntypedPtr* %this, %CStr* %val) #4 { +define internal void @ctor.91(%UntypedPtr* %this, %CStr* %val) #4 { %val.addr = alloca %CStr* store %CStr* %val, %CStr** %val.addr br label %code @@ -4310,20 +4138,17 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.102(%MainParameters* %this) #4 { - %tmp.this = alloca i64 +define internal i1 @isEmpty.92(%MainParameters* %this) #4 { br label %code code: ; preds = %0 - %1 = call i64 @size.103(%MainParameters* %this) - store i64 0, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = icmp eq i64 %1, %2 - ret i1 %3 + %1 = call i32 @size.93(%MainParameters* %this) + %2 = call i1 @_Int32_opEQ(i32 %1, i32 0) + ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i64 @size.103(%MainParameters* %this) #4 { +define internal i32 @size.93(%MainParameters* %this) #4 { br label %code code: ; preds = %0 @@ -4331,17 +4156,16 @@ code: ; preds = %0 %2 = load %CStrPtr, %CStrPtr* %1 %3 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 0 %4 = load %CStrPtr, %CStrPtr* %3 - %5 = call i64 @-(%CStrPtr %2, %CStrPtr %4) - ret i64 %5 + %5 = call i32 @-(%CStrPtr %2, %CStrPtr %4) + ret i32 %5 } ; Function Attrs: inlinehint nounwind -define internal i64 @-(%CStrPtr %p, %CStrPtr %q) #4 { +define internal i32 @-(%CStrPtr %p, %CStrPtr %q) #4 { %p.addr = alloca %CStrPtr store %CStrPtr %p, %CStrPtr* %p.addr %q.addr = alloca %CStrPtr store %CStrPtr %q, %CStrPtr* %q.addr - %tmp.this = alloca i64 br label %code code: ; preds = %0 @@ -4349,15 +4173,13 @@ code: ; preds = %0 %2 = call %UntypedPtr @toUntypedPtr(%CStrPtr %1) %3 = load %CStrPtr, %CStrPtr* %q.addr %4 = call %UntypedPtr @toUntypedPtr(%CStrPtr %3) - %5 = call i64 bitcast (i64 (i8*, i8*)* @ptrDiff to i64 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %2, %UntypedPtr %4) - store i64 %5, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = call i64 @_SizeType_opDiv(i64 %6, i64 8) - ret i64 %7 + %5 = call i32 bitcast (i32 (i8*, i8*)* @ptrDiff to i32 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %2, %UntypedPtr %4) + %6 = call i32 @_Int32_opDiv(i32 %5, i32 8) + ret i32 %6 } ; Function Attrs: inlinehint nounwind -define internal %StringRef @front.104(%MainParameters* %this) #4 { +define internal %StringRef @front.94(%MainParameters* %this) #4 { br label %code code: ; preds = %0 @@ -4383,40 +4205,37 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %StringRef @back.105(%MainParameters* %this) #4 { - %tmp.this = alloca i64 +define internal %StringRef @back.95(%MainParameters* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 1 %2 = load %CStrPtr, %CStrPtr* %1 - store i64 1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = call %CStrPtr @-.106(%CStrPtr %2, i64 %3) - %5 = call %StringRef @toStringRef(%CStrPtr %4) - ret %StringRef %5 + %3 = call %CStrPtr @-.96(%CStrPtr %2, i32 1) + %4 = call %StringRef @toStringRef(%CStrPtr %3) + ret %StringRef %4 } ; Function Attrs: inlinehint nounwind -define internal %CStrPtr @-.106(%CStrPtr %p, i64 %n) #4 { +define internal %CStrPtr @-.96(%CStrPtr %p, i32 %n) #4 { %p.addr = alloca %CStrPtr store %CStrPtr %p, %CStrPtr* %p.addr - %n.addr = alloca i64 - store i64 %n, i64* %n.addr + %n.addr = alloca i32 + store i32 %n, i32* %n.addr br label %code code: ; preds = %0 %1 = load %CStrPtr, %CStrPtr* %p.addr %2 = call %UntypedPtr @toUntypedPtr(%CStrPtr %1) - %3 = load i64, i64* %n.addr - %4 = mul i64 %3, 8 - %5 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrSub to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %2, i64 %4) + %3 = load i32, i32* %n.addr + %4 = call i32 @_Int32_opMul(i32 %3, i32 8) + %5 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrSub to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %2, i32 %4) %6 = call %CStrPtr @toCStrPtr(%UntypedPtr %5) ret %CStrPtr %6 } ; Function Attrs: inlinehint nounwind -define internal %StringRef @"().107"(%MainParameters* %this) #4 { +define internal %StringRef @"().97"(%MainParameters* %this) #4 { br label %code code: ; preds = %0 @@ -4427,26 +4246,25 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %StringRef @"().108"(%MainParameters* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal %StringRef @"().98"(%MainParameters* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr br label %code code: ; preds = %0 %1 = getelementptr inbounds %MainParameters, %MainParameters* %this, i32 0, i32 0 %2 = load %CStrPtr, %CStrPtr* %1 - %3 = load i64, i64* %n.addr - %4 = call %CStrPtr @"+.99"(%CStrPtr %2, i64 %3) + %3 = load i32, i32* %n.addr + %4 = call %CStrPtr @"+.89"(%CStrPtr %2, i32 %3) %5 = call %StringRef @toStringRef(%CStrPtr %4) ret %StringRef %5 } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.109(%MainParameters* %this) #3 { +define internal void @popFront.99(%MainParameters* %this) #3 { %this.addr = alloca %MainParameters* store %MainParameters* %this, %MainParameters** %this.addr %"$tmpForRef" = alloca %CStrPtr - %tmp.this = alloca i64 br label %code code: ; preds = %0 @@ -4455,20 +4273,17 @@ code: ; preds = %0 %3 = load %MainParameters*, %MainParameters** %this.addr %4 = getelementptr inbounds %MainParameters, %MainParameters* %3, i32 0, i32 0 %5 = load %CStrPtr, %CStrPtr* %4 - store i64 1, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = call %CStrPtr @"+.99"(%CStrPtr %5, i64 %6) - store %CStrPtr %7, %CStrPtr* %"$tmpForRef" - call void @"=.93"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") + %6 = call %CStrPtr @"+.89"(%CStrPtr %5, i32 1) + store %CStrPtr %6, %CStrPtr* %"$tmpForRef" + call void @"=.83"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popBack.110(%MainParameters* %this) #3 { +define internal void @popBack.100(%MainParameters* %this) #3 { %this.addr = alloca %MainParameters* store %MainParameters* %this, %MainParameters** %this.addr %"$tmpForRef" = alloca %CStrPtr - %tmp.this = alloca i64 br label %code code: ; preds = %0 @@ -4477,20 +4292,18 @@ code: ; preds = %0 %3 = load %MainParameters*, %MainParameters** %this.addr %4 = getelementptr inbounds %MainParameters, %MainParameters* %3, i32 0, i32 1 %5 = load %CStrPtr, %CStrPtr* %4 - store i64 1, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = call %CStrPtr @-.106(%CStrPtr %5, i64 %6) - store %CStrPtr %7, %CStrPtr* %"$tmpForRef" - call void @"=.93"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") + %6 = call %CStrPtr @-.96(%CStrPtr %5, i32 1) + store %CStrPtr %6, %CStrPtr* %"$tmpForRef" + call void @"=.83"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.111(%MainParameters* %this, i64 %n) #3 { +define internal void @popFront.101(%MainParameters* %this, i32 %n) #3 { %this.addr = alloca %MainParameters* store %MainParameters* %this, %MainParameters** %this.addr - %n.addr = alloca i64 - store i64 %n, i64* %n.addr + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %CStrPtr br label %code @@ -4500,19 +4313,19 @@ code: ; preds = %0 %3 = load %MainParameters*, %MainParameters** %this.addr %4 = getelementptr inbounds %MainParameters, %MainParameters* %3, i32 0, i32 0 %5 = load %CStrPtr, %CStrPtr* %4 - %6 = load i64, i64* %n.addr - %7 = call %CStrPtr @"+.99"(%CStrPtr %5, i64 %6) + %6 = load i32, i32* %n.addr + %7 = call %CStrPtr @"+.89"(%CStrPtr %5, i32 %6) store %CStrPtr %7, %CStrPtr* %"$tmpForRef" - call void @"=.93"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") + call void @"=.83"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popBack.112(%MainParameters* %this, i64 %n) #3 { +define internal void @popBack.102(%MainParameters* %this, i32 %n) #3 { %this.addr = alloca %MainParameters* store %MainParameters* %this, %MainParameters** %this.addr - %n.addr = alloca i64 - store i64 %n, i64* %n.addr + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %CStrPtr br label %code @@ -4522,10 +4335,10 @@ code: ; preds = %0 %3 = load %MainParameters*, %MainParameters** %this.addr %4 = getelementptr inbounds %MainParameters, %MainParameters* %3, i32 0, i32 1 %5 = load %CStrPtr, %CStrPtr* %4 - %6 = load i64, i64* %n.addr - %7 = call %CStrPtr @-.106(%CStrPtr %5, i64 %6) + %6 = load i32, i32* %n.addr + %7 = call %CStrPtr @-.96(%CStrPtr %5, i32 %6) store %CStrPtr %7, %CStrPtr* %"$tmpForRef" - call void @"=.93"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") + call void @"=.83"(%CStrPtr* %2, %CStrPtr* %"$tmpForRef") ret void } @@ -4533,7 +4346,7 @@ define internal void @__global_ctor.6() { br label %code code: ; preds = %0 - call void @ctor.87(%MainParameters* @programArgs.3) + call void @ctor.77(%MainParameters* @programArgs.3) ret void } @@ -4563,7 +4376,7 @@ code: ; preds = %0 declare i32 @atoi(i8*) ; Function Attrs: inlinehint nounwind -define internal i64 @asLong(%StringRef %src) #4 { +define internal i64 @asInt64(%StringRef %src) #4 { %src.addr = alloca %StringRef store %StringRef %src, %StringRef* %src.addr br label %code @@ -4578,7 +4391,7 @@ code: ; preds = %0 declare i64 @atoll(i8*) ; Function Attrs: inlinehint nounwind -define internal double @asDouble(%StringRef %src) #4 { +define internal double @asFloat(%StringRef %src) #4 { %src.addr = alloca %StringRef store %StringRef %src, %StringRef* %src.addr br label %code @@ -4593,67 +4406,67 @@ code: ; preds = %0 declare double @atof(i8*) ; Function Attrs: alwaysinline nounwind -define internal void @ctor.116(%ParserContext* %this) #3 { +define internal void @ctor.106(%ParserContext* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 0 - call void @ctor.117(%SparrowScanner* %1) + call void @ctor.107(%SparrowScanner* %1) %2 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 1 - call void @ctor.134(%"SparrowLayoutDecoder[SparrowScanner]"* %2) + call void @ctor.124(%"SparrowLayoutDecoder[SparrowScanner]"* %2) %3 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 2 - call void @ctor.140(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %3) + call void @ctor.130(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.117(%SparrowScanner* %this) #3 { +define internal void @ctor.107(%SparrowScanner* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 0 - call void @ctor.118(%Location* %1) + call void @ctor.108(%Location* %1) %2 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 1 - call void @ctor.121(%BufferedCharSource* %2) + call void @ctor.111(%BufferedCharSource* %2) %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @ctor.126(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3) + call void @ctor.116(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3) %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - call void @ctor.130(%Token* %4) + call void @ctor.120(%Token* %4) %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 4 store i1 false, i1* %5 %6 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 5 - call void @ctor.132(%ErrorReporter* %6) + call void @ctor.122(%ErrorReporter* %6) %7 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 store i1 false, i1* %7 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.118(%Location* %this) #3 { +define internal void @ctor.108(%Location* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 0 - call void @ctor.119(%SourceCode* %1) + call void @ctor.109(%SourceCode* %1) %2 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 1 - call void @ctor.120(%LineCol* %2) + call void @ctor.110(%LineCol* %2) %3 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 2 - call void @ctor.120(%LineCol* %3) + call void @ctor.110(%LineCol* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.119(%SourceCode* %this) #3 { +define internal void @ctor.109(%SourceCode* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %SourceCode, %SourceCode* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.120(%LineCol* %this) #3 { +define internal void @ctor.110(%LineCol* %this) #3 { br label %code code: ; preds = %0 @@ -4665,57 +4478,57 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.121(%BufferedCharSource* %this) #3 { +define internal void @ctor.111(%BufferedCharSource* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 0 - call void @ctor.122(%CharSource* %1) + call void @ctor.112(%CharSource* %1) %2 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 - call void @ctor.124(%String* %2) + call void @ctor.114(%String* %2) %3 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 2 store i32 0, i32* %3 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.122(%CharSource* %this) #3 { +define internal void @ctor.112(%CharSource* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %CharSource, %CharSource* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %CharSource, %CharSource* %this, i32 0, i32 1 - call void @ctor.123(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %2) + call void @ctor.113(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.123(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this) #3 { +define internal void @ctor.113(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, String mut, Int]", %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.124(%String* %this) #4 { +define internal void @ctor.114(%String* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - call void @ctor.125(%"RawPtr[Char]"* %1) + call void @ctor.115(%"RawPtr[Char]"* %1) %2 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - call void @ctor.125(%"RawPtr[Char]"* %2) + call void @ctor.115(%"RawPtr[Char]"* %2) %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 - call void @ctor.125(%"RawPtr[Char]"* %3) + call void @ctor.115(%"RawPtr[Char]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.125(%"RawPtr[Char]"* %this) #3 { +define internal void @ctor.115(%"RawPtr[Char]"* %this) #3 { br label %code code: ; preds = %0 @@ -4725,31 +4538,31 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.126(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #3 { +define internal void @ctor.116(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 - call void @ctor.127(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) + call void @ctor.117(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) %2 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 1 store %Location* null, %Location** %2 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.127(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #3 { +define internal void @ctor.117(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - call void @ctor.128(%BufferedCharSourceRange* %1) + call void @ctor.118(%BufferedCharSourceRange* %1) %2 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - call void @ctor.129(%"Vector[Char]"* %2) + call void @ctor.119(%"Vector[Char]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.128(%BufferedCharSourceRange* %this) #3 { +define internal void @ctor.118(%BufferedCharSourceRange* %this) #3 { br label %code code: ; preds = %0 @@ -4759,30 +4572,30 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.129(%"Vector[Char]"* %this) #3 { +define internal void @ctor.119(%"Vector[Char]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - call void @ctor.125(%"RawPtr[Char]"* %1) + call void @ctor.115(%"RawPtr[Char]"* %1) %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - call void @ctor.125(%"RawPtr[Char]"* %2) + call void @ctor.115(%"RawPtr[Char]"* %2) %3 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 - call void @ctor.125(%"RawPtr[Char]"* %3) + call void @ctor.115(%"RawPtr[Char]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.130(%Token* %this) #3 { +define internal void @ctor.120(%Token* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 0 - call void @ctor.118(%Location* %1) + call void @ctor.108(%Location* %1) %2 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 1 - call void @ctor.131(%TokenType* %2) + call void @ctor.121(%TokenType* %2) %3 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 2 - call void @ctor.124(%String* %3) + call void @ctor.114(%String* %3) %4 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 3 store i64 0, i64* %4 %5 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 4 @@ -4791,7 +4604,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.131(%TokenType* %this) #3 { +define internal void @ctor.121(%TokenType* %this) #3 { br label %code code: ; preds = %0 @@ -4801,75 +4614,75 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.132(%ErrorReporter* %this) #3 { +define internal void @ctor.122(%ErrorReporter* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %this, i32 0, i32 1 - call void @ctor.133(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %2) + call void @ctor.123(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.133(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this) #3 { +define internal void @ctor.123(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.134(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #3 { +define internal void @ctor.124(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @ctor.135(%"RangeWithLookahead[SparrowScanner]"* %1) + call void @ctor.125(%"RangeWithLookahead[SparrowScanner]"* %1) %2 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 1 - call void @ctor.132(%ErrorReporter* %2) + call void @ctor.122(%ErrorReporter* %2) %3 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - call void @ctor.138(%"Vector[UInt]"* %3) + call void @ctor.128(%"Vector[Int]"* %3) %4 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @ctor.129(%"Vector[Char]"* %4) + call void @ctor.119(%"Vector[Char]"* %4) %5 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @ctor.131(%TokenType* %5) + call void @ctor.121(%TokenType* %5) %6 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 store i32 0, i32* %6 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.135(%"RangeWithLookahead[SparrowScanner]"* %this) #3 { +define internal void @ctor.125(%"RangeWithLookahead[SparrowScanner]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - call void @ctor.117(%SparrowScanner* %1) + call void @ctor.107(%SparrowScanner* %1) %2 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - call void @ctor.136(%"Vector[Token]"* %2) + call void @ctor.126(%"Vector[Token]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.136(%"Vector[Token]"* %this) #3 { +define internal void @ctor.126(%"Vector[Token]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - call void @ctor.137(%"RawPtr[Token]"* %1) + call void @ctor.127(%"RawPtr[Token]"* %1) %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - call void @ctor.137(%"RawPtr[Token]"* %2) + call void @ctor.127(%"RawPtr[Token]"* %2) %3 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 - call void @ctor.137(%"RawPtr[Token]"* %3) + call void @ctor.127(%"RawPtr[Token]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.137(%"RawPtr[Token]"* %this) #3 { +define internal void @ctor.127(%"RawPtr[Token]"* %this) #3 { br label %code code: ; preds = %0 @@ -4879,391 +4692,391 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.138(%"Vector[UInt]"* %this) #3 { +define internal void @ctor.128(%"Vector[Int]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - call void @ctor.139(%"RawPtr[UInt]"* %1) - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - call void @ctor.139(%"RawPtr[UInt]"* %2) - %3 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - call void @ctor.139(%"RawPtr[UInt]"* %3) + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + call void @ctor.129(%"RawPtr[Int]"* %1) + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + call void @ctor.129(%"RawPtr[Int]"* %2) + %3 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + call void @ctor.129(%"RawPtr[Int]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.139(%"RawPtr[UInt]"* %this) #3 { +define internal void @ctor.129(%"RawPtr[Int]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 store i32* null, i32** %1 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.140(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { +define internal void @ctor.130(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @ctor.141(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) + call void @ctor.131(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - call void @ctor.130(%Token* %2) + call void @ctor.120(%Token* %2) %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 2 store i1 false, i1* %3 %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 - call void @ctor.142(%AstBuilder* %4) + call void @ctor.132(%AstBuilder* %4) %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 4 - call void @ctor.132(%ErrorReporter* %5) + call void @ctor.122(%ErrorReporter* %5) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.141(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { +define internal void @ctor.131(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @ctor.134(%"SparrowLayoutDecoder[SparrowScanner]"* %1) + call void @ctor.124(%"SparrowLayoutDecoder[SparrowScanner]"* %1) %2 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - call void @ctor.136(%"Vector[Token]"* %2) + call void @ctor.126(%"Vector[Token]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.142(%AstBuilder* %this) #3 { +define internal void @ctor.132(%AstBuilder* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 1 - call void @ctor.143(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %2) + call void @ctor.133(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %2) %3 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 2 - call void @ctor.144(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %3) + call void @ctor.134(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %3) %4 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 3 - call void @ctor.144(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %4) + call void @ctor.134(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %4) %5 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 4 - call void @ctor.145(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %5) + call void @ctor.135(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %5) %6 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 5 - call void @ctor.146(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %6) + call void @ctor.136(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %6) %7 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 6 - call void @ctor.147(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %7) + call void @ctor.137(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %7) %8 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 7 - call void @ctor.148(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %8) + call void @ctor.138(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %8) %9 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 8 - call void @ctor.145(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %9) + call void @ctor.135(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %9) %10 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 9 - call void @ctor.149(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %10) + call void @ctor.139(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %10) %11 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 10 - call void @ctor.145(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %11) + call void @ctor.135(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %11) %12 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 11 - call void @ctor.145(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %12) + call void @ctor.135(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %12) %13 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 12 - call void @ctor.145(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %13) + call void @ctor.135(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %13) %14 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 13 - call void @ctor.150(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %14) + call void @ctor.140(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %14) %15 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 14 - call void @ctor.151(%"FunctionPtr2[Node, UntypedPtr, Node]"* %15) + call void @ctor.141(%"FunctionPtr2[Node, UntypedPtr, Node]"* %15) %16 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 15 - call void @ctor.152(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %16) + call void @ctor.142(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %16) %17 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 16 - call void @ctor.153(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %17) + call void @ctor.143(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %17) %18 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 17 - call void @ctor.146(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %18) + call void @ctor.136(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %18) %19 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 18 - call void @ctor.154(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %19) + call void @ctor.144(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %19) %20 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 19 - call void @ctor.152(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %20) + call void @ctor.142(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %20) %21 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 20 - call void @ctor.152(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %21) + call void @ctor.142(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %21) %22 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 21 - call void @ctor.152(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %22) + call void @ctor.142(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %22) %23 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 22 - call void @ctor.144(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %23) + call void @ctor.134(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %23) %24 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 23 - call void @ctor.155(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %24) + call void @ctor.145(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %24) %25 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 24 - call void @ctor.156(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %25) + call void @ctor.146(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %25) %26 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 25 - call void @ctor.157(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %26) + call void @ctor.147(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %26) %27 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 26 - call void @ctor.158(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %27) + call void @ctor.148(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %27) %28 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 27 - call void @ctor.159(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %28) + call void @ctor.149(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %28) %29 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 28 - call void @ctor.160(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %29) + call void @ctor.150(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %29) %30 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 29 - call void @ctor.161(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %30) + call void @ctor.151(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %30) %31 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 30 - call void @ctor.162(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %31) + call void @ctor.152(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %31) %32 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 31 - call void @ctor.163(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %32) + call void @ctor.153(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %32) %33 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 32 - call void @ctor.164(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %33) + call void @ctor.154(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %33) %34 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 33 - call void @ctor.154(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %34) + call void @ctor.144(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %34) %35 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 34 - call void @ctor.165(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %35) + call void @ctor.155(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %35) %36 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 35 - call void @ctor.166(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %36) + call void @ctor.156(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %36) %37 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 36 - call void @ctor.147(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %37) + call void @ctor.137(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %37) %38 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 37 - call void @ctor.166(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %38) + call void @ctor.156(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %38) %39 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 38 - call void @ctor.156(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %39) + call void @ctor.146(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %39) %40 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 39 - call void @ctor.156(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %40) + call void @ctor.146(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %40) %41 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 40 - call void @ctor.165(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %41) + call void @ctor.155(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %41) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.143(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this) #3 { +define internal void @ctor.133(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Node, Node]", %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.144(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this) #3 { +define internal void @ctor.134(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.145(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this) #3 { +define internal void @ctor.135(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.146(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this) #3 { +define internal void @ctor.136(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.147(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this) #3 { +define internal void @ctor.137(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.148(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this) #3 { +define internal void @ctor.138(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.149(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this) #3 { +define internal void @ctor.139(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.150(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this) #3 { +define internal void @ctor.140(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]", %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.151(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this) #3 { +define internal void @ctor.141(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Node]", %"FunctionPtr2[Node, UntypedPtr, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.152(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this) #3 { +define internal void @ctor.142(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.153(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this) #3 { +define internal void @ctor.143(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.154(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this) #3 { +define internal void @ctor.144(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.155(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this) #3 { +define internal void @ctor.145(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.156(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this) #3 { +define internal void @ctor.146(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.157(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this) #3 { +define internal void @ctor.147(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]", %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.158(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this) #3 { +define internal void @ctor.148(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.159(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this) #3 { +define internal void @ctor.149(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, i32 0, i32 0 + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.160(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this) #3 { +define internal void @ctor.150(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, i32 0, i32 0 + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.161(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this) #3 { +define internal void @ctor.151(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, i32 0, i32 0 + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.162(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this) #3 { +define internal void @ctor.152(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, i32 0, i32 0 + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.163(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this) #3 { +define internal void @ctor.153(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, i32 0, i32 0 + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.164(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this) #3 { +define internal void @ctor.154(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Char]", %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.165(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this) #3 { +define internal void @ctor.155(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Node]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.166(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this) #3 { +define internal void @ctor.156(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.167(%ParserContext* %this, %ParserContext* %other) #3 { +define internal void @ctor.157(%ParserContext* %this, %ParserContext* %other) #3 { %other.addr = alloca %ParserContext* store %ParserContext* %other, %ParserContext** %other.addr br label %code @@ -5272,20 +5085,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 0 %2 = load %ParserContext*, %ParserContext** %other.addr %3 = getelementptr inbounds %ParserContext, %ParserContext* %2, i32 0, i32 0 - call void @ctor.168(%SparrowScanner* %1, %SparrowScanner* %3) + call void @ctor.158(%SparrowScanner* %1, %SparrowScanner* %3) %4 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 1 %5 = load %ParserContext*, %ParserContext** %other.addr %6 = getelementptr inbounds %ParserContext, %ParserContext* %5, i32 0, i32 1 - call void @ctor.192(%"SparrowLayoutDecoder[SparrowScanner]"* %4, %"SparrowLayoutDecoder[SparrowScanner]"* %6) + call void @ctor.181(%"SparrowLayoutDecoder[SparrowScanner]"* %4, %"SparrowLayoutDecoder[SparrowScanner]"* %6) %7 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 2 %8 = load %ParserContext*, %ParserContext** %other.addr %9 = getelementptr inbounds %ParserContext, %ParserContext* %8, i32 0, i32 2 - call void @ctor.220(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %9) + call void @ctor.209(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.168(%SparrowScanner* %this, %SparrowScanner* %other) #3 { +define internal void @ctor.158(%SparrowScanner* %this, %SparrowScanner* %other) #3 { %other.addr = alloca %SparrowScanner* store %SparrowScanner* %other, %SparrowScanner** %other.addr br label %code @@ -5294,19 +5107,19 @@ code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 0 %2 = load %SparrowScanner*, %SparrowScanner** %other.addr %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %2, i32 0, i32 0 - call void @ctor.169(%Location* %1, %Location* %3) + call void @ctor.159(%Location* %1, %Location* %3) %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 1 %5 = load %SparrowScanner*, %SparrowScanner** %other.addr %6 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %5, i32 0, i32 1 - call void @ctor.172(%BufferedCharSource* %4, %BufferedCharSource* %6) + call void @ctor.162(%BufferedCharSource* %4, %BufferedCharSource* %6) %7 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %8 = load %SparrowScanner*, %SparrowScanner** %other.addr %9 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %8, i32 0, i32 2 - call void @ctor.181(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %7, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %9) + call void @ctor.171(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %7, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %9) %10 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %11 = load %SparrowScanner*, %SparrowScanner** %other.addr %12 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %11, i32 0, i32 3 - call void @ctor.188(%Token* %10, %Token* %12) + call void @ctor.177(%Token* %10, %Token* %12) %13 = load %SparrowScanner*, %SparrowScanner** %other.addr %14 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %13, i32 0, i32 4 %15 = load i1, i1* %14 @@ -5315,7 +5128,7 @@ code: ; preds = %0 %17 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 5 %18 = load %SparrowScanner*, %SparrowScanner** %other.addr %19 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %18, i32 0, i32 5 - call void @ctor.190(%ErrorReporter* %17, %ErrorReporter* %19) + call void @ctor.179(%ErrorReporter* %17, %ErrorReporter* %19) %20 = load %SparrowScanner*, %SparrowScanner** %other.addr %21 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %20, i32 0, i32 6 %22 = load i1, i1* %21 @@ -5325,7 +5138,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.169(%Location* %this, %Location* %other) #3 { +define internal void @ctor.159(%Location* %this, %Location* %other) #3 { %other.addr = alloca %Location* store %Location* %other, %Location** %other.addr br label %code @@ -5334,20 +5147,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 0 %2 = load %Location*, %Location** %other.addr %3 = getelementptr inbounds %Location, %Location* %2, i32 0, i32 0 - call void @ctor.170(%SourceCode* %1, %SourceCode* %3) + call void @ctor.160(%SourceCode* %1, %SourceCode* %3) %4 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 1 %5 = load %Location*, %Location** %other.addr %6 = getelementptr inbounds %Location, %Location* %5, i32 0, i32 1 - call void @ctor.171(%LineCol* %4, %LineCol* %6) + call void @ctor.161(%LineCol* %4, %LineCol* %6) %7 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 2 %8 = load %Location*, %Location** %other.addr %9 = getelementptr inbounds %Location, %Location* %8, i32 0, i32 2 - call void @ctor.171(%LineCol* %7, %LineCol* %9) + call void @ctor.161(%LineCol* %7, %LineCol* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.170(%SourceCode* %this, %SourceCode* %other) #3 { +define internal void @ctor.160(%SourceCode* %this, %SourceCode* %other) #3 { %other.addr = alloca %SourceCode* store %SourceCode* %other, %SourceCode** %other.addr br label %code @@ -5357,12 +5170,12 @@ code: ; preds = %0 %2 = load %SourceCode*, %SourceCode** %other.addr %3 = getelementptr inbounds %SourceCode, %SourceCode* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.171(%LineCol* %this, %LineCol* %other) #3 { +define internal void @ctor.161(%LineCol* %this, %LineCol* %other) #3 { %other.addr = alloca %LineCol* store %LineCol* %other, %LineCol** %other.addr br label %code @@ -5382,7 +5195,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.172(%BufferedCharSource* %this, %BufferedCharSource* %other) #3 { +define internal void @ctor.162(%BufferedCharSource* %this, %BufferedCharSource* %other) #3 { %other.addr = alloca %BufferedCharSource* store %BufferedCharSource* %other, %BufferedCharSource** %other.addr br label %code @@ -5391,11 +5204,11 @@ code: ; preds = %0 %1 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 0 %2 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %3 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %2, i32 0, i32 0 - call void @ctor.173(%CharSource* %1, %CharSource* %3) + call void @ctor.163(%CharSource* %1, %CharSource* %3) %4 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 %5 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %6 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %5, i32 0, i32 1 - call void @ctor.175(%String* %4, %String* %6) + call void @ctor.165(%String* %4, %String* %6) %7 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %8 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %7, i32 0, i32 2 %9 = load i32, i32* %8 @@ -5405,7 +5218,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.173(%CharSource* %this, %CharSource* %other) #3 { +define internal void @ctor.163(%CharSource* %this, %CharSource* %other) #3 { %other.addr = alloca %CharSource* store %CharSource* %other, %CharSource** %other.addr br label %code @@ -5415,16 +5228,16 @@ code: ; preds = %0 %2 = load %CharSource*, %CharSource** %other.addr %3 = getelementptr inbounds %CharSource, %CharSource* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) %5 = getelementptr inbounds %CharSource, %CharSource* %this, i32 0, i32 1 %6 = load %CharSource*, %CharSource** %other.addr %7 = getelementptr inbounds %CharSource, %CharSource* %6, i32 0, i32 1 - call void @ctor.174(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %5, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %7) + call void @ctor.164(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %5, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %7) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.174(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other) #3 { +define internal void @ctor.164(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* store %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"** %other.addr br label %code @@ -5434,110 +5247,98 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"*, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, String mut, Int]", %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.175(%String* %this, %String* %other) #4 { - %size = alloca i64 +define internal void @ctor.165(%String* %this, %String* %other) #4 { + %size = alloca i32 br label %code code: ; preds = %0 - %1 = call i64 @size.176(%String* %other) - store i64 %1, i64* %size - %2 = load i64, i64* %size - call void @ctor.177(%String* %this, i64 %2) + %1 = call i32 @size.166(%String* %other) + store i32 %1, i32* %size + %2 = load i32, i32* %size + call void @ctor.167(%String* %this, i32 %2) %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %4 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %3) %5 = getelementptr inbounds %String, %String* %other, i32 0, i32 0 %6 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %5) - %7 = load i64, i64* %size - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %4, %UntypedPtr %6, i64 %7) + %7 = load i32, i32* %size + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %4, %UntypedPtr %6, i32 %7) ret void } ; Function Attrs: inlinehint nounwind -define internal i64 @size.176(%String* %this) #4 { - %tmp.this = alloca i64 +define internal i32 @size.166(%String* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %2 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %3 = load %"RawPtr[Char]", %"RawPtr[Char]"* %2 - %4 = call i64 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal i64 @diff(%"RawPtr[Char]"* %this, %"RawPtr[Char]" %other) #4 { +define internal i32 @diff(%"RawPtr[Char]"* %this, %"RawPtr[Char]" %other) #4 { %other.addr = alloca %"RawPtr[Char]" store %"RawPtr[Char]" %other, %"RawPtr[Char]"* %other.addr %tmp.this = alloca %UntypedPtr %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 %2 = load i8*, i8** %1 - call void @ctor.67(%UntypedPtr* %tmp.this, i8* %2) + call void @ctor.57(%UntypedPtr* %tmp.this, i8* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this %4 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %other.addr, i32 0, i32 0 %5 = load i8*, i8** %4 - call void @ctor.67(%UntypedPtr* %tmp.this1, i8* %5) + call void @ctor.57(%UntypedPtr* %tmp.this1, i8* %5) %6 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %7 = call i64 bitcast (i64 (i8*, i8*)* @ptrDiff to i64 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) - store i64 1, i64* %tmp.this2 - %8 = load i64, i64* %tmp.this2 - %9 = sdiv i64 %7, %8 - ret i64 %9 + %7 = call i32 bitcast (i32 (i8*, i8*)* @ptrDiff to i32 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) + %8 = call i32 @_Int32_opDiv(i32 %7, i32 1) + ret i32 %8 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.177(%String* %this, i64 %size) #4 { - %size.addr = alloca i64 - store i64 %size, i64* %size.addr +define internal void @ctor.167(%String* %this, i32 %size) #4 { + %size.addr = alloca i32 + store i32 %size, i32* %size.addr %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 %"$tmpForRef1" = alloca %"RawPtr[Char]" - %tmp.this2 = alloca i64 - %tmp.this3 = alloca i8 + %tmp.this = alloca i8 br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %2 = load i64, i64* %size.addr - store i64 1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = add i64 %2, %3 - %5 = call %"RawPtr[Char]" @allocRawPtr(i64 %4) - store %"RawPtr[Char]" %5, %"RawPtr[Char]"* %"$tmpForRef" - call void @ctor.178(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") - %6 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %7 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %8 = load i64, i64* %size.addr - store i64 %8, i64* %tmp.this2 - %9 = load i64, i64* %tmp.this2 - %10 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %7, i64 %9) - store %"RawPtr[Char]" %10, %"RawPtr[Char]"* %"$tmpForRef1" - call void @ctor.178(%"RawPtr[Char]"* %6, %"RawPtr[Char]"* %"$tmpForRef1") - %11 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 + %2 = load i32, i32* %size.addr + %3 = call i32 @_Int32_opPlus(i32 %2, i32 1) + %4 = call %"RawPtr[Char]" @allocRawPtr(i32 %3) + store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" + call void @ctor.168(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") + %5 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %6 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %7 = load i32, i32* %size.addr + %8 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %6, i32 %7) + store %"RawPtr[Char]" %8, %"RawPtr[Char]"* %"$tmpForRef1" + call void @ctor.168(%"RawPtr[Char]"* %5, %"RawPtr[Char]"* %"$tmpForRef1") + %9 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 + %10 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + call void @ctor.168(%"RawPtr[Char]"* %9, %"RawPtr[Char]"* %10) + store i8 0, i8* %tmp.this + %11 = load i8, i8* %tmp.this %12 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - call void @ctor.178(%"RawPtr[Char]"* %11, %"RawPtr[Char]"* %12) - store i8 0, i8* %tmp.this3 - %13 = load i8, i8* %tmp.this3 - %14 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %15 = call i8* @value(%"RawPtr[Char]"* %14) - store i8 %13, i8* %15 + %13 = call i8* @value(%"RawPtr[Char]"* %12) + store i8 %11, i8* %13 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.178(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #3 { +define internal void @ctor.168(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #3 { %other.addr = alloca %"RawPtr[Char]"* store %"RawPtr[Char]"* %other, %"RawPtr[Char]"** %other.addr br label %code @@ -5552,27 +5353,27 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Char]" @allocRawPtr(i64 %num) #4 { - %num.addr = alloca i64 - store i64 %num, i64* %num.addr +define internal %"RawPtr[Char]" @allocRawPtr(i32 %num) #4 { + %num.addr = alloca i32 + store i32 %num, i32* %num.addr %tmp.this = alloca %"RawPtr[Char]" %"$tmpForRef" = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = load i64, i64* %num.addr - %2 = mul i64 %1, 1 - %3 = call %UntypedPtr @malloc(i64 %2) + %1 = load i32, i32* %num.addr + %2 = call i32 @_Int32_opMul(i32 %1, i32 1) + %3 = call %UntypedPtr @malloc(i32 %2) store %UntypedPtr %3, %UntypedPtr* %"$tmpForRef" %4 = getelementptr inbounds %UntypedPtr, %UntypedPtr* %"$tmpForRef", i32 0, i32 0 %5 = load i8*, i8** %4 - call void @ctor.179(%"RawPtr[Char]"* %tmp.this, i8* %5) + call void @ctor.169(%"RawPtr[Char]"* %tmp.this, i8* %5) %6 = load %"RawPtr[Char]", %"RawPtr[Char]"* %tmp.this ret %"RawPtr[Char]" %6 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.179(%"RawPtr[Char]"* %this, i8* %f_ptr) #3 { +define internal void @ctor.169(%"RawPtr[Char]"* %this, i8* %f_ptr) #3 { %this.addr = alloca %"RawPtr[Char]"* store %"RawPtr[Char]"* %this, %"RawPtr[Char]"** %this.addr %f_ptr.addr = alloca i8* @@ -5588,34 +5389,28 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %tmp.this = alloca %"RawPtr[Char]" %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 - %tmp.this3 = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 %2 = load i8*, i8** %1 - call void @ctor.67(%UntypedPtr* %tmp.this1, i8* %2) + call void @ctor.57(%UntypedPtr* %tmp.this1, i8* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = load i64, i64* %n.addr - store i64 1, i64* %tmp.this3 - %5 = load i64, i64* %tmp.this3 - %6 = mul i64 %4, %5 - store i64 %6, i64* %tmp.this2 - %7 = load i64, i64* %tmp.this2 - %8 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %7) - call void @ctor.180(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %8) - %9 = load %"RawPtr[Char]", %"RawPtr[Char]"* %tmp.this - ret %"RawPtr[Char]" %9 -} + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 1) + %6 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 %5) + call void @ctor.170(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %6) + %7 = load %"RawPtr[Char]", %"RawPtr[Char]"* %tmp.this + ret %"RawPtr[Char]" %7 +} ; Function Attrs: inlinehint nounwind -define internal void @ctor.180(%"RawPtr[Char]"* %this, %UntypedPtr %p) #4 { +define internal void @ctor.170(%"RawPtr[Char]"* %this, %UntypedPtr %p) #4 { %p.addr = alloca %UntypedPtr store %UntypedPtr %p, %UntypedPtr* %p.addr br label %code @@ -5624,7 +5419,7 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 store i8* null, i8** %1 %2 = load %UntypedPtr, %UntypedPtr* %p.addr - %3 = call i8* @asRefOf.62(%UntypedPtr %2) + %3 = call i8* @asRefOf.52(%UntypedPtr %2) %4 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 store i8* %3, i8** %4 ret void @@ -5648,13 +5443,13 @@ define internal %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %this) #4 { code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 %2 = load i8*, i8** %1 - call void @ctor.67(%UntypedPtr* %tmp.this, i8* %2) + call void @ctor.57(%UntypedPtr* %tmp.this, i8* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this ret %UntypedPtr %3 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.181(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other) #3 { +define internal void @ctor.171(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other) #3 { %other.addr = alloca %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* store %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %other.addr br label %code @@ -5663,7 +5458,7 @@ code: ; preds = %0 %1 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 %2 = load %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"*, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %other.addr %3 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %2, i32 0, i32 0 - call void @ctor.182(%"RangeWithLookahead[BufferedCharSourceRange]"* %1, %"RangeWithLookahead[BufferedCharSourceRange]"* %3) + call void @ctor.172(%"RangeWithLookahead[BufferedCharSourceRange]"* %1, %"RangeWithLookahead[BufferedCharSourceRange]"* %3) %4 = load %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"*, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %other.addr %5 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %4, i32 0, i32 1 %6 = load %Location*, %Location** %5 @@ -5673,7 +5468,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.182(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %other) #3 { +define internal void @ctor.172(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %other) #3 { %other.addr = alloca %"RangeWithLookahead[BufferedCharSourceRange]"* store %"RangeWithLookahead[BufferedCharSourceRange]"* %other, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr br label %code @@ -5682,16 +5477,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 %2 = load %"RangeWithLookahead[BufferedCharSourceRange]"*, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr %3 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %2, i32 0, i32 0 - call void @ctor.183(%BufferedCharSourceRange* %1, %BufferedCharSourceRange* %3) + call void @ctor.173(%BufferedCharSourceRange* %1, %BufferedCharSourceRange* %3) %4 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 %5 = load %"RangeWithLookahead[BufferedCharSourceRange]"*, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr %6 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %5, i32 0, i32 1 - call void @ctor.184(%"Vector[Char]"* %4, %"Vector[Char]"* %6) + call void @ctor.174(%"Vector[Char]"* %4, %"Vector[Char]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.183(%BufferedCharSourceRange* %this, %BufferedCharSourceRange* %other) #3 { +define internal void @ctor.173(%BufferedCharSourceRange* %this, %BufferedCharSourceRange* %other) #3 { %other.addr = alloca %BufferedCharSourceRange* store %BufferedCharSourceRange* %other, %BufferedCharSourceRange** %other.addr br label %code @@ -5706,8 +5501,8 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.184(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { - %size = alloca i64 +define internal void @ctor.174(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { + %size = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Char]" %"$tmpForRef1" = alloca %"RawPtr[Char]" %dst = alloca %"RawPtr[Char]" @@ -5716,56 +5511,53 @@ define internal void @ctor.184(%"Vector[Char]"* %this, %"Vector[Char]"* %other) code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - call void @ctor.125(%"RawPtr[Char]"* %1) + call void @ctor.115(%"RawPtr[Char]"* %1) %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - call void @ctor.125(%"RawPtr[Char]"* %2) + call void @ctor.115(%"RawPtr[Char]"* %2) %3 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 - call void @ctor.125(%"RawPtr[Char]"* %3) - %4 = call i64 @size.185(%"Vector[Char]"* %other) - store i64 %4, i64* %size + call void @ctor.115(%"RawPtr[Char]"* %3) + %4 = call i32 @size.175(%"Vector[Char]"* %other) + store i32 %4, i32* %size %5 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - %6 = load i64, i64* %size - %7 = call %"RawPtr[Char]" @allocRawPtr(i64 %6) + %6 = load i32, i32* %size + %7 = call %"RawPtr[Char]" @allocRawPtr(i32 %6) store %"RawPtr[Char]" %7, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %5, %"RawPtr[Char]"* %"$tmpForRef") + call void @"=.176"(%"RawPtr[Char]"* %5, %"RawPtr[Char]"* %"$tmpForRef") %8 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %9 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - %10 = load i64, i64* %size - %11 = call %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %9, i64 %10) + %10 = load i32, i32* %size + %11 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %9, i32 %10) store %"RawPtr[Char]" %11, %"RawPtr[Char]"* %"$tmpForRef1" - call void @"=.186"(%"RawPtr[Char]"* %8, %"RawPtr[Char]"* %"$tmpForRef1") + call void @"=.176"(%"RawPtr[Char]"* %8, %"RawPtr[Char]"* %"$tmpForRef1") %12 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 %13 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %12, %"RawPtr[Char]"* %13) + call void @"=.176"(%"RawPtr[Char]"* %12, %"RawPtr[Char]"* %13) %14 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - call void @ctor.178(%"RawPtr[Char]"* %dst, %"RawPtr[Char]"* %14) + call void @ctor.168(%"RawPtr[Char]"* %dst, %"RawPtr[Char]"* %14) %15 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %other, i32 0, i32 0 - call void @ctor.178(%"RawPtr[Char]"* %src, %"RawPtr[Char]"* %15) + call void @ctor.168(%"RawPtr[Char]"* %src, %"RawPtr[Char]"* %15) %16 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %dst) %17 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %src) - %18 = load i64, i64* %size - %19 = mul i64 %18, 1 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %16, %UntypedPtr %17, i64 %19) + %18 = load i32, i32* %size + %19 = call i32 @_Int32_opMul(i32 %18, i32 1) + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %16, %UntypedPtr %17, i32 %19) ret void } ; Function Attrs: inlinehint nounwind -define internal i64 @size.185(%"Vector[Char]"* %this) #4 { - %tmp.this = alloca i64 +define internal i32 @size.175(%"Vector[Char]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 %3 = load %"RawPtr[Char]", %"RawPtr[Char]"* %2 - %4 = call i64 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) + ret i32 %4 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.186"(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #3 { +define internal void @"=.176"(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #3 { %other.addr = alloca %"RawPtr[Char]"* store %"RawPtr[Char]"* %other, %"RawPtr[Char]"** %other.addr br label %code @@ -5779,29 +5571,8 @@ code: ; preds = %0 ret void } -; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %tmp.this = alloca %"RawPtr[Char]" - %tmp.this1 = alloca %UntypedPtr - br label %code - -code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 - %2 = load i8*, i8** %1 - call void @ctor.67(%UntypedPtr* %tmp.this1, i8* %2) - %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 1 - %6 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %5) - call void @ctor.180(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %6) - %7 = load %"RawPtr[Char]", %"RawPtr[Char]"* %tmp.this - ret %"RawPtr[Char]" %7 -} - ; Function Attrs: alwaysinline nounwind -define internal void @ctor.188(%Token* %this, %Token* %other) #3 { +define internal void @ctor.177(%Token* %this, %Token* %other) #3 { %other.addr = alloca %Token* store %Token* %other, %Token** %other.addr br label %code @@ -5810,15 +5581,15 @@ code: ; preds = %0 %1 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 0 %2 = load %Token*, %Token** %other.addr %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 0 - call void @ctor.169(%Location* %1, %Location* %3) + call void @ctor.159(%Location* %1, %Location* %3) %4 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 1 %5 = load %Token*, %Token** %other.addr %6 = getelementptr inbounds %Token, %Token* %5, i32 0, i32 1 - call void @ctor.189(%TokenType* %4, %TokenType* %6) + call void @ctor.178(%TokenType* %4, %TokenType* %6) %7 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 2 %8 = load %Token*, %Token** %other.addr %9 = getelementptr inbounds %Token, %Token* %8, i32 0, i32 2 - call void @ctor.175(%String* %7, %String* %9) + call void @ctor.165(%String* %7, %String* %9) %10 = load %Token*, %Token** %other.addr %11 = getelementptr inbounds %Token, %Token* %10, i32 0, i32 3 %12 = load i64, i64* %11 @@ -5833,7 +5604,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.189(%TokenType* %this, %TokenType* %other) #3 { +define internal void @ctor.178(%TokenType* %this, %TokenType* %other) #3 { %other.addr = alloca %TokenType* store %TokenType* %other, %TokenType** %other.addr br label %code @@ -5848,7 +5619,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.190(%ErrorReporter* %this, %ErrorReporter* %other) #3 { +define internal void @ctor.179(%ErrorReporter* %this, %ErrorReporter* %other) #3 { %other.addr = alloca %ErrorReporter* store %ErrorReporter* %other, %ErrorReporter** %other.addr br label %code @@ -5858,16 +5629,16 @@ code: ; preds = %0 %2 = load %ErrorReporter*, %ErrorReporter** %other.addr %3 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) %5 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %this, i32 0, i32 1 %6 = load %ErrorReporter*, %ErrorReporter** %other.addr %7 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %6, i32 0, i32 1 - call void @ctor.191(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %5, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %7) + call void @ctor.180(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %5, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %7) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.191(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other) #3 { +define internal void @ctor.180(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* store %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"** %other.addr br label %code @@ -5877,12 +5648,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"*, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.192(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %other) #3 { +define internal void @ctor.181(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %other) #3 { %other.addr = alloca %"SparrowLayoutDecoder[SparrowScanner]"* store %"SparrowLayoutDecoder[SparrowScanner]"* %other, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr br label %code @@ -5891,23 +5662,23 @@ code: ; preds = %0 %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 %2 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %3 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %2, i32 0, i32 0 - call void @ctor.193(%"RangeWithLookahead[SparrowScanner]"* %1, %"RangeWithLookahead[SparrowScanner]"* %3) + call void @ctor.182(%"RangeWithLookahead[SparrowScanner]"* %1, %"RangeWithLookahead[SparrowScanner]"* %3) %4 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 1 %5 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %6 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %5, i32 0, i32 1 - call void @ctor.190(%ErrorReporter* %4, %ErrorReporter* %6) + call void @ctor.179(%ErrorReporter* %4, %ErrorReporter* %6) %7 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 %8 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %9 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %8, i32 0, i32 2 - call void @ctor.208(%"Vector[UInt]"* %7, %"Vector[UInt]"* %9) + call void @ctor.197(%"Vector[Int]"* %7, %"Vector[Int]"* %9) %10 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 %11 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %12 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %11, i32 0, i32 3 - call void @ctor.184(%"Vector[Char]"* %10, %"Vector[Char]"* %12) + call void @ctor.174(%"Vector[Char]"* %10, %"Vector[Char]"* %12) %13 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 %14 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %15 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %14, i32 0, i32 4 - call void @ctor.189(%TokenType* %13, %TokenType* %15) + call void @ctor.178(%TokenType* %13, %TokenType* %15) %16 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %17 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %16, i32 0, i32 5 %18 = load i32, i32* %17 @@ -5917,7 +5688,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.193(%"RangeWithLookahead[SparrowScanner]"* %this, %"RangeWithLookahead[SparrowScanner]"* %other) #3 { +define internal void @ctor.182(%"RangeWithLookahead[SparrowScanner]"* %this, %"RangeWithLookahead[SparrowScanner]"* %other) #3 { %other.addr = alloca %"RangeWithLookahead[SparrowScanner]"* store %"RangeWithLookahead[SparrowScanner]"* %other, %"RangeWithLookahead[SparrowScanner]"** %other.addr br label %code @@ -5926,17 +5697,17 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 %2 = load %"RangeWithLookahead[SparrowScanner]"*, %"RangeWithLookahead[SparrowScanner]"** %other.addr %3 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %2, i32 0, i32 0 - call void @ctor.168(%SparrowScanner* %1, %SparrowScanner* %3) + call void @ctor.158(%SparrowScanner* %1, %SparrowScanner* %3) %4 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 %5 = load %"RangeWithLookahead[SparrowScanner]"*, %"RangeWithLookahead[SparrowScanner]"** %other.addr %6 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %5, i32 0, i32 1 - call void @ctor.194(%"Vector[Token]"* %4, %"Vector[Token]"* %6) + call void @ctor.183(%"Vector[Token]"* %4, %"Vector[Token]"* %6) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.194(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { - %size = alloca i64 +define internal void @ctor.183(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { + %size = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Token]" %"$tmpForRef1" = alloca %"RawPtr[Token]" %dst = alloca %"RawPtr[Token]" @@ -5947,49 +5718,49 @@ define internal void @ctor.194(%"Vector[Token]"* %this, %"Vector[Token]"* %other code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - call void @ctor.137(%"RawPtr[Token]"* %1) + call void @ctor.127(%"RawPtr[Token]"* %1) %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - call void @ctor.137(%"RawPtr[Token]"* %2) + call void @ctor.127(%"RawPtr[Token]"* %2) %3 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 - call void @ctor.137(%"RawPtr[Token]"* %3) - %4 = call i64 @size.195(%"Vector[Token]"* %other) - store i64 %4, i64* %size + call void @ctor.127(%"RawPtr[Token]"* %3) + %4 = call i32 @size.184(%"Vector[Token]"* %other) + store i32 %4, i32* %size %5 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %6 = load i64, i64* %size - %7 = call %"RawPtr[Token]" @allocRawPtr.199(i64 %6) + %6 = load i32, i32* %size + %7 = call %"RawPtr[Token]" @allocRawPtr.188(i32 %6) store %"RawPtr[Token]" %7, %"RawPtr[Token]"* %"$tmpForRef" - call void @"=.198"(%"RawPtr[Token]"* %5, %"RawPtr[Token]"* %"$tmpForRef") + call void @"=.187"(%"RawPtr[Token]"* %5, %"RawPtr[Token]"* %"$tmpForRef") %8 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %9 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %10 = load i64, i64* %size - %11 = call %"RawPtr[Token]" @advance.201(%"RawPtr[Token]"* %9, i64 %10) + %10 = load i32, i32* %size + %11 = call %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %9, i32 %10) store %"RawPtr[Token]" %11, %"RawPtr[Token]"* %"$tmpForRef1" - call void @"=.198"(%"RawPtr[Token]"* %8, %"RawPtr[Token]"* %"$tmpForRef1") + call void @"=.187"(%"RawPtr[Token]"* %8, %"RawPtr[Token]"* %"$tmpForRef1") %12 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 %13 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - call void @"=.198"(%"RawPtr[Token]"* %12, %"RawPtr[Token]"* %13) + call void @"=.187"(%"RawPtr[Token]"* %12, %"RawPtr[Token]"* %13) %14 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - call void @ctor.204(%"RawPtr[Token]"* %dst, %"RawPtr[Token]"* %14) + call void @ctor.193(%"RawPtr[Token]"* %dst, %"RawPtr[Token]"* %14) %15 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %other, i32 0, i32 0 - call void @ctor.204(%"RawPtr[Token]"* %src, %"RawPtr[Token]"* %15) + call void @ctor.193(%"RawPtr[Token]"* %src, %"RawPtr[Token]"* %15) br label %while_block while_block: ; preds = %while_step, %code %16 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %17 = call i1 @"==.205"(%"RawPtr[Token]"* %dst, %"RawPtr[Token]"* %16) + %17 = call i1 @"==.194"(%"RawPtr[Token]"* %dst, %"RawPtr[Token]"* %16) %18 = xor i1 true, %17 br i1 %18, label %while_body, label %while_end while_body: ; preds = %while_block - %19 = call %Token* @value.206(%"RawPtr[Token]"* %dst) - %20 = call %Token* @value.206(%"RawPtr[Token]"* %src) - call void @ctor.188(%Token* %19, %Token* %20) - %21 = call %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %dst) + %19 = call %Token* @value.195(%"RawPtr[Token]"* %dst) + %20 = call %Token* @value.195(%"RawPtr[Token]"* %src) + call void @ctor.177(%Token* %19, %Token* %20) + %21 = call %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %dst) store %"RawPtr[Token]" %21, %"RawPtr[Token]"* %"$tmpForRef2" - call void @"=.198"(%"RawPtr[Token]"* %dst, %"RawPtr[Token]"* %"$tmpForRef2") - %22 = call %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %src) + call void @"=.187"(%"RawPtr[Token]"* %dst, %"RawPtr[Token]"* %"$tmpForRef2") + %22 = call %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %src) store %"RawPtr[Token]" %22, %"RawPtr[Token]"* %"$tmpForRef3" - call void @"=.198"(%"RawPtr[Token]"* %src, %"RawPtr[Token]"* %"$tmpForRef3") + call void @"=.187"(%"RawPtr[Token]"* %src, %"RawPtr[Token]"* %"$tmpForRef3") br label %while_step while_step: ; preds = %while_body @@ -6000,47 +5771,41 @@ while_end: ; preds = %while_block } ; Function Attrs: inlinehint nounwind -define internal i64 @size.195(%"Vector[Token]"* %this) #4 { - %tmp.this = alloca i64 +define internal i32 @size.184(%"Vector[Token]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 %3 = load %"RawPtr[Token]", %"RawPtr[Token]"* %2 - %4 = call i64 @diff.196(%"RawPtr[Token]"* %1, %"RawPtr[Token]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff.185(%"RawPtr[Token]"* %1, %"RawPtr[Token]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal i64 @diff.196(%"RawPtr[Token]"* %this, %"RawPtr[Token]" %other) #4 { +define internal i32 @diff.185(%"RawPtr[Token]"* %this, %"RawPtr[Token]" %other) #4 { %other.addr = alloca %"RawPtr[Token]" store %"RawPtr[Token]" %other, %"RawPtr[Token]"* %other.addr %tmp.this = alloca %UntypedPtr %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 %2 = load %Token*, %Token** %1 - call void @ctor.197(%UntypedPtr* %tmp.this, %Token* %2) + call void @ctor.186(%UntypedPtr* %tmp.this, %Token* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this %4 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %other.addr, i32 0, i32 0 %5 = load %Token*, %Token** %4 - call void @ctor.197(%UntypedPtr* %tmp.this1, %Token* %5) + call void @ctor.186(%UntypedPtr* %tmp.this1, %Token* %5) %6 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %7 = call i64 bitcast (i64 (i8*, i8*)* @ptrDiff to i64 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) - store i64 72, i64* %tmp.this2 - %8 = load i64, i64* %tmp.this2 - %9 = sdiv i64 %7, %8 - ret i64 %9 + %7 = call i32 bitcast (i32 (i8*, i8*)* @ptrDiff to i32 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) + %8 = call i32 @_Int32_opDiv(i32 %7, i32 72) + ret i32 %8 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.197(%UntypedPtr* %this, %Token* %val) #4 { +define internal void @ctor.186(%UntypedPtr* %this, %Token* %val) #4 { %val.addr = alloca %Token* store %Token* %val, %Token** %val.addr br label %code @@ -6056,7 +5821,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.198"(%"RawPtr[Token]"* %this, %"RawPtr[Token]"* %other) #3 { +define internal void @"=.187"(%"RawPtr[Token]"* %this, %"RawPtr[Token]"* %other) #3 { %other.addr = alloca %"RawPtr[Token]"* store %"RawPtr[Token]"* %other, %"RawPtr[Token]"** %other.addr br label %code @@ -6071,28 +5836,28 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Token]" @allocRawPtr.199(i64 %num) #4 { - %num.addr = alloca i64 - store i64 %num, i64* %num.addr +define internal %"RawPtr[Token]" @allocRawPtr.188(i32 %num) #4 { + %num.addr = alloca i32 + store i32 %num, i32* %num.addr %tmp.this = alloca %"RawPtr[Token]" %"$tmpForRef" = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = load i64, i64* %num.addr - %2 = mul i64 %1, 72 - %3 = call %UntypedPtr @malloc(i64 %2) + %1 = load i32, i32* %num.addr + %2 = call i32 @_Int32_opMul(i32 %1, i32 72) + %3 = call %UntypedPtr @malloc(i32 %2) store %UntypedPtr %3, %UntypedPtr* %"$tmpForRef" %4 = getelementptr inbounds %UntypedPtr, %UntypedPtr* %"$tmpForRef", i32 0, i32 0 %5 = load i8*, i8** %4 %6 = bitcast i8* %5 to %Token* - call void @ctor.200(%"RawPtr[Token]"* %tmp.this, %Token* %6) + call void @ctor.189(%"RawPtr[Token]"* %tmp.this, %Token* %6) %7 = load %"RawPtr[Token]", %"RawPtr[Token]"* %tmp.this ret %"RawPtr[Token]" %7 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.200(%"RawPtr[Token]"* %this, %Token* %f_ptr) #3 { +define internal void @ctor.189(%"RawPtr[Token]"* %this, %Token* %f_ptr) #3 { %this.addr = alloca %"RawPtr[Token]"* store %"RawPtr[Token]"* %this, %"RawPtr[Token]"** %this.addr %f_ptr.addr = alloca %Token* @@ -6108,9 +5873,9 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Token]" @advance.201(%"RawPtr[Token]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %tmp.this = alloca %"RawPtr[Token]" %tmp.this1 = alloca %UntypedPtr br label %code @@ -6118,18 +5883,18 @@ define internal %"RawPtr[Token]" @advance.201(%"RawPtr[Token]"* %this, i64 %n) # code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 %2 = load %Token*, %Token** %1 - call void @ctor.197(%UntypedPtr* %tmp.this1, %Token* %2) + call void @ctor.186(%UntypedPtr* %tmp.this1, %Token* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 72 - %6 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %5) - call void @ctor.202(%"RawPtr[Token]"* %tmp.this, %UntypedPtr %6) + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 72) + %6 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 %5) + call void @ctor.191(%"RawPtr[Token]"* %tmp.this, %UntypedPtr %6) %7 = load %"RawPtr[Token]", %"RawPtr[Token]"* %tmp.this ret %"RawPtr[Token]" %7 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.202(%"RawPtr[Token]"* %this, %UntypedPtr %p) #4 { +define internal void @ctor.191(%"RawPtr[Token]"* %this, %UntypedPtr %p) #4 { %p.addr = alloca %UntypedPtr store %UntypedPtr %p, %UntypedPtr* %p.addr br label %code @@ -6138,14 +5903,14 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 store %Token* null, %Token** %1 %2 = load %UntypedPtr, %UntypedPtr* %p.addr - %3 = call %Token* @asRefOf.203(%UntypedPtr %2) + %3 = call %Token* @asRefOf.192(%UntypedPtr %2) %4 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 store %Token* %3, %Token** %4 ret void } ; Function Attrs: inlinehint nounwind -define internal %Token* @asRefOf.203(%UntypedPtr %this) #4 { +define internal %Token* @asRefOf.192(%UntypedPtr %this) #4 { %this.addr = alloca %UntypedPtr store %UntypedPtr %this, %UntypedPtr* %this.addr br label %code @@ -6158,7 +5923,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.204(%"RawPtr[Token]"* %this, %"RawPtr[Token]"* %other) #3 { +define internal void @ctor.193(%"RawPtr[Token]"* %this, %"RawPtr[Token]"* %other) #3 { %other.addr = alloca %"RawPtr[Token]"* store %"RawPtr[Token]"* %other, %"RawPtr[Token]"** %other.addr br label %code @@ -6173,7 +5938,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.205"(%"RawPtr[Token]"* %this, %"RawPtr[Token]"* %other) #3 { +define internal i1 @"==.194"(%"RawPtr[Token]"* %this, %"RawPtr[Token]"* %other) #3 { %this.addr = alloca %"RawPtr[Token]"* store %"RawPtr[Token]"* %this, %"RawPtr[Token]"** %this.addr %other.addr = alloca %"RawPtr[Token]"* @@ -6194,7 +5959,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %Token* @value.206(%"RawPtr[Token]"* %this) #4 { +define internal %Token* @value.195(%"RawPtr[Token]"* %this) #4 { br label %code code: ; preds = %0 @@ -6204,7 +5969,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %this) #4 { +define internal %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %this) #4 { %tmp.this = alloca %"RawPtr[Token]" %tmp.this1 = alloca %UntypedPtr br label %code @@ -6212,100 +5977,94 @@ define internal %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %this) #4 { code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 %2 = load %Token*, %Token** %1 - call void @ctor.197(%UntypedPtr* %tmp.this1, %Token* %2) + call void @ctor.186(%UntypedPtr* %tmp.this1, %Token* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 72) - call void @ctor.202(%"RawPtr[Token]"* %tmp.this, %UntypedPtr %4) + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 72) + call void @ctor.191(%"RawPtr[Token]"* %tmp.this, %UntypedPtr %4) %5 = load %"RawPtr[Token]", %"RawPtr[Token]"* %tmp.this ret %"RawPtr[Token]" %5 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.208(%"Vector[UInt]"* %this, %"Vector[UInt]"* %other) #4 { - %size = alloca i64 - %"$tmpForRef" = alloca %"RawPtr[UInt]" - %"$tmpForRef1" = alloca %"RawPtr[UInt]" - %dst = alloca %"RawPtr[UInt]" - %src = alloca %"RawPtr[UInt]" - br label %code - -code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - call void @ctor.139(%"RawPtr[UInt]"* %1) - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - call void @ctor.139(%"RawPtr[UInt]"* %2) - %3 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - call void @ctor.139(%"RawPtr[UInt]"* %3) - %4 = call i64 @size.209(%"Vector[UInt]"* %other) - store i64 %4, i64* %size - %5 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %6 = load i64, i64* %size - %7 = call %"RawPtr[UInt]" @allocRawPtr.213(i64 %6) - store %"RawPtr[UInt]" %7, %"RawPtr[UInt]"* %"$tmpForRef" - call void @"=.212"(%"RawPtr[UInt]"* %5, %"RawPtr[UInt]"* %"$tmpForRef") - %8 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %9 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %10 = load i64, i64* %size - %11 = call %"RawPtr[UInt]" @advance.215(%"RawPtr[UInt]"* %9, i64 %10) - store %"RawPtr[UInt]" %11, %"RawPtr[UInt]"* %"$tmpForRef1" - call void @"=.212"(%"RawPtr[UInt]"* %8, %"RawPtr[UInt]"* %"$tmpForRef1") - %12 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - %13 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - call void @"=.212"(%"RawPtr[UInt]"* %12, %"RawPtr[UInt]"* %13) - %14 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - call void @ctor.218(%"RawPtr[UInt]"* %dst, %"RawPtr[UInt]"* %14) - %15 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %other, i32 0, i32 0 - call void @ctor.218(%"RawPtr[UInt]"* %src, %"RawPtr[UInt]"* %15) - %16 = call %UntypedPtr @untypedPtr.219(%"RawPtr[UInt]"* %dst) - %17 = call %UntypedPtr @untypedPtr.219(%"RawPtr[UInt]"* %src) - %18 = load i64, i64* %size - %19 = mul i64 %18, 4 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %16, %UntypedPtr %17, i64 %19) - ret void -} - -; Function Attrs: inlinehint nounwind -define internal i64 @size.209(%"Vector[UInt]"* %this) #4 { - %tmp.this = alloca i64 +define internal void @ctor.197(%"Vector[Int]"* %this, %"Vector[Int]"* %other) #4 { + %size = alloca i32 + %"$tmpForRef" = alloca %"RawPtr[Int]" + %"$tmpForRef1" = alloca %"RawPtr[Int]" + %dst = alloca %"RawPtr[Int]" + %src = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %3 = load %"RawPtr[UInt]", %"RawPtr[UInt]"* %2 - %4 = call i64 @diff.210(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + call void @ctor.129(%"RawPtr[Int]"* %1) + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + call void @ctor.129(%"RawPtr[Int]"* %2) + %3 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + call void @ctor.129(%"RawPtr[Int]"* %3) + %4 = call i32 @size.198(%"Vector[Int]"* %other) + store i32 %4, i32* %size + %5 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %6 = load i32, i32* %size + %7 = call %"RawPtr[Int]" @allocRawPtr.202(i32 %6) + store %"RawPtr[Int]" %7, %"RawPtr[Int]"* %"$tmpForRef" + call void @"=.201"(%"RawPtr[Int]"* %5, %"RawPtr[Int]"* %"$tmpForRef") + %8 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %9 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %10 = load i32, i32* %size + %11 = call %"RawPtr[Int]" @advance.204(%"RawPtr[Int]"* %9, i32 %10) + store %"RawPtr[Int]" %11, %"RawPtr[Int]"* %"$tmpForRef1" + call void @"=.201"(%"RawPtr[Int]"* %8, %"RawPtr[Int]"* %"$tmpForRef1") + %12 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + %13 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + call void @"=.201"(%"RawPtr[Int]"* %12, %"RawPtr[Int]"* %13) + %14 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + call void @ctor.207(%"RawPtr[Int]"* %dst, %"RawPtr[Int]"* %14) + %15 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %other, i32 0, i32 0 + call void @ctor.207(%"RawPtr[Int]"* %src, %"RawPtr[Int]"* %15) + %16 = call %UntypedPtr @untypedPtr.208(%"RawPtr[Int]"* %dst) + %17 = call %UntypedPtr @untypedPtr.208(%"RawPtr[Int]"* %src) + %18 = load i32, i32* %size + %19 = call i32 @_Int32_opMul(i32 %18, i32 4) + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %16, %UntypedPtr %17, i32 %19) + ret void +} + +; Function Attrs: inlinehint nounwind +define internal i32 @size.198(%"Vector[Int]"* %this) #4 { + br label %code + +code: ; preds = %0 + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %3 = load %"RawPtr[Int]", %"RawPtr[Int]"* %2 + %4 = call i32 @diff.199(%"RawPtr[Int]"* %1, %"RawPtr[Int]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal i64 @diff.210(%"RawPtr[UInt]"* %this, %"RawPtr[UInt]" %other) #4 { - %other.addr = alloca %"RawPtr[UInt]" - store %"RawPtr[UInt]" %other, %"RawPtr[UInt]"* %other.addr +define internal i32 @diff.199(%"RawPtr[Int]"* %this, %"RawPtr[Int]" %other) #4 { + %other.addr = alloca %"RawPtr[Int]" + store %"RawPtr[Int]" %other, %"RawPtr[Int]"* %other.addr %tmp.this = alloca %UntypedPtr %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %2 = load i32*, i32** %1 - call void @ctor.211(%UntypedPtr* %tmp.this, i32* %2) + call void @ctor.200(%UntypedPtr* %tmp.this, i32* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this - %4 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %other.addr, i32 0, i32 0 + %4 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %other.addr, i32 0, i32 0 %5 = load i32*, i32** %4 - call void @ctor.211(%UntypedPtr* %tmp.this1, i32* %5) + call void @ctor.200(%UntypedPtr* %tmp.this1, i32* %5) %6 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %7 = call i64 bitcast (i64 (i8*, i8*)* @ptrDiff to i64 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) - store i64 4, i64* %tmp.this2 - %8 = load i64, i64* %tmp.this2 - %9 = sdiv i64 %7, %8 - ret i64 %9 + %7 = call i32 bitcast (i32 (i8*, i8*)* @ptrDiff to i32 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) + %8 = call i32 @_Int32_opDiv(i32 %7, i32 4) + ret i32 %8 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.211(%UntypedPtr* %this, i32* %val) #4 { +define internal void @ctor.200(%UntypedPtr* %this, i32* %val) #4 { %val.addr = alloca i32* store i32* %val, i32** %val.addr br label %code @@ -6321,96 +6080,96 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.212"(%"RawPtr[UInt]"* %this, %"RawPtr[UInt]"* %other) #3 { - %other.addr = alloca %"RawPtr[UInt]"* - store %"RawPtr[UInt]"* %other, %"RawPtr[UInt]"** %other.addr +define internal void @"=.201"(%"RawPtr[Int]"* %this, %"RawPtr[Int]"* %other) #3 { + %other.addr = alloca %"RawPtr[Int]"* + store %"RawPtr[Int]"* %other, %"RawPtr[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"RawPtr[UInt]"*, %"RawPtr[UInt]"** %other.addr - %2 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %1, i32 0, i32 0 + %1 = load %"RawPtr[Int]"*, %"RawPtr[Int]"** %other.addr + %2 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %1, i32 0, i32 0 %3 = load i32*, i32** %2 - %4 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %4 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 store i32* %3, i32** %4 ret void } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[UInt]" @allocRawPtr.213(i64 %num) #4 { - %num.addr = alloca i64 - store i64 %num, i64* %num.addr - %tmp.this = alloca %"RawPtr[UInt]" +define internal %"RawPtr[Int]" @allocRawPtr.202(i32 %num) #4 { + %num.addr = alloca i32 + store i32 %num, i32* %num.addr + %tmp.this = alloca %"RawPtr[Int]" %"$tmpForRef" = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = load i64, i64* %num.addr - %2 = mul i64 %1, 4 - %3 = call %UntypedPtr @malloc(i64 %2) + %1 = load i32, i32* %num.addr + %2 = call i32 @_Int32_opMul(i32 %1, i32 4) + %3 = call %UntypedPtr @malloc(i32 %2) store %UntypedPtr %3, %UntypedPtr* %"$tmpForRef" %4 = getelementptr inbounds %UntypedPtr, %UntypedPtr* %"$tmpForRef", i32 0, i32 0 %5 = load i8*, i8** %4 %6 = bitcast i8* %5 to i32* - call void @ctor.214(%"RawPtr[UInt]"* %tmp.this, i32* %6) - %7 = load %"RawPtr[UInt]", %"RawPtr[UInt]"* %tmp.this - ret %"RawPtr[UInt]" %7 + call void @ctor.203(%"RawPtr[Int]"* %tmp.this, i32* %6) + %7 = load %"RawPtr[Int]", %"RawPtr[Int]"* %tmp.this + ret %"RawPtr[Int]" %7 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.214(%"RawPtr[UInt]"* %this, i32* %f_ptr) #3 { - %this.addr = alloca %"RawPtr[UInt]"* - store %"RawPtr[UInt]"* %this, %"RawPtr[UInt]"** %this.addr +define internal void @ctor.203(%"RawPtr[Int]"* %this, i32* %f_ptr) #3 { + %this.addr = alloca %"RawPtr[Int]"* + store %"RawPtr[Int]"* %this, %"RawPtr[Int]"** %this.addr %f_ptr.addr = alloca i32* store i32* %f_ptr, i32** %f_ptr.addr br label %code code: ; preds = %0 %1 = load i32*, i32** %f_ptr.addr - %2 = load %"RawPtr[UInt]"*, %"RawPtr[UInt]"** %this.addr - %3 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %2, i32 0, i32 0 + %2 = load %"RawPtr[Int]"*, %"RawPtr[Int]"** %this.addr + %3 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %2, i32 0, i32 0 store i32* %1, i32** %3 ret void } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[UInt]" @advance.215(%"RawPtr[UInt]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %tmp.this = alloca %"RawPtr[UInt]" +define internal %"RawPtr[Int]" @advance.204(%"RawPtr[Int]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %tmp.this = alloca %"RawPtr[Int]" %tmp.this1 = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %2 = load i32*, i32** %1 - call void @ctor.211(%UntypedPtr* %tmp.this1, i32* %2) + call void @ctor.200(%UntypedPtr* %tmp.this1, i32* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 4 - %6 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %5) - call void @ctor.216(%"RawPtr[UInt]"* %tmp.this, %UntypedPtr %6) - %7 = load %"RawPtr[UInt]", %"RawPtr[UInt]"* %tmp.this - ret %"RawPtr[UInt]" %7 + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 4) + %6 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 %5) + call void @ctor.205(%"RawPtr[Int]"* %tmp.this, %UntypedPtr %6) + %7 = load %"RawPtr[Int]", %"RawPtr[Int]"* %tmp.this + ret %"RawPtr[Int]" %7 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.216(%"RawPtr[UInt]"* %this, %UntypedPtr %p) #4 { +define internal void @ctor.205(%"RawPtr[Int]"* %this, %UntypedPtr %p) #4 { %p.addr = alloca %UntypedPtr store %UntypedPtr %p, %UntypedPtr* %p.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 store i32* null, i32** %1 %2 = load %UntypedPtr, %UntypedPtr* %p.addr - %3 = call i32* @asRefOf.217(%UntypedPtr %2) - %4 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %3 = call i32* @asRefOf.206(%UntypedPtr %2) + %4 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 store i32* %3, i32** %4 ret void } ; Function Attrs: inlinehint nounwind -define internal i32* @asRefOf.217(%UntypedPtr %this) #4 { +define internal i32* @asRefOf.206(%UntypedPtr %this) #4 { %this.addr = alloca %UntypedPtr store %UntypedPtr %this, %UntypedPtr* %this.addr br label %code @@ -6423,35 +6182,35 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.218(%"RawPtr[UInt]"* %this, %"RawPtr[UInt]"* %other) #3 { - %other.addr = alloca %"RawPtr[UInt]"* - store %"RawPtr[UInt]"* %other, %"RawPtr[UInt]"** %other.addr +define internal void @ctor.207(%"RawPtr[Int]"* %this, %"RawPtr[Int]"* %other) #3 { + %other.addr = alloca %"RawPtr[Int]"* + store %"RawPtr[Int]"* %other, %"RawPtr[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"RawPtr[UInt]"*, %"RawPtr[UInt]"** %other.addr - %2 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %1, i32 0, i32 0 + %1 = load %"RawPtr[Int]"*, %"RawPtr[Int]"** %other.addr + %2 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %1, i32 0, i32 0 %3 = load i32*, i32** %2 - %4 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %4 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 store i32* %3, i32** %4 ret void } ; Function Attrs: inlinehint nounwind -define internal %UntypedPtr @untypedPtr.219(%"RawPtr[UInt]"* %this) #4 { +define internal %UntypedPtr @untypedPtr.208(%"RawPtr[Int]"* %this) #4 { %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %2 = load i32*, i32** %1 - call void @ctor.211(%UntypedPtr* %tmp.this, i32* %2) + call void @ctor.200(%UntypedPtr* %tmp.this, i32* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this ret %UntypedPtr %3 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.220(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { +define internal void @ctor.209(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { %other.addr = alloca %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* store %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr br label %code @@ -6460,11 +6219,11 @@ code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 %2 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %2, i32 0, i32 0 - call void @ctor.221(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %3) + call void @ctor.210(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %3) %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %5 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %6 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %5, i32 0, i32 1 - call void @ctor.188(%Token* %4, %Token* %6) + call void @ctor.177(%Token* %4, %Token* %6) %7 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %8 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, i32 0, i32 2 %9 = load i1, i1* %8 @@ -6473,16 +6232,16 @@ code: ; preds = %0 %11 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %12 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %13 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %12, i32 0, i32 3 - call void @ctor.222(%AstBuilder* %11, %AstBuilder* %13) + call void @ctor.211(%AstBuilder* %11, %AstBuilder* %13) %14 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 4 %15 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %16 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %15, i32 0, i32 4 - call void @ctor.190(%ErrorReporter* %14, %ErrorReporter* %16) + call void @ctor.179(%ErrorReporter* %14, %ErrorReporter* %16) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.221(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { +define internal void @ctor.210(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { %other.addr = alloca %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* store %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr br label %code @@ -6491,16 +6250,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 %2 = load %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"*, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %3 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2, i32 0, i32 0 - call void @ctor.192(%"SparrowLayoutDecoder[SparrowScanner]"* %1, %"SparrowLayoutDecoder[SparrowScanner]"* %3) + call void @ctor.181(%"SparrowLayoutDecoder[SparrowScanner]"* %1, %"SparrowLayoutDecoder[SparrowScanner]"* %3) %4 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %5 = load %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"*, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %6 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %5, i32 0, i32 1 - call void @ctor.194(%"Vector[Token]"* %4, %"Vector[Token]"* %6) + call void @ctor.183(%"Vector[Token]"* %4, %"Vector[Token]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.222(%AstBuilder* %this, %AstBuilder* %other) #3 { +define internal void @ctor.211(%AstBuilder* %this, %AstBuilder* %other) #3 { %other.addr = alloca %AstBuilder* store %AstBuilder* %other, %AstBuilder** %other.addr br label %code @@ -6510,172 +6269,172 @@ code: ; preds = %0 %2 = load %AstBuilder*, %AstBuilder** %other.addr %3 = getelementptr inbounds %AstBuilder, %AstBuilder* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) %5 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 1 %6 = load %AstBuilder*, %AstBuilder** %other.addr %7 = getelementptr inbounds %AstBuilder, %AstBuilder* %6, i32 0, i32 1 - call void @ctor.223(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %5, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %7) + call void @ctor.212(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %5, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %7) %8 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 2 %9 = load %AstBuilder*, %AstBuilder** %other.addr %10 = getelementptr inbounds %AstBuilder, %AstBuilder* %9, i32 0, i32 2 - call void @ctor.224(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %8, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %10) + call void @ctor.213(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %8, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %10) %11 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 3 %12 = load %AstBuilder*, %AstBuilder** %other.addr %13 = getelementptr inbounds %AstBuilder, %AstBuilder* %12, i32 0, i32 3 - call void @ctor.224(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %11, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %13) + call void @ctor.213(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %11, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %13) %14 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 4 %15 = load %AstBuilder*, %AstBuilder** %other.addr %16 = getelementptr inbounds %AstBuilder, %AstBuilder* %15, i32 0, i32 4 - call void @ctor.225(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %14, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %16) + call void @ctor.214(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %14, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %16) %17 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 5 %18 = load %AstBuilder*, %AstBuilder** %other.addr %19 = getelementptr inbounds %AstBuilder, %AstBuilder* %18, i32 0, i32 5 - call void @ctor.226(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %17, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %19) + call void @ctor.215(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %17, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %19) %20 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 6 %21 = load %AstBuilder*, %AstBuilder** %other.addr %22 = getelementptr inbounds %AstBuilder, %AstBuilder* %21, i32 0, i32 6 - call void @ctor.227(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %20, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %22) + call void @ctor.216(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %20, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %22) %23 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 7 %24 = load %AstBuilder*, %AstBuilder** %other.addr %25 = getelementptr inbounds %AstBuilder, %AstBuilder* %24, i32 0, i32 7 - call void @ctor.228(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %23, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %25) + call void @ctor.217(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %23, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %25) %26 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 8 %27 = load %AstBuilder*, %AstBuilder** %other.addr %28 = getelementptr inbounds %AstBuilder, %AstBuilder* %27, i32 0, i32 8 - call void @ctor.225(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %26, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %28) + call void @ctor.214(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %26, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %28) %29 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 9 %30 = load %AstBuilder*, %AstBuilder** %other.addr %31 = getelementptr inbounds %AstBuilder, %AstBuilder* %30, i32 0, i32 9 - call void @ctor.229(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %29, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %31) + call void @ctor.218(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %29, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %31) %32 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 10 %33 = load %AstBuilder*, %AstBuilder** %other.addr %34 = getelementptr inbounds %AstBuilder, %AstBuilder* %33, i32 0, i32 10 - call void @ctor.225(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %32, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %34) + call void @ctor.214(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %32, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %34) %35 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 11 %36 = load %AstBuilder*, %AstBuilder** %other.addr %37 = getelementptr inbounds %AstBuilder, %AstBuilder* %36, i32 0, i32 11 - call void @ctor.225(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %35, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %37) + call void @ctor.214(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %35, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %37) %38 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 12 %39 = load %AstBuilder*, %AstBuilder** %other.addr %40 = getelementptr inbounds %AstBuilder, %AstBuilder* %39, i32 0, i32 12 - call void @ctor.225(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %38, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %40) + call void @ctor.214(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %38, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %40) %41 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 13 %42 = load %AstBuilder*, %AstBuilder** %other.addr %43 = getelementptr inbounds %AstBuilder, %AstBuilder* %42, i32 0, i32 13 - call void @ctor.230(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %41, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %43) + call void @ctor.219(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %41, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %43) %44 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 14 %45 = load %AstBuilder*, %AstBuilder** %other.addr %46 = getelementptr inbounds %AstBuilder, %AstBuilder* %45, i32 0, i32 14 - call void @ctor.231(%"FunctionPtr2[Node, UntypedPtr, Node]"* %44, %"FunctionPtr2[Node, UntypedPtr, Node]"* %46) + call void @ctor.220(%"FunctionPtr2[Node, UntypedPtr, Node]"* %44, %"FunctionPtr2[Node, UntypedPtr, Node]"* %46) %47 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 15 %48 = load %AstBuilder*, %AstBuilder** %other.addr %49 = getelementptr inbounds %AstBuilder, %AstBuilder* %48, i32 0, i32 15 - call void @ctor.232(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %47, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %49) + call void @ctor.221(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %47, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %49) %50 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 16 %51 = load %AstBuilder*, %AstBuilder** %other.addr %52 = getelementptr inbounds %AstBuilder, %AstBuilder* %51, i32 0, i32 16 - call void @ctor.233(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %50, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %52) + call void @ctor.222(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %50, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %52) %53 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 17 %54 = load %AstBuilder*, %AstBuilder** %other.addr %55 = getelementptr inbounds %AstBuilder, %AstBuilder* %54, i32 0, i32 17 - call void @ctor.226(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %53, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %55) + call void @ctor.215(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %53, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %55) %56 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 18 %57 = load %AstBuilder*, %AstBuilder** %other.addr %58 = getelementptr inbounds %AstBuilder, %AstBuilder* %57, i32 0, i32 18 - call void @ctor.234(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %56, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %58) + call void @ctor.223(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %56, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %58) %59 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 19 %60 = load %AstBuilder*, %AstBuilder** %other.addr %61 = getelementptr inbounds %AstBuilder, %AstBuilder* %60, i32 0, i32 19 - call void @ctor.232(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %59, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %61) + call void @ctor.221(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %59, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %61) %62 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 20 %63 = load %AstBuilder*, %AstBuilder** %other.addr %64 = getelementptr inbounds %AstBuilder, %AstBuilder* %63, i32 0, i32 20 - call void @ctor.232(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %62, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %64) + call void @ctor.221(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %62, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %64) %65 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 21 %66 = load %AstBuilder*, %AstBuilder** %other.addr %67 = getelementptr inbounds %AstBuilder, %AstBuilder* %66, i32 0, i32 21 - call void @ctor.232(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %65, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %67) + call void @ctor.221(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %65, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %67) %68 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 22 %69 = load %AstBuilder*, %AstBuilder** %other.addr %70 = getelementptr inbounds %AstBuilder, %AstBuilder* %69, i32 0, i32 22 - call void @ctor.224(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %68, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %70) + call void @ctor.213(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %68, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %70) %71 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 23 %72 = load %AstBuilder*, %AstBuilder** %other.addr %73 = getelementptr inbounds %AstBuilder, %AstBuilder* %72, i32 0, i32 23 - call void @ctor.235(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %71, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %73) + call void @ctor.224(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %71, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %73) %74 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 24 %75 = load %AstBuilder*, %AstBuilder** %other.addr %76 = getelementptr inbounds %AstBuilder, %AstBuilder* %75, i32 0, i32 24 - call void @ctor.236(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %74, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %76) + call void @ctor.225(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %74, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %76) %77 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 25 %78 = load %AstBuilder*, %AstBuilder** %other.addr %79 = getelementptr inbounds %AstBuilder, %AstBuilder* %78, i32 0, i32 25 - call void @ctor.237(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %77, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %79) + call void @ctor.226(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %77, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %79) %80 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 26 %81 = load %AstBuilder*, %AstBuilder** %other.addr %82 = getelementptr inbounds %AstBuilder, %AstBuilder* %81, i32 0, i32 26 - call void @ctor.238(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %80, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %82) + call void @ctor.227(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %80, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %82) %83 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 27 %84 = load %AstBuilder*, %AstBuilder** %other.addr %85 = getelementptr inbounds %AstBuilder, %AstBuilder* %84, i32 0, i32 27 - call void @ctor.239(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %83, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %85) + call void @ctor.228(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %83, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %85) %86 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 28 %87 = load %AstBuilder*, %AstBuilder** %other.addr %88 = getelementptr inbounds %AstBuilder, %AstBuilder* %87, i32 0, i32 28 - call void @ctor.240(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %86, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %88) + call void @ctor.229(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %86, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %88) %89 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 29 %90 = load %AstBuilder*, %AstBuilder** %other.addr %91 = getelementptr inbounds %AstBuilder, %AstBuilder* %90, i32 0, i32 29 - call void @ctor.241(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %89, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %91) + call void @ctor.230(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %89, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %91) %92 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 30 %93 = load %AstBuilder*, %AstBuilder** %other.addr %94 = getelementptr inbounds %AstBuilder, %AstBuilder* %93, i32 0, i32 30 - call void @ctor.242(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %92, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %94) + call void @ctor.231(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %92, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %94) %95 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 31 %96 = load %AstBuilder*, %AstBuilder** %other.addr %97 = getelementptr inbounds %AstBuilder, %AstBuilder* %96, i32 0, i32 31 - call void @ctor.243(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %95, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %97) + call void @ctor.232(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %95, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %97) %98 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 32 %99 = load %AstBuilder*, %AstBuilder** %other.addr %100 = getelementptr inbounds %AstBuilder, %AstBuilder* %99, i32 0, i32 32 - call void @ctor.244(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %98, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %100) + call void @ctor.233(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %98, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %100) %101 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 33 %102 = load %AstBuilder*, %AstBuilder** %other.addr %103 = getelementptr inbounds %AstBuilder, %AstBuilder* %102, i32 0, i32 33 - call void @ctor.234(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %101, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %103) + call void @ctor.223(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %101, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %103) %104 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 34 %105 = load %AstBuilder*, %AstBuilder** %other.addr %106 = getelementptr inbounds %AstBuilder, %AstBuilder* %105, i32 0, i32 34 - call void @ctor.245(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %104, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %106) + call void @ctor.234(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %104, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %106) %107 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 35 %108 = load %AstBuilder*, %AstBuilder** %other.addr %109 = getelementptr inbounds %AstBuilder, %AstBuilder* %108, i32 0, i32 35 - call void @ctor.246(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %107, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %109) + call void @ctor.235(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %107, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %109) %110 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 36 %111 = load %AstBuilder*, %AstBuilder** %other.addr %112 = getelementptr inbounds %AstBuilder, %AstBuilder* %111, i32 0, i32 36 - call void @ctor.227(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %110, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %112) + call void @ctor.216(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %110, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %112) %113 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 37 %114 = load %AstBuilder*, %AstBuilder** %other.addr %115 = getelementptr inbounds %AstBuilder, %AstBuilder* %114, i32 0, i32 37 - call void @ctor.246(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %113, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %115) + call void @ctor.235(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %113, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %115) %116 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 38 %117 = load %AstBuilder*, %AstBuilder** %other.addr %118 = getelementptr inbounds %AstBuilder, %AstBuilder* %117, i32 0, i32 38 - call void @ctor.236(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %116, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %118) + call void @ctor.225(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %116, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %118) %119 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 39 %120 = load %AstBuilder*, %AstBuilder** %other.addr %121 = getelementptr inbounds %AstBuilder, %AstBuilder* %120, i32 0, i32 39 - call void @ctor.236(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %119, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %121) + call void @ctor.225(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %119, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %121) %122 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 40 %123 = load %AstBuilder*, %AstBuilder** %other.addr %124 = getelementptr inbounds %AstBuilder, %AstBuilder* %123, i32 0, i32 40 - call void @ctor.245(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %122, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %124) + call void @ctor.234(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %122, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %124) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.223(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other) #3 { +define internal void @ctor.212(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* store %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"** %other.addr br label %code @@ -6685,12 +6444,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Node, UntypedPtr, Node, Node]"*, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Node, Node]", %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.224(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other) #3 { +define internal void @ctor.213(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"** %other.addr br label %code @@ -6700,12 +6459,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"*, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.225(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other) #3 { +define internal void @ctor.214(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"** %other.addr br label %code @@ -6715,12 +6474,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"*, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.226(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other) #3 { +define internal void @ctor.215(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"** %other.addr br label %code @@ -6730,12 +6489,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"*, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.227(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other) #3 { +define internal void @ctor.216(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* store %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"** %other.addr br label %code @@ -6745,12 +6504,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"*, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.228(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other) #3 { +define internal void @ctor.217(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* store %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"** %other.addr br label %code @@ -6760,12 +6519,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"*, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.229(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other) #3 { +define internal void @ctor.218(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* store %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"** %other.addr br label %code @@ -6775,12 +6534,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"*, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.230(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other) #3 { +define internal void @ctor.219(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* store %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"** %other.addr br label %code @@ -6790,12 +6549,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"*, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]", %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.231(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %"FunctionPtr2[Node, UntypedPtr, Node]"* %other) #3 { +define internal void @ctor.220(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %"FunctionPtr2[Node, UntypedPtr, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Node]"* store %"FunctionPtr2[Node, UntypedPtr, Node]"* %other, %"FunctionPtr2[Node, UntypedPtr, Node]"** %other.addr br label %code @@ -6805,12 +6564,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr2[Node, UntypedPtr, Node]"*, %"FunctionPtr2[Node, UntypedPtr, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Node]", %"FunctionPtr2[Node, UntypedPtr, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.232(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other) #3 { +define internal void @ctor.221(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other) #3 { %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"** %other.addr br label %code @@ -6820,12 +6579,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"*, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.233(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other) #3 { +define internal void @ctor.222(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"** %other.addr br label %code @@ -6835,12 +6594,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"*, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.234(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other) #3 { +define internal void @ctor.223(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"** %other.addr br label %code @@ -6850,12 +6609,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.235(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other) #3 { +define internal void @ctor.224(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* store %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"** %other.addr br label %code @@ -6865,12 +6624,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"*, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.236(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other) #3 { +define internal void @ctor.225(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other) #3 { %other.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Location const]"* store %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other, %"FunctionPtr2[Node, UntypedPtr, Location const]"** %other.addr br label %code @@ -6880,12 +6639,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr2[Node, UntypedPtr, Location const]"*, %"FunctionPtr2[Node, UntypedPtr, Location const]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr2[Node, UntypedPtr, Location const]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.237(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other) #3 { +define internal void @ctor.226(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"** %other.addr br label %code @@ -6895,12 +6654,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]", %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.238(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other) #3 { +define internal void @ctor.227(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"** %other.addr br label %code @@ -6910,87 +6669,87 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.239(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %other.addr +define internal void @ctor.228(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.240(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %other.addr +define internal void @ctor.229(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.241(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %other.addr +define internal void @ctor.230(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.242(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr +define internal void @ctor.231(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.243(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %other.addr +define internal void @ctor.232(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.244(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other) #3 { +define internal void @ctor.233(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"** %other.addr br label %code @@ -7000,12 +6759,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Char]", %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.245(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other) #3 { +define internal void @ctor.234(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"** %other.addr br label %code @@ -7015,12 +6774,12 @@ code: ; preds = %0 %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Node]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.246(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other) #3 { +define internal void @ctor.235(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"** %other.addr br label %code @@ -7030,48 +6789,48 @@ code: ; preds = %0 %2 = load %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"*, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"** %other.addr %3 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.247(%ParserContext* %this) #3 { +define internal void @dtor.236(%ParserContext* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 2 - call void @dtor.248(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %1) + call void @dtor.237(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %1) %2 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 1 - call void @dtor.255(%"SparrowLayoutDecoder[SparrowScanner]"* %2) + call void @dtor.244(%"SparrowLayoutDecoder[SparrowScanner]"* %2) %3 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 0 - call void @dtor.266(%SparrowScanner* %3) + call void @dtor.255(%SparrowScanner* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.248(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { +define internal void @dtor.237(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - call void @dtor.249(%Token* %1) + call void @dtor.238(%Token* %1) %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @dtor.251(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2) + call void @dtor.240(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.249(%Token* %this) #3 { +define internal void @dtor.238(%Token* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 2 - call void @dtor.250(%String* %1) + call void @dtor.239(%String* %1) ret void } ; Function Attrs: inlinehint nounwind -define internal void @dtor.250(%String* %this) #4 { +define internal void @dtor.239(%String* %this) #4 { br label %code code: ; preds = %0 @@ -7095,7 +6854,7 @@ if_block: ; preds = %code if_then: ; preds = %if_block %2 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 %3 = load i8*, i8** %2 - call void @ctor.67(%UntypedPtr* %tmp.this, i8* %3) + call void @ctor.57(%UntypedPtr* %tmp.this, i8* %3) %4 = load %UntypedPtr, %UntypedPtr* %tmp.this call void @free(%UntypedPtr %4) br label %if_end @@ -7116,53 +6875,53 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.251(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { +define internal void @dtor.240(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - call void @dtor.252(%"Vector[Token]"* %1) + call void @dtor.241(%"Vector[Token]"* %1) %2 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @dtor.255(%"SparrowLayoutDecoder[SparrowScanner]"* %2) + call void @dtor.244(%"SparrowLayoutDecoder[SparrowScanner]"* %2) ret void } ; Function Attrs: inlinehint nounwind -define internal void @dtor.252(%"Vector[Token]"* %this) #4 { +define internal void @dtor.241(%"Vector[Token]"* %this) #4 { %p = alloca %"RawPtr[Token]" %"$tmpForRef" = alloca %"RawPtr[Token]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - call void @ctor.204(%"RawPtr[Token]"* %p, %"RawPtr[Token]"* %1) + call void @ctor.193(%"RawPtr[Token]"* %p, %"RawPtr[Token]"* %1) br label %while_block while_block: ; preds = %while_step, %code %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %3 = call i1 @"==.205"(%"RawPtr[Token]"* %p, %"RawPtr[Token]"* %2) + %3 = call i1 @"==.194"(%"RawPtr[Token]"* %p, %"RawPtr[Token]"* %2) %4 = xor i1 true, %3 br i1 %4, label %while_body, label %while_end while_body: ; preds = %while_block - %5 = call %Token* @value.206(%"RawPtr[Token]"* %p) - call void @dtor.249(%Token* %5) + %5 = call %Token* @value.195(%"RawPtr[Token]"* %p) + call void @dtor.238(%Token* %5) br label %while_step while_step: ; preds = %while_body - %6 = call %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %p) + %6 = call %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %p) store %"RawPtr[Token]" %6, %"RawPtr[Token]"* %"$tmpForRef" - call void @"=.198"(%"RawPtr[Token]"* %p, %"RawPtr[Token]"* %"$tmpForRef") + call void @"=.187"(%"RawPtr[Token]"* %p, %"RawPtr[Token]"* %"$tmpForRef") br label %while_block while_end: ; preds = %while_block %7 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - call void @freePtr.253(%"RawPtr[Token]"* %7) + call void @freePtr.242(%"RawPtr[Token]"* %7) ret void } ; Function Attrs: inlinehint nounwind -define internal void @freePtr.253(%"RawPtr[Token]"* %this) #4 { +define internal void @freePtr.242(%"RawPtr[Token]"* %this) #4 { %tmp.this = alloca %UntypedPtr br label %code @@ -7170,13 +6929,13 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = call i1 @isSet.254(%"RawPtr[Token]"* %this) + %1 = call i1 @isSet.243(%"RawPtr[Token]"* %this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block %2 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 %3 = load %Token*, %Token** %2 - call void @ctor.197(%UntypedPtr* %tmp.this, %Token* %3) + call void @ctor.186(%UntypedPtr* %tmp.this, %Token* %3) %4 = load %UntypedPtr, %UntypedPtr* %tmp.this call void @free(%UntypedPtr %4) br label %if_end @@ -7186,7 +6945,7 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal i1 @isSet.254(%"RawPtr[Token]"* %this) #4 { +define internal i1 @isSet.243(%"RawPtr[Token]"* %this) #4 { br label %code code: ; preds = %0 @@ -7198,33 +6957,33 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.255(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #3 { +define internal void @dtor.244(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @dtor.256(%"Vector[Char]"* %1) + call void @dtor.245(%"Vector[Char]"* %1) %2 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - call void @dtor.259(%"Vector[UInt]"* %2) + call void @dtor.248(%"Vector[Int]"* %2) %3 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @dtor.265(%"RangeWithLookahead[SparrowScanner]"* %3) + call void @dtor.254(%"RangeWithLookahead[SparrowScanner]"* %3) ret void } ; Function Attrs: inlinehint nounwind -define internal void @dtor.256(%"Vector[Char]"* %this) #4 { +define internal void @dtor.245(%"Vector[Char]"* %this) #4 { %p = alloca %"RawPtr[Char]" %"$tmpForRef" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - call void @ctor.178(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %1) + call void @ctor.168(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %1) br label %while_block while_block: ; preds = %while_step, %code %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %3 = call i1 @"==.257"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %2) + %3 = call i1 @"==.246"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %2) %4 = xor i1 true, %3 br i1 %4, label %while_body, label %while_end @@ -7234,9 +6993,9 @@ while_body: ; preds = %while_block br label %while_step while_step: ; preds = %while_body - %7 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %p) + %7 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %p) store %"RawPtr[Char]" %7, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef") + call void @"=.176"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef") br label %while_block while_end: ; preds = %while_block @@ -7246,7 +7005,7 @@ while_end: ; preds = %while_block } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.257"(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #3 { +define internal i1 @"==.246"(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #3 { %this.addr = alloca %"RawPtr[Char]"* store %"RawPtr[Char]"* %this, %"RawPtr[Char]"** %this.addr %other.addr = alloca %"RawPtr[Char]"* @@ -7265,7 +7024,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %this) #4 { +define internal %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %this) #4 { %tmp.this = alloca %"RawPtr[Char]" %tmp.this1 = alloca %UntypedPtr br label %code @@ -7273,63 +7032,63 @@ define internal %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %this) #4 { code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 %2 = load i8*, i8** %1 - call void @ctor.67(%UntypedPtr* %tmp.this1, i8* %2) + call void @ctor.57(%UntypedPtr* %tmp.this1, i8* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 1) - call void @ctor.180(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %4) + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 1) + call void @ctor.170(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %4) %5 = load %"RawPtr[Char]", %"RawPtr[Char]"* %tmp.this ret %"RawPtr[Char]" %5 } ; Function Attrs: inlinehint nounwind -define internal void @dtor.259(%"Vector[UInt]"* %this) #4 { - %p = alloca %"RawPtr[UInt]" - %"$tmpForRef" = alloca %"RawPtr[UInt]" +define internal void @dtor.248(%"Vector[Int]"* %this) #4 { + %p = alloca %"RawPtr[Int]" + %"$tmpForRef" = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - call void @ctor.218(%"RawPtr[UInt]"* %p, %"RawPtr[UInt]"* %1) + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + call void @ctor.207(%"RawPtr[Int]"* %p, %"RawPtr[Int]"* %1) br label %while_block while_block: ; preds = %while_step, %code - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %3 = call i1 @"==.260"(%"RawPtr[UInt]"* %p, %"RawPtr[UInt]"* %2) + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %3 = call i1 @"==.249"(%"RawPtr[Int]"* %p, %"RawPtr[Int]"* %2) %4 = xor i1 true, %3 br i1 %4, label %while_body, label %while_end while_body: ; preds = %while_block - %5 = call i32* @value.261(%"RawPtr[UInt]"* %p) + %5 = call i32* @value.250(%"RawPtr[Int]"* %p) %6 = load i32, i32* %5 br label %while_step while_step: ; preds = %while_body - %7 = call %"RawPtr[UInt]" @advance.262(%"RawPtr[UInt]"* %p) - store %"RawPtr[UInt]" %7, %"RawPtr[UInt]"* %"$tmpForRef" - call void @"=.212"(%"RawPtr[UInt]"* %p, %"RawPtr[UInt]"* %"$tmpForRef") + %7 = call %"RawPtr[Int]" @advance.251(%"RawPtr[Int]"* %p) + store %"RawPtr[Int]" %7, %"RawPtr[Int]"* %"$tmpForRef" + call void @"=.201"(%"RawPtr[Int]"* %p, %"RawPtr[Int]"* %"$tmpForRef") br label %while_block while_end: ; preds = %while_block - %8 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - call void @freePtr.263(%"RawPtr[UInt]"* %8) + %8 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + call void @freePtr.252(%"RawPtr[Int]"* %8) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.260"(%"RawPtr[UInt]"* %this, %"RawPtr[UInt]"* %other) #3 { - %this.addr = alloca %"RawPtr[UInt]"* - store %"RawPtr[UInt]"* %this, %"RawPtr[UInt]"** %this.addr - %other.addr = alloca %"RawPtr[UInt]"* - store %"RawPtr[UInt]"* %other, %"RawPtr[UInt]"** %other.addr +define internal i1 @"==.249"(%"RawPtr[Int]"* %this, %"RawPtr[Int]"* %other) #3 { + %this.addr = alloca %"RawPtr[Int]"* + store %"RawPtr[Int]"* %this, %"RawPtr[Int]"** %this.addr + %other.addr = alloca %"RawPtr[Int]"* + store %"RawPtr[Int]"* %other, %"RawPtr[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"RawPtr[UInt]"*, %"RawPtr[UInt]"** %this.addr - %2 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %1, i32 0, i32 0 + %1 = load %"RawPtr[Int]"*, %"RawPtr[Int]"** %this.addr + %2 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %1, i32 0, i32 0 %3 = load i32*, i32** %2 %4 = bitcast i32* %3 to i8* - %5 = load %"RawPtr[UInt]"*, %"RawPtr[UInt]"** %other.addr - %6 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %5, i32 0, i32 0 + %5 = load %"RawPtr[Int]"*, %"RawPtr[Int]"** %other.addr + %6 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %5, i32 0, i32 0 %7 = load i32*, i32** %6 %8 = bitcast i32* %7 to i8* %9 = call i1 @implOpRefEQ(i8* %4, i8* %8) @@ -7337,34 +7096,34 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i32* @value.261(%"RawPtr[UInt]"* %this) #4 { +define internal i32* @value.250(%"RawPtr[Int]"* %this) #4 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %2 = load i32*, i32** %1 ret i32* %2 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[UInt]" @advance.262(%"RawPtr[UInt]"* %this) #4 { - %tmp.this = alloca %"RawPtr[UInt]" +define internal %"RawPtr[Int]" @advance.251(%"RawPtr[Int]"* %this) #4 { + %tmp.this = alloca %"RawPtr[Int]" %tmp.this1 = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %2 = load i32*, i32** %1 - call void @ctor.211(%UntypedPtr* %tmp.this1, i32* %2) + call void @ctor.200(%UntypedPtr* %tmp.this1, i32* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 4) - call void @ctor.216(%"RawPtr[UInt]"* %tmp.this, %UntypedPtr %4) - %5 = load %"RawPtr[UInt]", %"RawPtr[UInt]"* %tmp.this - ret %"RawPtr[UInt]" %5 + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 4) + call void @ctor.205(%"RawPtr[Int]"* %tmp.this, %UntypedPtr %4) + %5 = load %"RawPtr[Int]", %"RawPtr[Int]"* %tmp.this + ret %"RawPtr[Int]" %5 } ; Function Attrs: inlinehint nounwind -define internal void @freePtr.263(%"RawPtr[UInt]"* %this) #4 { +define internal void @freePtr.252(%"RawPtr[Int]"* %this) #4 { %tmp.this = alloca %UntypedPtr br label %code @@ -7372,13 +7131,13 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = call i1 @isSet.264(%"RawPtr[UInt]"* %this) + %1 = call i1 @isSet.253(%"RawPtr[Int]"* %this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block - %2 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %2 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %3 = load i32*, i32** %2 - call void @ctor.211(%UntypedPtr* %tmp.this, i32* %3) + call void @ctor.200(%UntypedPtr* %tmp.this, i32* %3) %4 = load %UntypedPtr, %UntypedPtr* %tmp.this call void @free(%UntypedPtr %4) br label %if_end @@ -7388,11 +7147,11 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal i1 @isSet.264(%"RawPtr[UInt]"* %this) #4 { +define internal i1 @isSet.253(%"RawPtr[Int]"* %this) #4 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %2 = load i32*, i32** %1 %3 = bitcast i32* %2 to i8* %4 = call i1 @implOpRefNE(i8* %3, i8* null) @@ -7400,63 +7159,63 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.265(%"RangeWithLookahead[SparrowScanner]"* %this) #3 { +define internal void @dtor.254(%"RangeWithLookahead[SparrowScanner]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - call void @dtor.252(%"Vector[Token]"* %1) + call void @dtor.241(%"Vector[Token]"* %1) %2 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - call void @dtor.266(%SparrowScanner* %2) + call void @dtor.255(%SparrowScanner* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.266(%SparrowScanner* %this) #3 { +define internal void @dtor.255(%SparrowScanner* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - call void @dtor.249(%Token* %1) + call void @dtor.238(%Token* %1) %2 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @dtor.267(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %2) + call void @dtor.256(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %2) %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 1 - call void @dtor.269(%BufferedCharSource* %3) + call void @dtor.258(%BufferedCharSource* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.267(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #3 { +define internal void @dtor.256(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 - call void @dtor.268(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) + call void @dtor.257(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.268(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #3 { +define internal void @dtor.257(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - call void @dtor.256(%"Vector[Char]"* %1) + call void @dtor.245(%"Vector[Char]"* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.269(%BufferedCharSource* %this) #3 { +define internal void @dtor.258(%BufferedCharSource* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 - call void @dtor.250(%String* %1) + call void @dtor.239(%String* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.270"(%ParserContext* %this, %ParserContext* %other) #3 { +define internal void @"=.259"(%ParserContext* %this, %ParserContext* %other) #3 { %other.addr = alloca %ParserContext* store %ParserContext* %other, %ParserContext** %other.addr br label %code @@ -7465,20 +7224,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 0 %2 = load %ParserContext*, %ParserContext** %other.addr %3 = getelementptr inbounds %ParserContext, %ParserContext* %2, i32 0, i32 0 - call void @"=.271"(%SparrowScanner* %1, %SparrowScanner* %3) + call void @"=.260"(%SparrowScanner* %1, %SparrowScanner* %3) %4 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 1 %5 = load %ParserContext*, %ParserContext** %other.addr %6 = getelementptr inbounds %ParserContext, %ParserContext* %5, i32 0, i32 1 - call void @"=.289"(%"SparrowLayoutDecoder[SparrowScanner]"* %4, %"SparrowLayoutDecoder[SparrowScanner]"* %6) + call void @"=.278"(%"SparrowLayoutDecoder[SparrowScanner]"* %4, %"SparrowLayoutDecoder[SparrowScanner]"* %6) %7 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 2 %8 = load %ParserContext*, %ParserContext** %other.addr %9 = getelementptr inbounds %ParserContext, %ParserContext* %8, i32 0, i32 2 - call void @"=.295"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %9) + call void @"=.284"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.271"(%SparrowScanner* %this, %SparrowScanner* %other) #3 { +define internal void @"=.260"(%SparrowScanner* %this, %SparrowScanner* %other) #3 { %other.addr = alloca %SparrowScanner* store %SparrowScanner* %other, %SparrowScanner** %other.addr br label %code @@ -7487,19 +7246,19 @@ code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 0 %2 = load %SparrowScanner*, %SparrowScanner** %other.addr %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %2, i32 0, i32 0 - call void @"=.272"(%Location* %1, %Location* %3) + call void @"=.261"(%Location* %1, %Location* %3) %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 1 %5 = load %SparrowScanner*, %SparrowScanner** %other.addr %6 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %5, i32 0, i32 1 - call void @"=.275"(%BufferedCharSource* %4, %BufferedCharSource* %6) + call void @"=.264"(%BufferedCharSource* %4, %BufferedCharSource* %6) %7 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %8 = load %SparrowScanner*, %SparrowScanner** %other.addr %9 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %8, i32 0, i32 2 - call void @"=.280"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %7, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %9) + call void @"=.269"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %7, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %9) %10 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %11 = load %SparrowScanner*, %SparrowScanner** %other.addr %12 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %11, i32 0, i32 3 - call void @"=.285"(%Token* %10, %Token* %12) + call void @"=.274"(%Token* %10, %Token* %12) %13 = load %SparrowScanner*, %SparrowScanner** %other.addr %14 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %13, i32 0, i32 4 %15 = load i1, i1* %14 @@ -7508,7 +7267,7 @@ code: ; preds = %0 %17 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 5 %18 = load %SparrowScanner*, %SparrowScanner** %other.addr %19 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %18, i32 0, i32 5 - call void @"=.287"(%ErrorReporter* %17, %ErrorReporter* %19) + call void @"=.276"(%ErrorReporter* %17, %ErrorReporter* %19) %20 = load %SparrowScanner*, %SparrowScanner** %other.addr %21 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %20, i32 0, i32 6 %22 = load i1, i1* %21 @@ -7518,7 +7277,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.272"(%Location* %this, %Location* %other) #3 { +define internal void @"=.261"(%Location* %this, %Location* %other) #3 { %other.addr = alloca %Location* store %Location* %other, %Location** %other.addr br label %code @@ -7527,20 +7286,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 0 %2 = load %Location*, %Location** %other.addr %3 = getelementptr inbounds %Location, %Location* %2, i32 0, i32 0 - call void @"=.273"(%SourceCode* %1, %SourceCode* %3) + call void @"=.262"(%SourceCode* %1, %SourceCode* %3) %4 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 1 %5 = load %Location*, %Location** %other.addr %6 = getelementptr inbounds %Location, %Location* %5, i32 0, i32 1 - call void @"=.274"(%LineCol* %4, %LineCol* %6) + call void @"=.263"(%LineCol* %4, %LineCol* %6) %7 = getelementptr inbounds %Location, %Location* %this, i32 0, i32 2 %8 = load %Location*, %Location** %other.addr %9 = getelementptr inbounds %Location, %Location* %8, i32 0, i32 2 - call void @"=.274"(%LineCol* %7, %LineCol* %9) + call void @"=.263"(%LineCol* %7, %LineCol* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.273"(%SourceCode* %this, %SourceCode* %other) #3 { +define internal void @"=.262"(%SourceCode* %this, %SourceCode* %other) #3 { %other.addr = alloca %SourceCode* store %SourceCode* %other, %SourceCode** %other.addr br label %code @@ -7554,7 +7313,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.274"(%LineCol* %this, %LineCol* %other) #3 { +define internal void @"=.263"(%LineCol* %this, %LineCol* %other) #3 { %other.addr = alloca %LineCol* store %LineCol* %other, %LineCol** %other.addr br label %code @@ -7574,7 +7333,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.275"(%BufferedCharSource* %this, %BufferedCharSource* %other) #3 { +define internal void @"=.264"(%BufferedCharSource* %this, %BufferedCharSource* %other) #3 { %other.addr = alloca %BufferedCharSource* store %BufferedCharSource* %other, %BufferedCharSource** %other.addr br label %code @@ -7583,11 +7342,11 @@ code: ; preds = %0 %1 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 0 %2 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %3 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %2, i32 0, i32 0 - call void @"=.276"(%CharSource* %1, %CharSource* %3) + call void @"=.265"(%CharSource* %1, %CharSource* %3) %4 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 %5 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %6 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %5, i32 0, i32 1 - %7 = call %String* @"=.278"(%String* %4, %String* %6) + %7 = call %String* @"=.267"(%String* %4, %String* %6) %8 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %9 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %8, i32 0, i32 2 %10 = load i32, i32* %9 @@ -7597,7 +7356,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.276"(%CharSource* %this, %CharSource* %other) #3 { +define internal void @"=.265"(%CharSource* %this, %CharSource* %other) #3 { %other.addr = alloca %CharSource* store %CharSource* %other, %CharSource** %other.addr br label %code @@ -7610,12 +7369,12 @@ code: ; preds = %0 %4 = getelementptr inbounds %CharSource, %CharSource* %this, i32 0, i32 1 %5 = load %CharSource*, %CharSource** %other.addr %6 = getelementptr inbounds %CharSource, %CharSource* %5, i32 0, i32 1 - call void @"=.277"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %4, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %6) + call void @"=.266"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %4, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.277"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other) #3 { +define internal void @"=.266"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* store %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"** %other.addr br label %code @@ -7629,18 +7388,18 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %String* @"=.278"(%String* %this, %String* %other) #4 { +define internal %String* @"=.267"(%String* %this, %String* %other) #4 { %tmp = alloca %String br label %code code: ; preds = %0 - call void @ctor.175(%String* %tmp, %String* %other) + call void @ctor.165(%String* %tmp, %String* %other) call void @swap(%String* %tmp, %String* %this) - call void @dtor.250(%String* %tmp) + call void @dtor.239(%String* %tmp) ret %String* %this dumy_block: ; No predecessors! - call void @dtor.250(%String* %tmp) + call void @dtor.239(%String* %tmp) unreachable } @@ -7651,18 +7410,18 @@ define internal void @swap(%String* %this, %String* %other) #4 { code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %2 = getelementptr inbounds %String, %String* %other, i32 0, i32 0 - call void @swap.279(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) + call void @swap.268(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %4 = getelementptr inbounds %String, %String* %other, i32 0, i32 1 - call void @swap.279(%"RawPtr[Char]"* %3, %"RawPtr[Char]"* %4) + call void @swap.268(%"RawPtr[Char]"* %3, %"RawPtr[Char]"* %4) %5 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 %6 = getelementptr inbounds %String, %String* %other, i32 0, i32 2 - call void @swap.279(%"RawPtr[Char]"* %5, %"RawPtr[Char]"* %6) + call void @swap.268(%"RawPtr[Char]"* %5, %"RawPtr[Char]"* %6) ret void } ; Function Attrs: inlinehint nounwind -define internal void @swap.279(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #4 { +define internal void @swap.268(%"RawPtr[Char]"* %this, %"RawPtr[Char]"* %other) #4 { %t = alloca i8* br label %code @@ -7681,7 +7440,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.280"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other) #3 { +define internal void @"=.269"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other) #3 { %other.addr = alloca %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* store %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %other.addr br label %code @@ -7690,7 +7449,7 @@ code: ; preds = %0 %1 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 %2 = load %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"*, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %other.addr %3 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %2, i32 0, i32 0 - call void @"=.281"(%"RangeWithLookahead[BufferedCharSourceRange]"* %1, %"RangeWithLookahead[BufferedCharSourceRange]"* %3) + call void @"=.270"(%"RangeWithLookahead[BufferedCharSourceRange]"* %1, %"RangeWithLookahead[BufferedCharSourceRange]"* %3) %4 = load %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"*, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %other.addr %5 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %4, i32 0, i32 1 %6 = load %Location*, %Location** %5 @@ -7700,7 +7459,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.281"(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %other) #3 { +define internal void @"=.270"(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %other) #3 { %other.addr = alloca %"RangeWithLookahead[BufferedCharSourceRange]"* store %"RangeWithLookahead[BufferedCharSourceRange]"* %other, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr br label %code @@ -7709,16 +7468,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 %2 = load %"RangeWithLookahead[BufferedCharSourceRange]"*, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr %3 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %2, i32 0, i32 0 - call void @"=.282"(%BufferedCharSourceRange* %1, %BufferedCharSourceRange* %3) + call void @"=.271"(%BufferedCharSourceRange* %1, %BufferedCharSourceRange* %3) %4 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 %5 = load %"RangeWithLookahead[BufferedCharSourceRange]"*, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr %6 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %5, i32 0, i32 1 - %7 = call %"Vector[Char]"* @"=.283"(%"Vector[Char]"* %4, %"Vector[Char]"* %6) + %7 = call %"Vector[Char]"* @"=.272"(%"Vector[Char]"* %4, %"Vector[Char]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.282"(%BufferedCharSourceRange* %this, %BufferedCharSourceRange* %other) #3 { +define internal void @"=.271"(%BufferedCharSourceRange* %this, %BufferedCharSourceRange* %other) #3 { %other.addr = alloca %BufferedCharSourceRange* store %BufferedCharSourceRange* %other, %BufferedCharSourceRange** %other.addr br label %code @@ -7733,53 +7492,53 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"Vector[Char]"* @"=.283"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { +define internal %"Vector[Char]"* @"=.272"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { %tmp = alloca %"Vector[Char]" br label %code code: ; preds = %0 - call void @ctor.184(%"Vector[Char]"* %tmp, %"Vector[Char]"* %other) - call void @swap.284(%"Vector[Char]"* %tmp, %"Vector[Char]"* %this) - call void @dtor.256(%"Vector[Char]"* %tmp) + call void @ctor.174(%"Vector[Char]"* %tmp, %"Vector[Char]"* %other) + call void @swap.273(%"Vector[Char]"* %tmp, %"Vector[Char]"* %this) + call void @dtor.245(%"Vector[Char]"* %tmp) ret %"Vector[Char]"* %this dumy_block: ; No predecessors! - call void @dtor.256(%"Vector[Char]"* %tmp) + call void @dtor.245(%"Vector[Char]"* %tmp) unreachable } ; Function Attrs: inlinehint nounwind -define internal void @swap.284(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { +define internal void @swap.273(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { %tmp = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - call void @ctor.178(%"RawPtr[Char]"* %tmp, %"RawPtr[Char]"* %1) + call void @ctor.168(%"RawPtr[Char]"* %tmp, %"RawPtr[Char]"* %1) %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 %3 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %other, i32 0, i32 0 - call void @"=.186"(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %3) + call void @"=.176"(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %3) %4 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %other, i32 0, i32 0 - call void @"=.186"(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %tmp) + call void @"=.176"(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %tmp) %5 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %tmp, %"RawPtr[Char]"* %5) + call void @"=.176"(%"RawPtr[Char]"* %tmp, %"RawPtr[Char]"* %5) %6 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %7 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %other, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %6, %"RawPtr[Char]"* %7) + call void @"=.176"(%"RawPtr[Char]"* %6, %"RawPtr[Char]"* %7) %8 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %other, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %8, %"RawPtr[Char]"* %tmp) + call void @"=.176"(%"RawPtr[Char]"* %8, %"RawPtr[Char]"* %tmp) %9 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 - call void @"=.186"(%"RawPtr[Char]"* %tmp, %"RawPtr[Char]"* %9) + call void @"=.176"(%"RawPtr[Char]"* %tmp, %"RawPtr[Char]"* %9) %10 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 %11 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %other, i32 0, i32 2 - call void @"=.186"(%"RawPtr[Char]"* %10, %"RawPtr[Char]"* %11) + call void @"=.176"(%"RawPtr[Char]"* %10, %"RawPtr[Char]"* %11) %12 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %other, i32 0, i32 2 - call void @"=.186"(%"RawPtr[Char]"* %12, %"RawPtr[Char]"* %tmp) + call void @"=.176"(%"RawPtr[Char]"* %12, %"RawPtr[Char]"* %tmp) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.285"(%Token* %this, %Token* %other) #3 { +define internal void @"=.274"(%Token* %this, %Token* %other) #3 { %other.addr = alloca %Token* store %Token* %other, %Token** %other.addr br label %code @@ -7788,15 +7547,15 @@ code: ; preds = %0 %1 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 0 %2 = load %Token*, %Token** %other.addr %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 0 - call void @"=.272"(%Location* %1, %Location* %3) + call void @"=.261"(%Location* %1, %Location* %3) %4 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 1 %5 = load %Token*, %Token** %other.addr %6 = getelementptr inbounds %Token, %Token* %5, i32 0, i32 1 - call void @"=.286"(%TokenType* %4, %TokenType* %6) + call void @"=.275"(%TokenType* %4, %TokenType* %6) %7 = getelementptr inbounds %Token, %Token* %this, i32 0, i32 2 %8 = load %Token*, %Token** %other.addr %9 = getelementptr inbounds %Token, %Token* %8, i32 0, i32 2 - %10 = call %String* @"=.278"(%String* %7, %String* %9) + %10 = call %String* @"=.267"(%String* %7, %String* %9) %11 = load %Token*, %Token** %other.addr %12 = getelementptr inbounds %Token, %Token* %11, i32 0, i32 3 %13 = load i64, i64* %12 @@ -7811,7 +7570,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.286"(%TokenType* %this, %TokenType* %other) #3 { +define internal void @"=.275"(%TokenType* %this, %TokenType* %other) #3 { %other.addr = alloca %TokenType* store %TokenType* %other, %TokenType** %other.addr br label %code @@ -7826,7 +7585,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.287"(%ErrorReporter* %this, %ErrorReporter* %other) #3 { +define internal void @"=.276"(%ErrorReporter* %this, %ErrorReporter* %other) #3 { %other.addr = alloca %ErrorReporter* store %ErrorReporter* %other, %ErrorReporter** %other.addr br label %code @@ -7839,12 +7598,12 @@ code: ; preds = %0 %4 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %this, i32 0, i32 1 %5 = load %ErrorReporter*, %ErrorReporter** %other.addr %6 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %5, i32 0, i32 1 - call void @"=.288"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %4, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %6) + call void @"=.277"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %4, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.288"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other) #3 { +define internal void @"=.277"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* store %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"** %other.addr br label %code @@ -7858,7 +7617,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.289"(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %other) #3 { +define internal void @"=.278"(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %other) #3 { %other.addr = alloca %"SparrowLayoutDecoder[SparrowScanner]"* store %"SparrowLayoutDecoder[SparrowScanner]"* %other, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr br label %code @@ -7867,23 +7626,23 @@ code: ; preds = %0 %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 %2 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %3 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %2, i32 0, i32 0 - call void @"=.290"(%"RangeWithLookahead[SparrowScanner]"* %1, %"RangeWithLookahead[SparrowScanner]"* %3) + call void @"=.279"(%"RangeWithLookahead[SparrowScanner]"* %1, %"RangeWithLookahead[SparrowScanner]"* %3) %4 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 1 %5 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %6 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %5, i32 0, i32 1 - call void @"=.287"(%ErrorReporter* %4, %ErrorReporter* %6) + call void @"=.276"(%ErrorReporter* %4, %ErrorReporter* %6) %7 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 %8 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %9 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %8, i32 0, i32 2 - %10 = call %"Vector[UInt]"* @"=.293"(%"Vector[UInt]"* %7, %"Vector[UInt]"* %9) + %10 = call %"Vector[Int]"* @"=.282"(%"Vector[Int]"* %7, %"Vector[Int]"* %9) %11 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 %12 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %13 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %12, i32 0, i32 3 - %14 = call %"Vector[Char]"* @"=.283"(%"Vector[Char]"* %11, %"Vector[Char]"* %13) + %14 = call %"Vector[Char]"* @"=.272"(%"Vector[Char]"* %11, %"Vector[Char]"* %13) %15 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 %16 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %17 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %16, i32 0, i32 4 - call void @"=.286"(%TokenType* %15, %TokenType* %17) + call void @"=.275"(%TokenType* %15, %TokenType* %17) %18 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %19 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %18, i32 0, i32 5 %20 = load i32, i32* %19 @@ -7893,7 +7652,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.290"(%"RangeWithLookahead[SparrowScanner]"* %this, %"RangeWithLookahead[SparrowScanner]"* %other) #3 { +define internal void @"=.279"(%"RangeWithLookahead[SparrowScanner]"* %this, %"RangeWithLookahead[SparrowScanner]"* %other) #3 { %other.addr = alloca %"RangeWithLookahead[SparrowScanner]"* store %"RangeWithLookahead[SparrowScanner]"* %other, %"RangeWithLookahead[SparrowScanner]"** %other.addr br label %code @@ -7902,108 +7661,108 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 %2 = load %"RangeWithLookahead[SparrowScanner]"*, %"RangeWithLookahead[SparrowScanner]"** %other.addr %3 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %2, i32 0, i32 0 - call void @"=.271"(%SparrowScanner* %1, %SparrowScanner* %3) + call void @"=.260"(%SparrowScanner* %1, %SparrowScanner* %3) %4 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 %5 = load %"RangeWithLookahead[SparrowScanner]"*, %"RangeWithLookahead[SparrowScanner]"** %other.addr %6 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %5, i32 0, i32 1 - %7 = call %"Vector[Token]"* @"=.291"(%"Vector[Token]"* %4, %"Vector[Token]"* %6) + %7 = call %"Vector[Token]"* @"=.280"(%"Vector[Token]"* %4, %"Vector[Token]"* %6) ret void } ; Function Attrs: inlinehint nounwind -define internal %"Vector[Token]"* @"=.291"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { +define internal %"Vector[Token]"* @"=.280"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { %tmp = alloca %"Vector[Token]" br label %code code: ; preds = %0 - call void @ctor.194(%"Vector[Token]"* %tmp, %"Vector[Token]"* %other) - call void @swap.292(%"Vector[Token]"* %tmp, %"Vector[Token]"* %this) - call void @dtor.252(%"Vector[Token]"* %tmp) + call void @ctor.183(%"Vector[Token]"* %tmp, %"Vector[Token]"* %other) + call void @swap.281(%"Vector[Token]"* %tmp, %"Vector[Token]"* %this) + call void @dtor.241(%"Vector[Token]"* %tmp) ret %"Vector[Token]"* %this dumy_block: ; No predecessors! - call void @dtor.252(%"Vector[Token]"* %tmp) + call void @dtor.241(%"Vector[Token]"* %tmp) unreachable } ; Function Attrs: inlinehint nounwind -define internal void @swap.292(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { +define internal void @swap.281(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { %tmp = alloca %"RawPtr[Token]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - call void @ctor.204(%"RawPtr[Token]"* %tmp, %"RawPtr[Token]"* %1) + call void @ctor.193(%"RawPtr[Token]"* %tmp, %"RawPtr[Token]"* %1) %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 %3 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %other, i32 0, i32 0 - call void @"=.198"(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %3) + call void @"=.187"(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %3) %4 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %other, i32 0, i32 0 - call void @"=.198"(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %tmp) + call void @"=.187"(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %tmp) %5 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - call void @"=.198"(%"RawPtr[Token]"* %tmp, %"RawPtr[Token]"* %5) + call void @"=.187"(%"RawPtr[Token]"* %tmp, %"RawPtr[Token]"* %5) %6 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %7 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %other, i32 0, i32 1 - call void @"=.198"(%"RawPtr[Token]"* %6, %"RawPtr[Token]"* %7) + call void @"=.187"(%"RawPtr[Token]"* %6, %"RawPtr[Token]"* %7) %8 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %other, i32 0, i32 1 - call void @"=.198"(%"RawPtr[Token]"* %8, %"RawPtr[Token]"* %tmp) + call void @"=.187"(%"RawPtr[Token]"* %8, %"RawPtr[Token]"* %tmp) %9 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 - call void @"=.198"(%"RawPtr[Token]"* %tmp, %"RawPtr[Token]"* %9) + call void @"=.187"(%"RawPtr[Token]"* %tmp, %"RawPtr[Token]"* %9) %10 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 %11 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %other, i32 0, i32 2 - call void @"=.198"(%"RawPtr[Token]"* %10, %"RawPtr[Token]"* %11) + call void @"=.187"(%"RawPtr[Token]"* %10, %"RawPtr[Token]"* %11) %12 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %other, i32 0, i32 2 - call void @"=.198"(%"RawPtr[Token]"* %12, %"RawPtr[Token]"* %tmp) + call void @"=.187"(%"RawPtr[Token]"* %12, %"RawPtr[Token]"* %tmp) ret void } ; Function Attrs: inlinehint nounwind -define internal %"Vector[UInt]"* @"=.293"(%"Vector[UInt]"* %this, %"Vector[UInt]"* %other) #4 { - %tmp = alloca %"Vector[UInt]" +define internal %"Vector[Int]"* @"=.282"(%"Vector[Int]"* %this, %"Vector[Int]"* %other) #4 { + %tmp = alloca %"Vector[Int]" br label %code code: ; preds = %0 - call void @ctor.208(%"Vector[UInt]"* %tmp, %"Vector[UInt]"* %other) - call void @swap.294(%"Vector[UInt]"* %tmp, %"Vector[UInt]"* %this) - call void @dtor.259(%"Vector[UInt]"* %tmp) - ret %"Vector[UInt]"* %this + call void @ctor.197(%"Vector[Int]"* %tmp, %"Vector[Int]"* %other) + call void @swap.283(%"Vector[Int]"* %tmp, %"Vector[Int]"* %this) + call void @dtor.248(%"Vector[Int]"* %tmp) + ret %"Vector[Int]"* %this dumy_block: ; No predecessors! - call void @dtor.259(%"Vector[UInt]"* %tmp) + call void @dtor.248(%"Vector[Int]"* %tmp) unreachable } ; Function Attrs: inlinehint nounwind -define internal void @swap.294(%"Vector[UInt]"* %this, %"Vector[UInt]"* %other) #4 { - %tmp = alloca %"RawPtr[UInt]" +define internal void @swap.283(%"Vector[Int]"* %this, %"Vector[Int]"* %other) #4 { + %tmp = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - call void @ctor.218(%"RawPtr[UInt]"* %tmp, %"RawPtr[UInt]"* %1) - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %3 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %other, i32 0, i32 0 - call void @"=.212"(%"RawPtr[UInt]"* %2, %"RawPtr[UInt]"* %3) - %4 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %other, i32 0, i32 0 - call void @"=.212"(%"RawPtr[UInt]"* %4, %"RawPtr[UInt]"* %tmp) - %5 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - call void @"=.212"(%"RawPtr[UInt]"* %tmp, %"RawPtr[UInt]"* %5) - %6 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %7 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %other, i32 0, i32 1 - call void @"=.212"(%"RawPtr[UInt]"* %6, %"RawPtr[UInt]"* %7) - %8 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %other, i32 0, i32 1 - call void @"=.212"(%"RawPtr[UInt]"* %8, %"RawPtr[UInt]"* %tmp) - %9 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - call void @"=.212"(%"RawPtr[UInt]"* %tmp, %"RawPtr[UInt]"* %9) - %10 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - %11 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %other, i32 0, i32 2 - call void @"=.212"(%"RawPtr[UInt]"* %10, %"RawPtr[UInt]"* %11) - %12 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %other, i32 0, i32 2 - call void @"=.212"(%"RawPtr[UInt]"* %12, %"RawPtr[UInt]"* %tmp) + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + call void @ctor.207(%"RawPtr[Int]"* %tmp, %"RawPtr[Int]"* %1) + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %3 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %other, i32 0, i32 0 + call void @"=.201"(%"RawPtr[Int]"* %2, %"RawPtr[Int]"* %3) + %4 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %other, i32 0, i32 0 + call void @"=.201"(%"RawPtr[Int]"* %4, %"RawPtr[Int]"* %tmp) + %5 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + call void @"=.201"(%"RawPtr[Int]"* %tmp, %"RawPtr[Int]"* %5) + %6 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %7 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %other, i32 0, i32 1 + call void @"=.201"(%"RawPtr[Int]"* %6, %"RawPtr[Int]"* %7) + %8 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %other, i32 0, i32 1 + call void @"=.201"(%"RawPtr[Int]"* %8, %"RawPtr[Int]"* %tmp) + %9 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + call void @"=.201"(%"RawPtr[Int]"* %tmp, %"RawPtr[Int]"* %9) + %10 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + %11 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %other, i32 0, i32 2 + call void @"=.201"(%"RawPtr[Int]"* %10, %"RawPtr[Int]"* %11) + %12 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %other, i32 0, i32 2 + call void @"=.201"(%"RawPtr[Int]"* %12, %"RawPtr[Int]"* %tmp) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.295"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { +define internal void @"=.284"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { %other.addr = alloca %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* store %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr br label %code @@ -8012,11 +7771,11 @@ code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 %2 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %2, i32 0, i32 0 - call void @"=.296"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %3) + call void @"=.285"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %3) %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %5 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %6 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %5, i32 0, i32 1 - call void @"=.285"(%Token* %4, %Token* %6) + call void @"=.274"(%Token* %4, %Token* %6) %7 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %8 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, i32 0, i32 2 %9 = load i1, i1* %8 @@ -8025,16 +7784,16 @@ code: ; preds = %0 %11 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %12 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %13 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %12, i32 0, i32 3 - call void @"=.297"(%AstBuilder* %11, %AstBuilder* %13) + call void @"=.286"(%AstBuilder* %11, %AstBuilder* %13) %14 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 4 %15 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %16 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %15, i32 0, i32 4 - call void @"=.287"(%ErrorReporter* %14, %ErrorReporter* %16) + call void @"=.276"(%ErrorReporter* %14, %ErrorReporter* %16) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.296"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { +define internal void @"=.285"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { %other.addr = alloca %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* store %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr br label %code @@ -8043,16 +7802,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 %2 = load %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"*, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %3 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2, i32 0, i32 0 - call void @"=.289"(%"SparrowLayoutDecoder[SparrowScanner]"* %1, %"SparrowLayoutDecoder[SparrowScanner]"* %3) + call void @"=.278"(%"SparrowLayoutDecoder[SparrowScanner]"* %1, %"SparrowLayoutDecoder[SparrowScanner]"* %3) %4 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %5 = load %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"*, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %6 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %5, i32 0, i32 1 - %7 = call %"Vector[Token]"* @"=.291"(%"Vector[Token]"* %4, %"Vector[Token]"* %6) + %7 = call %"Vector[Token]"* @"=.280"(%"Vector[Token]"* %4, %"Vector[Token]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.297"(%AstBuilder* %this, %AstBuilder* %other) #3 { +define internal void @"=.286"(%AstBuilder* %this, %AstBuilder* %other) #3 { %other.addr = alloca %AstBuilder* store %AstBuilder* %other, %AstBuilder** %other.addr br label %code @@ -8065,168 +7824,168 @@ code: ; preds = %0 %4 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 1 %5 = load %AstBuilder*, %AstBuilder** %other.addr %6 = getelementptr inbounds %AstBuilder, %AstBuilder* %5, i32 0, i32 1 - call void @"=.298"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %4, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %6) + call void @"=.287"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %4, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %6) %7 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 2 %8 = load %AstBuilder*, %AstBuilder** %other.addr %9 = getelementptr inbounds %AstBuilder, %AstBuilder* %8, i32 0, i32 2 - call void @"=.299"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %7, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %9) + call void @"=.288"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %7, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %9) %10 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 3 %11 = load %AstBuilder*, %AstBuilder** %other.addr %12 = getelementptr inbounds %AstBuilder, %AstBuilder* %11, i32 0, i32 3 - call void @"=.299"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %10, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %12) + call void @"=.288"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %10, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %12) %13 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 4 %14 = load %AstBuilder*, %AstBuilder** %other.addr %15 = getelementptr inbounds %AstBuilder, %AstBuilder* %14, i32 0, i32 4 - call void @"=.300"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %13, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %15) + call void @"=.289"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %13, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %15) %16 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 5 %17 = load %AstBuilder*, %AstBuilder** %other.addr %18 = getelementptr inbounds %AstBuilder, %AstBuilder* %17, i32 0, i32 5 - call void @"=.301"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %16, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %18) + call void @"=.290"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %16, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %18) %19 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 6 %20 = load %AstBuilder*, %AstBuilder** %other.addr %21 = getelementptr inbounds %AstBuilder, %AstBuilder* %20, i32 0, i32 6 - call void @"=.302"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %19, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %21) + call void @"=.291"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %19, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %21) %22 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 7 %23 = load %AstBuilder*, %AstBuilder** %other.addr %24 = getelementptr inbounds %AstBuilder, %AstBuilder* %23, i32 0, i32 7 - call void @"=.303"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %22, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %24) + call void @"=.292"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %22, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %24) %25 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 8 %26 = load %AstBuilder*, %AstBuilder** %other.addr %27 = getelementptr inbounds %AstBuilder, %AstBuilder* %26, i32 0, i32 8 - call void @"=.300"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %25, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %27) + call void @"=.289"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %25, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %27) %28 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 9 %29 = load %AstBuilder*, %AstBuilder** %other.addr %30 = getelementptr inbounds %AstBuilder, %AstBuilder* %29, i32 0, i32 9 - call void @"=.304"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %28, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %30) + call void @"=.293"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %28, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %30) %31 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 10 %32 = load %AstBuilder*, %AstBuilder** %other.addr %33 = getelementptr inbounds %AstBuilder, %AstBuilder* %32, i32 0, i32 10 - call void @"=.300"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %31, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %33) + call void @"=.289"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %31, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %33) %34 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 11 %35 = load %AstBuilder*, %AstBuilder** %other.addr %36 = getelementptr inbounds %AstBuilder, %AstBuilder* %35, i32 0, i32 11 - call void @"=.300"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %34, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %36) + call void @"=.289"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %34, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %36) %37 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 12 %38 = load %AstBuilder*, %AstBuilder** %other.addr %39 = getelementptr inbounds %AstBuilder, %AstBuilder* %38, i32 0, i32 12 - call void @"=.300"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %37, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %39) + call void @"=.289"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %37, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %39) %40 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 13 %41 = load %AstBuilder*, %AstBuilder** %other.addr %42 = getelementptr inbounds %AstBuilder, %AstBuilder* %41, i32 0, i32 13 - call void @"=.305"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %40, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %42) + call void @"=.294"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %40, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %42) %43 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 14 %44 = load %AstBuilder*, %AstBuilder** %other.addr %45 = getelementptr inbounds %AstBuilder, %AstBuilder* %44, i32 0, i32 14 - call void @"=.306"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %43, %"FunctionPtr2[Node, UntypedPtr, Node]"* %45) + call void @"=.295"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %43, %"FunctionPtr2[Node, UntypedPtr, Node]"* %45) %46 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 15 %47 = load %AstBuilder*, %AstBuilder** %other.addr %48 = getelementptr inbounds %AstBuilder, %AstBuilder* %47, i32 0, i32 15 - call void @"=.307"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %46, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %48) + call void @"=.296"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %46, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %48) %49 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 16 %50 = load %AstBuilder*, %AstBuilder** %other.addr %51 = getelementptr inbounds %AstBuilder, %AstBuilder* %50, i32 0, i32 16 - call void @"=.308"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %49, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %51) + call void @"=.297"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %49, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %51) %52 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 17 %53 = load %AstBuilder*, %AstBuilder** %other.addr %54 = getelementptr inbounds %AstBuilder, %AstBuilder* %53, i32 0, i32 17 - call void @"=.301"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %52, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %54) + call void @"=.290"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %52, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %54) %55 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 18 %56 = load %AstBuilder*, %AstBuilder** %other.addr %57 = getelementptr inbounds %AstBuilder, %AstBuilder* %56, i32 0, i32 18 - call void @"=.309"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %55, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %57) + call void @"=.298"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %55, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %57) %58 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 19 %59 = load %AstBuilder*, %AstBuilder** %other.addr %60 = getelementptr inbounds %AstBuilder, %AstBuilder* %59, i32 0, i32 19 - call void @"=.307"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %58, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %60) + call void @"=.296"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %58, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %60) %61 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 20 %62 = load %AstBuilder*, %AstBuilder** %other.addr %63 = getelementptr inbounds %AstBuilder, %AstBuilder* %62, i32 0, i32 20 - call void @"=.307"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %61, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %63) + call void @"=.296"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %61, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %63) %64 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 21 %65 = load %AstBuilder*, %AstBuilder** %other.addr %66 = getelementptr inbounds %AstBuilder, %AstBuilder* %65, i32 0, i32 21 - call void @"=.307"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %64, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %66) + call void @"=.296"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %64, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %66) %67 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 22 %68 = load %AstBuilder*, %AstBuilder** %other.addr %69 = getelementptr inbounds %AstBuilder, %AstBuilder* %68, i32 0, i32 22 - call void @"=.299"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %67, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %69) + call void @"=.288"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %67, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %69) %70 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 23 %71 = load %AstBuilder*, %AstBuilder** %other.addr %72 = getelementptr inbounds %AstBuilder, %AstBuilder* %71, i32 0, i32 23 - call void @"=.310"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %70, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %72) + call void @"=.299"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %70, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %72) %73 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 24 %74 = load %AstBuilder*, %AstBuilder** %other.addr %75 = getelementptr inbounds %AstBuilder, %AstBuilder* %74, i32 0, i32 24 - call void @"=.311"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %73, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %75) + call void @"=.300"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %73, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %75) %76 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 25 %77 = load %AstBuilder*, %AstBuilder** %other.addr %78 = getelementptr inbounds %AstBuilder, %AstBuilder* %77, i32 0, i32 25 - call void @"=.312"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %76, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %78) + call void @"=.301"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %76, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %78) %79 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 26 %80 = load %AstBuilder*, %AstBuilder** %other.addr %81 = getelementptr inbounds %AstBuilder, %AstBuilder* %80, i32 0, i32 26 - call void @"=.313"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %79, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %81) + call void @"=.302"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %79, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %81) %82 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 27 %83 = load %AstBuilder*, %AstBuilder** %other.addr %84 = getelementptr inbounds %AstBuilder, %AstBuilder* %83, i32 0, i32 27 - call void @"=.314"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %82, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %84) + call void @"=.303"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %82, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %84) %85 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 28 %86 = load %AstBuilder*, %AstBuilder** %other.addr %87 = getelementptr inbounds %AstBuilder, %AstBuilder* %86, i32 0, i32 28 - call void @"=.315"(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %85, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %87) + call void @"=.304"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %85, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %87) %88 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 29 %89 = load %AstBuilder*, %AstBuilder** %other.addr %90 = getelementptr inbounds %AstBuilder, %AstBuilder* %89, i32 0, i32 29 - call void @"=.316"(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %88, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %90) + call void @"=.305"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %88, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %90) %91 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 30 %92 = load %AstBuilder*, %AstBuilder** %other.addr %93 = getelementptr inbounds %AstBuilder, %AstBuilder* %92, i32 0, i32 30 - call void @"=.317"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %91, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %93) + call void @"=.306"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %91, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %93) %94 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 31 %95 = load %AstBuilder*, %AstBuilder** %other.addr %96 = getelementptr inbounds %AstBuilder, %AstBuilder* %95, i32 0, i32 31 - call void @"=.318"(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %94, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %96) + call void @"=.307"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %94, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %96) %97 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 32 %98 = load %AstBuilder*, %AstBuilder** %other.addr %99 = getelementptr inbounds %AstBuilder, %AstBuilder* %98, i32 0, i32 32 - call void @"=.319"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %97, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %99) + call void @"=.308"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %97, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %99) %100 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 33 %101 = load %AstBuilder*, %AstBuilder** %other.addr %102 = getelementptr inbounds %AstBuilder, %AstBuilder* %101, i32 0, i32 33 - call void @"=.309"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %100, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %102) + call void @"=.298"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %100, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %102) %103 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 34 %104 = load %AstBuilder*, %AstBuilder** %other.addr %105 = getelementptr inbounds %AstBuilder, %AstBuilder* %104, i32 0, i32 34 - call void @"=.320"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %103, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %105) + call void @"=.309"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %103, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %105) %106 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 35 %107 = load %AstBuilder*, %AstBuilder** %other.addr %108 = getelementptr inbounds %AstBuilder, %AstBuilder* %107, i32 0, i32 35 - call void @"=.321"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %106, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %108) + call void @"=.310"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %106, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %108) %109 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 36 %110 = load %AstBuilder*, %AstBuilder** %other.addr %111 = getelementptr inbounds %AstBuilder, %AstBuilder* %110, i32 0, i32 36 - call void @"=.302"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %109, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %111) + call void @"=.291"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %109, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %111) %112 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 37 %113 = load %AstBuilder*, %AstBuilder** %other.addr %114 = getelementptr inbounds %AstBuilder, %AstBuilder* %113, i32 0, i32 37 - call void @"=.321"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %112, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %114) + call void @"=.310"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %112, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %114) %115 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 38 %116 = load %AstBuilder*, %AstBuilder** %other.addr %117 = getelementptr inbounds %AstBuilder, %AstBuilder* %116, i32 0, i32 38 - call void @"=.311"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %115, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %117) + call void @"=.300"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %115, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %117) %118 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 39 %119 = load %AstBuilder*, %AstBuilder** %other.addr %120 = getelementptr inbounds %AstBuilder, %AstBuilder* %119, i32 0, i32 39 - call void @"=.311"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %118, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %120) + call void @"=.300"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %118, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %120) %121 = getelementptr inbounds %AstBuilder, %AstBuilder* %this, i32 0, i32 40 %122 = load %AstBuilder*, %AstBuilder** %other.addr %123 = getelementptr inbounds %AstBuilder, %AstBuilder* %122, i32 0, i32 40 - call void @"=.320"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %121, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %123) + call void @"=.309"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %121, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %123) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.298"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other) #3 { +define internal void @"=.287"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* store %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"** %other.addr br label %code @@ -8240,7 +7999,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.299"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other) #3 { +define internal void @"=.288"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"** %other.addr br label %code @@ -8254,7 +8013,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.300"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other) #3 { +define internal void @"=.289"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"** %other.addr br label %code @@ -8268,7 +8027,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.301"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other) #3 { +define internal void @"=.290"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"** %other.addr br label %code @@ -8282,7 +8041,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.302"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other) #3 { +define internal void @"=.291"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* store %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"** %other.addr br label %code @@ -8296,7 +8055,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.303"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other) #3 { +define internal void @"=.292"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* store %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"** %other.addr br label %code @@ -8310,7 +8069,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.304"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other) #3 { +define internal void @"=.293"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* store %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"** %other.addr br label %code @@ -8324,7 +8083,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.305"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other) #3 { +define internal void @"=.294"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* store %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"** %other.addr br label %code @@ -8338,7 +8097,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.306"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %"FunctionPtr2[Node, UntypedPtr, Node]"* %other) #3 { +define internal void @"=.295"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %"FunctionPtr2[Node, UntypedPtr, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Node]"* store %"FunctionPtr2[Node, UntypedPtr, Node]"* %other, %"FunctionPtr2[Node, UntypedPtr, Node]"** %other.addr br label %code @@ -8352,7 +8111,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.307"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other) #3 { +define internal void @"=.296"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other) #3 { %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"** %other.addr br label %code @@ -8366,7 +8125,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.308"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other) #3 { +define internal void @"=.297"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"** %other.addr br label %code @@ -8380,7 +8139,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.309"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other) #3 { +define internal void @"=.298"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"** %other.addr br label %code @@ -8394,7 +8153,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.310"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other) #3 { +define internal void @"=.299"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* store %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"** %other.addr br label %code @@ -8408,7 +8167,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.311"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other) #3 { +define internal void @"=.300"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other) #3 { %other.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Location const]"* store %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other, %"FunctionPtr2[Node, UntypedPtr, Location const]"** %other.addr br label %code @@ -8422,7 +8181,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.312"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other) #3 { +define internal void @"=.301"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"** %other.addr br label %code @@ -8436,7 +8195,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.313"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other) #3 { +define internal void @"=.302"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"** %other.addr br label %code @@ -8450,77 +8209,77 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.314"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %other.addr +define internal void @"=.303"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %2, i32 0, i32 0 call void @"="(%UntypedPtr* %1, %UntypedPtr* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.315"(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %other.addr +define internal void @"=.304"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %2, i32 0, i32 0 call void @"="(%UntypedPtr* %1, %UntypedPtr* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.316"(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %other.addr +define internal void @"=.305"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %2, i32 0, i32 0 call void @"="(%UntypedPtr* %1, %UntypedPtr* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.317"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr +define internal void @"=.306"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %2, i32 0, i32 0 call void @"="(%UntypedPtr* %1, %UntypedPtr* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.318"(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %other) #3 { - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %other.addr +define internal void @"=.307"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other) #3 { + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, i32 0, i32 0 - %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %other.addr - %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %2, i32 0, i32 0 + %1 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, i32 0, i32 0 + %2 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr + %3 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %2, i32 0, i32 0 call void @"="(%UntypedPtr* %1, %UntypedPtr* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.319"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other) #3 { +define internal void @"=.308"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"** %other.addr br label %code @@ -8534,7 +8293,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.320"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other) #3 { +define internal void @"=.309"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"** %other.addr br label %code @@ -8548,7 +8307,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.321"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other) #3 { +define internal void @"=.310"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other) #3 { %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"** %other.addr br label %code @@ -8562,7 +8321,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.322"(%ParserContext* %this, %ParserContext* %other) #3 { +define internal i1 @"==.311"(%ParserContext* %this, %ParserContext* %other) #3 { %this.addr = alloca %ParserContext* store %ParserContext* %this, %ParserContext** %this.addr %other.addr = alloca %ParserContext* @@ -8574,7 +8333,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %ParserContext, %ParserContext* %1, i32 0, i32 0 %3 = load %ParserContext*, %ParserContext** %other.addr %4 = getelementptr inbounds %ParserContext, %ParserContext* %3, i32 0, i32 0 - %5 = call i1 @"==.323"(%SparrowScanner* %2, %SparrowScanner* %4) + %5 = call i1 @"==.312"(%SparrowScanner* %2, %SparrowScanner* %4) br i1 %5, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 @@ -8582,7 +8341,7 @@ cond.true: ; preds = %cond.end3 %7 = getelementptr inbounds %ParserContext, %ParserContext* %6, i32 0, i32 2 %8 = load %ParserContext*, %ParserContext** %other.addr %9 = getelementptr inbounds %ParserContext, %ParserContext* %8, i32 0, i32 2 - %10 = call i1 @"==.348"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %9) + %10 = call i1 @"==.337"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %7, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -8597,7 +8356,7 @@ cond.true1: ; preds = %code %12 = getelementptr inbounds %ParserContext, %ParserContext* %11, i32 0, i32 1 %13 = load %ParserContext*, %ParserContext** %other.addr %14 = getelementptr inbounds %ParserContext, %ParserContext* %13, i32 0, i32 1 - %15 = call i1 @"==.342"(%"SparrowLayoutDecoder[SparrowScanner]"* %12, %"SparrowLayoutDecoder[SparrowScanner]"* %14) + %15 = call i1 @"==.331"(%"SparrowLayoutDecoder[SparrowScanner]"* %12, %"SparrowLayoutDecoder[SparrowScanner]"* %14) br label %cond.end3 cond.false2: ; preds = %code @@ -8609,7 +8368,7 @@ cond.end3: ; preds = %cond.false2, %cond. } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.323"(%SparrowScanner* %this, %SparrowScanner* %other) #3 { +define internal i1 @"==.312"(%SparrowScanner* %this, %SparrowScanner* %other) #3 { %this.addr = alloca %SparrowScanner* store %SparrowScanner* %this, %SparrowScanner** %this.addr %other.addr = alloca %SparrowScanner* @@ -8621,7 +8380,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %1, i32 0, i32 0 %3 = load %SparrowScanner*, %SparrowScanner** %other.addr %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %3, i32 0, i32 0 - %5 = call i1 @"==.324"(%Location* %2, %Location* %4) + %5 = call i1 @"==.313"(%Location* %2, %Location* %4) br i1 %5, label %cond.true13, label %cond.false14 cond.true: ; preds = %cond.end3 @@ -8646,7 +8405,7 @@ cond.true1: ; preds = %cond.end6 %14 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %13, i32 0, i32 5 %15 = load %SparrowScanner*, %SparrowScanner** %other.addr %16 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %15, i32 0, i32 5 - %17 = call i1 @"==.340"(%ErrorReporter* %14, %ErrorReporter* %16) + %17 = call i1 @"==.329"(%ErrorReporter* %14, %ErrorReporter* %16) br label %cond.end3 cond.false2: ; preds = %cond.end6 @@ -8678,7 +8437,7 @@ cond.true7: ; preds = %cond.end12 %26 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %25, i32 0, i32 3 %27 = load %SparrowScanner*, %SparrowScanner** %other.addr %28 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %27, i32 0, i32 3 - %29 = call i1 @"==.338"(%Token* %26, %Token* %28) + %29 = call i1 @"==.327"(%Token* %26, %Token* %28) br label %cond.end9 cond.false8: ; preds = %cond.end12 @@ -8693,7 +8452,7 @@ cond.true10: ; preds = %cond.end15 %31 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %30, i32 0, i32 2 %32 = load %SparrowScanner*, %SparrowScanner** %other.addr %33 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %32, i32 0, i32 2 - %34 = call i1 @"==.333"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %31, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %33) + %34 = call i1 @"==.322"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %31, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %33) br label %cond.end12 cond.false11: ; preds = %cond.end15 @@ -8708,7 +8467,7 @@ cond.true13: ; preds = %code %36 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %35, i32 0, i32 1 %37 = load %SparrowScanner*, %SparrowScanner** %other.addr %38 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %37, i32 0, i32 1 - %39 = call i1 @"==.328"(%BufferedCharSource* %36, %BufferedCharSource* %38) + %39 = call i1 @"==.317"(%BufferedCharSource* %36, %BufferedCharSource* %38) br label %cond.end15 cond.false14: ; preds = %code @@ -8720,7 +8479,7 @@ cond.end15: ; preds = %cond.false14, %cond } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.324"(%Location* %this, %Location* %other) #3 { +define internal i1 @"==.313"(%Location* %this, %Location* %other) #3 { %this.addr = alloca %Location* store %Location* %this, %Location** %this.addr %other.addr = alloca %Location* @@ -8732,7 +8491,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %Location, %Location* %1, i32 0, i32 0 %3 = load %Location*, %Location** %other.addr %4 = getelementptr inbounds %Location, %Location* %3, i32 0, i32 0 - %5 = call i1 @"==.325"(%SourceCode* %2, %SourceCode* %4) + %5 = call i1 @"==.314"(%SourceCode* %2, %SourceCode* %4) br i1 %5, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 @@ -8740,7 +8499,7 @@ cond.true: ; preds = %cond.end3 %7 = getelementptr inbounds %Location, %Location* %6, i32 0, i32 2 %8 = load %Location*, %Location** %other.addr %9 = getelementptr inbounds %Location, %Location* %8, i32 0, i32 2 - %10 = call i1 @"==.327"(%LineCol* %7, %LineCol* %9) + %10 = call i1 @"==.316"(%LineCol* %7, %LineCol* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -8755,7 +8514,7 @@ cond.true1: ; preds = %code %12 = getelementptr inbounds %Location, %Location* %11, i32 0, i32 1 %13 = load %Location*, %Location** %other.addr %14 = getelementptr inbounds %Location, %Location* %13, i32 0, i32 1 - %15 = call i1 @"==.327"(%LineCol* %12, %LineCol* %14) + %15 = call i1 @"==.316"(%LineCol* %12, %LineCol* %14) br label %cond.end3 cond.false2: ; preds = %code @@ -8767,7 +8526,7 @@ cond.end3: ; preds = %cond.false2, %cond. } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.325"(%SourceCode* %this, %SourceCode* %other) #3 { +define internal i1 @"==.314"(%SourceCode* %this, %SourceCode* %other) #3 { %this.addr = alloca %SourceCode* store %SourceCode* %this, %SourceCode** %this.addr %other.addr = alloca %SourceCode* @@ -8779,12 +8538,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %SourceCode, %SourceCode* %1, i32 0, i32 0 %3 = load %SourceCode*, %SourceCode** %other.addr %4 = getelementptr inbounds %SourceCode, %SourceCode* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.326"(%UntypedPtr* %this, %UntypedPtr* %other) #3 { +define internal i1 @"==.315"(%UntypedPtr* %this, %UntypedPtr* %other) #3 { %this.addr = alloca %UntypedPtr* store %UntypedPtr* %this, %UntypedPtr** %this.addr %other.addr = alloca %UntypedPtr* @@ -8803,7 +8562,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.327"(%LineCol* %this, %LineCol* %other) #3 { +define internal i1 @"==.316"(%LineCol* %this, %LineCol* %other) #3 { %this.addr = alloca %LineCol* store %LineCol* %this, %LineCol** %this.addr %other.addr = alloca %LineCol* @@ -8817,7 +8576,7 @@ code: ; preds = %0 %4 = load %LineCol*, %LineCol** %other.addr %5 = getelementptr inbounds %LineCol, %LineCol* %4, i32 0, i32 0 %6 = load i32, i32* %5 - %7 = icmp eq i32 %3, %6 + %7 = call i1 @_Int32_opEQ(i32 %3, i32 %6) br i1 %7, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -8827,7 +8586,7 @@ cond.true: ; preds = %code %11 = load %LineCol*, %LineCol** %other.addr %12 = getelementptr inbounds %LineCol, %LineCol* %11, i32 0, i32 1 %13 = load i32, i32* %12 - %14 = icmp eq i32 %10, %13 + %14 = call i1 @_Int32_opEQ(i32 %10, i32 %13) br label %cond.end cond.false: ; preds = %code @@ -8839,7 +8598,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.328"(%BufferedCharSource* %this, %BufferedCharSource* %other) #3 { +define internal i1 @"==.317"(%BufferedCharSource* %this, %BufferedCharSource* %other) #3 { %this.addr = alloca %BufferedCharSource* store %BufferedCharSource* %this, %BufferedCharSource** %this.addr %other.addr = alloca %BufferedCharSource* @@ -8851,7 +8610,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %1, i32 0, i32 0 %3 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %4 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %3, i32 0, i32 0 - %5 = call i1 @"==.329"(%CharSource* %2, %CharSource* %4) + %5 = call i1 @"==.318"(%CharSource* %2, %CharSource* %4) br i1 %5, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 @@ -8861,7 +8620,7 @@ cond.true: ; preds = %cond.end3 %9 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %10 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %9, i32 0, i32 2 %11 = load i32, i32* %10 - %12 = icmp eq i32 %8, %11 + %12 = call i1 @_Int32_opEQ(i32 %8, i32 %11) br label %cond.end cond.false: ; preds = %cond.end3 @@ -8876,7 +8635,7 @@ cond.true1: ; preds = %code %14 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %13, i32 0, i32 1 %15 = load %BufferedCharSource*, %BufferedCharSource** %other.addr %16 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %15, i32 0, i32 1 - %17 = call i1 @"==.331"(%String* %14, %String* %16) + %17 = call i1 @"==.320"(%String* %14, %String* %16) br label %cond.end3 cond.false2: ; preds = %code @@ -8888,7 +8647,7 @@ cond.end3: ; preds = %cond.false2, %cond. } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.329"(%CharSource* %this, %CharSource* %other) #3 { +define internal i1 @"==.318"(%CharSource* %this, %CharSource* %other) #3 { %this.addr = alloca %CharSource* store %CharSource* %this, %CharSource** %this.addr %other.addr = alloca %CharSource* @@ -8900,7 +8659,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %CharSource, %CharSource* %1, i32 0, i32 0 %3 = load %CharSource*, %CharSource** %other.addr %4 = getelementptr inbounds %CharSource, %CharSource* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -8908,7 +8667,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %CharSource, %CharSource* %6, i32 0, i32 1 %8 = load %CharSource*, %CharSource** %other.addr %9 = getelementptr inbounds %CharSource, %CharSource* %8, i32 0, i32 1 - %10 = call i1 @"==.330"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %7, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %9) + %10 = call i1 @"==.319"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %7, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %9) br label %cond.end cond.false: ; preds = %code @@ -8920,7 +8679,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.330"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other) #3 { +define internal i1 @"==.319"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* store %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"** %this.addr %other.addr = alloca %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* @@ -8932,59 +8691,59 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, String mut, Int]", %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"*, %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, String mut, Int]", %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: inlinehint nounwind -define internal i1 @"==.331"(%String* %this, %String* %other) #4 { - %i = alloca i64 - %s = alloca i64 +define internal i1 @"==.320"(%String* %this, %String* %other) #4 { + %i = alloca i32 + %s = alloca i32 br label %code code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = call i64 @size.176(%String* %this) - %2 = call i64 @size.176(%String* %other) - %3 = icmp ne i64 %1, %2 + %1 = call i32 @size.166(%String* %this) + %2 = call i32 @size.166(%String* %other) + %3 = call i1 @_Int32_opNE(i32 %1, i32 %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block ret i1 false if_end: ; preds = %dumy_block, %if_block - store i64 0, i64* %i - %4 = call i64 @size.176(%String* %this) - store i64 %4, i64* %s + store i32 0, i32* %i + %4 = call i32 @size.166(%String* %this) + store i32 %4, i32* %s br label %while_block dumy_block: ; No predecessors! br label %if_end while_block: ; preds = %while_step, %if_end - %5 = load i64, i64* %i - %6 = load i64, i64* %s - %7 = icmp slt i64 %5, %6 + %5 = load i32, i32* %i + %6 = load i32, i32* %s + %7 = call i1 @_Int32_opLT(i32 %5, i32 %6) br i1 %7, label %while_body, label %while_end while_body: ; preds = %while_block br label %if_block1 while_step: ; preds = %if_end3 - %8 = call i64 @"post_++.43"(i64* %i) + %8 = call i32 @"post_++.33"(i32* %i) br label %while_block while_end: ; preds = %while_block ret i1 true if_block1: ; preds = %while_body - %9 = load i64, i64* %i - %10 = call i8* @"().332"(%String* %this, i64 %9) + %9 = load i32, i32* %i + %10 = call i8* @"().321"(%String* %this, i32 %9) %11 = load i8, i8* %10 - %12 = load i64, i64* %i - %13 = call i8* @"().332"(%String* %other, i64 %12) + %12 = load i32, i32* %i + %13 = call i8* @"().321"(%String* %other, i32 %12) %14 = load i8, i8* %13 %15 = icmp ne i8 %11, %14 br i1 %15, label %if_then2, label %if_end3 @@ -9000,26 +8759,23 @@ dumy_block4: ; No predecessors! } ; Function Attrs: inlinehint nounwind -define internal i8* @"().332"(%String* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal i8* @"().321"(%String* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - store i64 %2, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i64 %3) - store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" - %5 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") - ret i8* %5 + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i32 %2) + store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" + %4 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") + ret i8* %4 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.333"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other) #3 { +define internal i1 @"==.322"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %other) #3 { %this.addr = alloca %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* store %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %this.addr %other.addr = alloca %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* @@ -9031,7 +8787,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1, i32 0, i32 0 %3 = load %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"*, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %other.addr %4 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3, i32 0, i32 0 - %5 = call i1 @"==.334"(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, %"RangeWithLookahead[BufferedCharSourceRange]"* %4) + %5 = call i1 @"==.323"(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, %"RangeWithLookahead[BufferedCharSourceRange]"* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -9055,7 +8811,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.334"(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %other) #3 { +define internal i1 @"==.323"(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %other) #3 { %this.addr = alloca %"RangeWithLookahead[BufferedCharSourceRange]"* store %"RangeWithLookahead[BufferedCharSourceRange]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"** %this.addr %other.addr = alloca %"RangeWithLookahead[BufferedCharSourceRange]"* @@ -9067,7 +8823,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %1, i32 0, i32 0 %3 = load %"RangeWithLookahead[BufferedCharSourceRange]"*, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr %4 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %3, i32 0, i32 0 - %5 = call i1 @"==.335"(%BufferedCharSourceRange* %2, %BufferedCharSourceRange* %4) + %5 = call i1 @"==.324"(%BufferedCharSourceRange* %2, %BufferedCharSourceRange* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -9075,7 +8831,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %6, i32 0, i32 1 %8 = load %"RangeWithLookahead[BufferedCharSourceRange]"*, %"RangeWithLookahead[BufferedCharSourceRange]"** %other.addr %9 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %8, i32 0, i32 1 - %10 = call i1 @"==.336"(%"Vector[Char]"* %7, %"Vector[Char]"* %9) + %10 = call i1 @"==.325"(%"Vector[Char]"* %7, %"Vector[Char]"* %9) br label %cond.end cond.false: ; preds = %code @@ -9087,7 +8843,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.335"(%BufferedCharSourceRange* %this, %BufferedCharSourceRange* %other) #3 { +define internal i1 @"==.324"(%BufferedCharSourceRange* %this, %BufferedCharSourceRange* %other) #3 { %this.addr = alloca %BufferedCharSourceRange* store %BufferedCharSourceRange* %this, %BufferedCharSourceRange** %this.addr %other.addr = alloca %BufferedCharSourceRange* @@ -9108,21 +8864,18 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i1 @"==.336"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { +define internal i1 @"==.325"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #4 { %i = alloca i32 - %s = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 + %s = alloca i32 br label %code code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = call i64 @size.185(%"Vector[Char]"* %this) - %2 = call i64 @size.185(%"Vector[Char]"* %other) - %3 = icmp ne i64 %1, %2 + %1 = call i32 @size.175(%"Vector[Char]"* %this) + %2 = call i32 @size.175(%"Vector[Char]"* %other) + %3 = call i1 @_Int32_opNE(i32 %1, i32 %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block @@ -9130,8 +8883,8 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block store i32 0, i32* %i - %4 = call i64 @size.185(%"Vector[Char]"* %this) - store i64 %4, i64* %s + %4 = call i32 @size.175(%"Vector[Char]"* %this) + store i32 %4, i32* %s br label %while_block dumy_block: ; No predecessors! @@ -9139,68 +8892,59 @@ dumy_block: ; No predecessors! while_block: ; preds = %while_step, %if_end %5 = load i32, i32* %i - %6 = zext i32 %5 to i64 - store i64 %6, i64* %tmp.this - %7 = load i64, i64* %tmp.this - %8 = load i64, i64* %s - %9 = icmp slt i64 %7, %8 - br i1 %9, label %while_body, label %while_end + %6 = load i32, i32* %s + %7 = call i1 @_Int32_opLT(i32 %5, i32 %6) + br i1 %7, label %while_body, label %while_end while_body: ; preds = %while_block br label %if_block1 while_step: ; preds = %if_end3 - %10 = call i32 @"post_++.39"(i32* %i) + %8 = call i32 @"post_++.33"(i32* %i) br label %while_block while_end: ; preds = %while_block ret i1 true if_block1: ; preds = %while_body - %11 = load i32, i32* %i - %12 = zext i32 %11 to i64 - store i64 %12, i64* %tmp.this4 - %13 = load i64, i64* %tmp.this4 - %14 = call i8* @at.337(%"Vector[Char]"* %this, i64 %13) - %15 = load i8, i8* %14 - %16 = load i32, i32* %i - %17 = zext i32 %16 to i64 - store i64 %17, i64* %tmp.this5 - %18 = load i64, i64* %tmp.this5 - %19 = call i8* @at.337(%"Vector[Char]"* %other, i64 %18) - %20 = load i8, i8* %19 - %21 = icmp eq i8 %15, %20 - %22 = xor i1 true, %21 - br i1 %22, label %if_then2, label %if_end3 + %9 = load i32, i32* %i + %10 = call i8* @at.326(%"Vector[Char]"* %this, i32 %9) + %11 = load i8, i8* %10 + %12 = load i32, i32* %i + %13 = call i8* @at.326(%"Vector[Char]"* %other, i32 %12) + %14 = load i8, i8* %13 + %15 = icmp eq i8 %11, %14 + %16 = xor i1 true, %15 + br i1 %16, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 ret i1 false -if_end3: ; preds = %dumy_block6, %if_block1 +if_end3: ; preds = %dumy_block4, %if_block1 br label %while_step -dumy_block6: ; No predecessors! +dumy_block4: ; No predecessors! br label %if_end3 } ; Function Attrs: inlinehint nounwind -define internal i8* @at.337(%"Vector[Char]"* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal i8* @at.326(%"Vector[Char]"* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %"$tmpForRef" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - %3 = call %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %1, i64 %2) + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i32 %2) store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" %4 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") ret i8* %4 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.338"(%Token* %this, %Token* %other) #3 { +define internal i1 @"==.327"(%Token* %this, %Token* %other) #3 { %this.addr = alloca %Token* store %Token* %this, %Token** %this.addr %other.addr = alloca %Token* @@ -9212,7 +8956,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %Token, %Token* %1, i32 0, i32 0 %3 = load %Token*, %Token** %other.addr %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 0 - %5 = call i1 @"==.324"(%Location* %2, %Location* %4) + %5 = call i1 @"==.313"(%Location* %2, %Location* %4) br i1 %5, label %cond.true7, label %cond.false8 cond.true: ; preds = %cond.end3 @@ -9222,7 +8966,7 @@ cond.true: ; preds = %cond.end3 %9 = load %Token*, %Token** %other.addr %10 = getelementptr inbounds %Token, %Token* %9, i32 0, i32 4 %11 = load double, double* %10 - %12 = call i1 @_Double_opEQ(double %8, double %11) + %12 = call i1 @_Float64_opEQ(double %8, double %11) br label %cond.end cond.false: ; preds = %cond.end3 @@ -9239,7 +8983,7 @@ cond.true1: ; preds = %cond.end6 %16 = load %Token*, %Token** %other.addr %17 = getelementptr inbounds %Token, %Token* %16, i32 0, i32 3 %18 = load i64, i64* %17 - %19 = icmp eq i64 %15, %18 + %19 = call i1 @_UInt64_opEQ(i64 %15, i64 %18) br label %cond.end3 cond.false2: ; preds = %cond.end6 @@ -9254,7 +8998,7 @@ cond.true4: ; preds = %cond.end9 %21 = getelementptr inbounds %Token, %Token* %20, i32 0, i32 2 %22 = load %Token*, %Token** %other.addr %23 = getelementptr inbounds %Token, %Token* %22, i32 0, i32 2 - %24 = call i1 @"==.331"(%String* %21, %String* %23) + %24 = call i1 @"==.320"(%String* %21, %String* %23) br label %cond.end6 cond.false5: ; preds = %cond.end9 @@ -9269,7 +9013,7 @@ cond.true7: ; preds = %code %26 = getelementptr inbounds %Token, %Token* %25, i32 0, i32 1 %27 = load %Token*, %Token** %other.addr %28 = getelementptr inbounds %Token, %Token* %27, i32 0, i32 1 - %29 = call i1 @"==.339"(%TokenType* %26, %TokenType* %28) + %29 = call i1 @"==.328"(%TokenType* %26, %TokenType* %28) br label %cond.end9 cond.false8: ; preds = %code @@ -9281,7 +9025,7 @@ cond.end9: ; preds = %cond.false8, %cond. } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.339"(%TokenType* %this, %TokenType* %other) #3 { +define internal i1 @"==.328"(%TokenType* %this, %TokenType* %other) #3 { %this.addr = alloca %TokenType* store %TokenType* %this, %TokenType** %this.addr %other.addr = alloca %TokenType* @@ -9295,12 +9039,12 @@ code: ; preds = %0 %4 = load %TokenType*, %TokenType** %other.addr %5 = getelementptr inbounds %TokenType, %TokenType* %4, i32 0, i32 0 %6 = load i32, i32* %5 - %7 = icmp eq i32 %3, %6 + %7 = call i1 @_Int32_opEQ(i32 %3, i32 %6) ret i1 %7 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.340"(%ErrorReporter* %this, %ErrorReporter* %other) #3 { +define internal i1 @"==.329"(%ErrorReporter* %this, %ErrorReporter* %other) #3 { %this.addr = alloca %ErrorReporter* store %ErrorReporter* %this, %ErrorReporter** %this.addr %other.addr = alloca %ErrorReporter* @@ -9312,7 +9056,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %1, i32 0, i32 0 %3 = load %ErrorReporter*, %ErrorReporter** %other.addr %4 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -9320,7 +9064,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %6, i32 0, i32 1 %8 = load %ErrorReporter*, %ErrorReporter** %other.addr %9 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %8, i32 0, i32 1 - %10 = call i1 @"==.341"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %7, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %9) + %10 = call i1 @"==.330"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %7, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %9) br label %cond.end cond.false: ; preds = %code @@ -9332,7 +9076,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.341"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other) #3 { +define internal i1 @"==.330"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* store %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"** %this.addr %other.addr = alloca %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* @@ -9344,12 +9088,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"*, %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.342"(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %other) #3 { +define internal i1 @"==.331"(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %other) #3 { %this.addr = alloca %"SparrowLayoutDecoder[SparrowScanner]"* store %"SparrowLayoutDecoder[SparrowScanner]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"** %this.addr %other.addr = alloca %"SparrowLayoutDecoder[SparrowScanner]"* @@ -9361,7 +9105,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %1, i32 0, i32 0 %3 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %4 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %3, i32 0, i32 0 - %5 = call i1 @"==.343"(%"RangeWithLookahead[SparrowScanner]"* %2, %"RangeWithLookahead[SparrowScanner]"* %4) + %5 = call i1 @"==.332"(%"RangeWithLookahead[SparrowScanner]"* %2, %"RangeWithLookahead[SparrowScanner]"* %4) br i1 %5, label %cond.true10, label %cond.false11 cond.true: ; preds = %cond.end3 @@ -9371,7 +9115,7 @@ cond.true: ; preds = %cond.end3 %9 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %10 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %9, i32 0, i32 5 %11 = load i32, i32* %10 - %12 = icmp eq i32 %8, %11 + %12 = call i1 @_Int32_opEQ(i32 %8, i32 %11) br label %cond.end cond.false: ; preds = %cond.end3 @@ -9386,7 +9130,7 @@ cond.true1: ; preds = %cond.end6 %14 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %13, i32 0, i32 4 %15 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %16 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %15, i32 0, i32 4 - %17 = call i1 @"==.339"(%TokenType* %14, %TokenType* %16) + %17 = call i1 @"==.328"(%TokenType* %14, %TokenType* %16) br label %cond.end3 cond.false2: ; preds = %cond.end6 @@ -9401,7 +9145,7 @@ cond.true4: ; preds = %cond.end9 %19 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %18, i32 0, i32 3 %20 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %21 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %20, i32 0, i32 3 - %22 = call i1 @"==.336"(%"Vector[Char]"* %19, %"Vector[Char]"* %21) + %22 = call i1 @"==.325"(%"Vector[Char]"* %19, %"Vector[Char]"* %21) br label %cond.end6 cond.false5: ; preds = %cond.end9 @@ -9416,7 +9160,7 @@ cond.true7: ; preds = %cond.end12 %24 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %23, i32 0, i32 2 %25 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %26 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %25, i32 0, i32 2 - %27 = call i1 @"==.346"(%"Vector[UInt]"* %24, %"Vector[UInt]"* %26) + %27 = call i1 @"==.335"(%"Vector[Int]"* %24, %"Vector[Int]"* %26) br label %cond.end9 cond.false8: ; preds = %cond.end12 @@ -9431,7 +9175,7 @@ cond.true10: ; preds = %code %29 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %28, i32 0, i32 1 %30 = load %"SparrowLayoutDecoder[SparrowScanner]"*, %"SparrowLayoutDecoder[SparrowScanner]"** %other.addr %31 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %30, i32 0, i32 1 - %32 = call i1 @"==.340"(%ErrorReporter* %29, %ErrorReporter* %31) + %32 = call i1 @"==.329"(%ErrorReporter* %29, %ErrorReporter* %31) br label %cond.end12 cond.false11: ; preds = %code @@ -9443,7 +9187,7 @@ cond.end12: ; preds = %cond.false11, %cond } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.343"(%"RangeWithLookahead[SparrowScanner]"* %this, %"RangeWithLookahead[SparrowScanner]"* %other) #3 { +define internal i1 @"==.332"(%"RangeWithLookahead[SparrowScanner]"* %this, %"RangeWithLookahead[SparrowScanner]"* %other) #3 { %this.addr = alloca %"RangeWithLookahead[SparrowScanner]"* store %"RangeWithLookahead[SparrowScanner]"* %this, %"RangeWithLookahead[SparrowScanner]"** %this.addr %other.addr = alloca %"RangeWithLookahead[SparrowScanner]"* @@ -9455,7 +9199,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %1, i32 0, i32 0 %3 = load %"RangeWithLookahead[SparrowScanner]"*, %"RangeWithLookahead[SparrowScanner]"** %other.addr %4 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %3, i32 0, i32 0 - %5 = call i1 @"==.323"(%SparrowScanner* %2, %SparrowScanner* %4) + %5 = call i1 @"==.312"(%SparrowScanner* %2, %SparrowScanner* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -9463,7 +9207,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %6, i32 0, i32 1 %8 = load %"RangeWithLookahead[SparrowScanner]"*, %"RangeWithLookahead[SparrowScanner]"** %other.addr %9 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %8, i32 0, i32 1 - %10 = call i1 @"==.344"(%"Vector[Token]"* %7, %"Vector[Token]"* %9) + %10 = call i1 @"==.333"(%"Vector[Token]"* %7, %"Vector[Token]"* %9) br label %cond.end cond.false: ; preds = %code @@ -9475,21 +9219,18 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: inlinehint nounwind -define internal i1 @"==.344"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { +define internal i1 @"==.333"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #4 { %i = alloca i32 - %s = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 + %s = alloca i32 br label %code code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = call i64 @size.195(%"Vector[Token]"* %this) - %2 = call i64 @size.195(%"Vector[Token]"* %other) - %3 = icmp ne i64 %1, %2 + %1 = call i32 @size.184(%"Vector[Token]"* %this) + %2 = call i32 @size.184(%"Vector[Token]"* %other) + %3 = call i1 @_Int32_opNE(i32 %1, i32 %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block @@ -9497,8 +9238,8 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block store i32 0, i32* %i - %4 = call i64 @size.195(%"Vector[Token]"* %this) - store i64 %4, i64* %s + %4 = call i32 @size.184(%"Vector[Token]"* %this) + store i32 %4, i32* %s br label %while_block dumy_block: ; No predecessors! @@ -9506,80 +9247,68 @@ dumy_block: ; No predecessors! while_block: ; preds = %while_step, %if_end %5 = load i32, i32* %i - %6 = zext i32 %5 to i64 - store i64 %6, i64* %tmp.this - %7 = load i64, i64* %tmp.this - %8 = load i64, i64* %s - %9 = icmp slt i64 %7, %8 - br i1 %9, label %while_body, label %while_end + %6 = load i32, i32* %s + %7 = call i1 @_Int32_opLT(i32 %5, i32 %6) + br i1 %7, label %while_body, label %while_end while_body: ; preds = %while_block br label %if_block1 while_step: ; preds = %if_end3 - %10 = call i32 @"post_++.39"(i32* %i) + %8 = call i32 @"post_++.33"(i32* %i) br label %while_block while_end: ; preds = %while_block ret i1 true if_block1: ; preds = %while_body + %9 = load i32, i32* %i + %10 = call %Token* @at.334(%"Vector[Token]"* %this, i32 %9) %11 = load i32, i32* %i - %12 = zext i32 %11 to i64 - store i64 %12, i64* %tmp.this4 - %13 = load i64, i64* %tmp.this4 - %14 = call %Token* @at.345(%"Vector[Token]"* %this, i64 %13) - %15 = load i32, i32* %i - %16 = zext i32 %15 to i64 - store i64 %16, i64* %tmp.this5 - %17 = load i64, i64* %tmp.this5 - %18 = call %Token* @at.345(%"Vector[Token]"* %other, i64 %17) - %19 = call i1 @"==.338"(%Token* %14, %Token* %18) - %20 = xor i1 true, %19 - br i1 %20, label %if_then2, label %if_end3 + %12 = call %Token* @at.334(%"Vector[Token]"* %other, i32 %11) + %13 = call i1 @"==.327"(%Token* %10, %Token* %12) + %14 = xor i1 true, %13 + br i1 %14, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 ret i1 false -if_end3: ; preds = %dumy_block6, %if_block1 +if_end3: ; preds = %dumy_block4, %if_block1 br label %while_step -dumy_block6: ; No predecessors! +dumy_block4: ; No predecessors! br label %if_end3 } ; Function Attrs: inlinehint nounwind -define internal %Token* @at.345(%"Vector[Token]"* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal %Token* @at.334(%"Vector[Token]"* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %"$tmpForRef" = alloca %"RawPtr[Token]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - %3 = call %"RawPtr[Token]" @advance.201(%"RawPtr[Token]"* %1, i64 %2) + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %1, i32 %2) store %"RawPtr[Token]" %3, %"RawPtr[Token]"* %"$tmpForRef" - %4 = call %Token* @value.206(%"RawPtr[Token]"* %"$tmpForRef") + %4 = call %Token* @value.195(%"RawPtr[Token]"* %"$tmpForRef") ret %Token* %4 } ; Function Attrs: inlinehint nounwind -define internal i1 @"==.346"(%"Vector[UInt]"* %this, %"Vector[UInt]"* %other) #4 { +define internal i1 @"==.335"(%"Vector[Int]"* %this, %"Vector[Int]"* %other) #4 { %i = alloca i32 - %s = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 + %s = alloca i32 br label %code code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = call i64 @size.209(%"Vector[UInt]"* %this) - %2 = call i64 @size.209(%"Vector[UInt]"* %other) - %3 = icmp ne i64 %1, %2 + %1 = call i32 @size.198(%"Vector[Int]"* %this) + %2 = call i32 @size.198(%"Vector[Int]"* %other) + %3 = call i1 @_Int32_opNE(i32 %1, i32 %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block @@ -9587,8 +9316,8 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block store i32 0, i32* %i - %4 = call i64 @size.209(%"Vector[UInt]"* %this) - store i64 %4, i64* %s + %4 = call i32 @size.198(%"Vector[Int]"* %this) + store i32 %4, i32* %s br label %while_block dumy_block: ; No predecessors! @@ -9596,68 +9325,59 @@ dumy_block: ; No predecessors! while_block: ; preds = %while_step, %if_end %5 = load i32, i32* %i - %6 = zext i32 %5 to i64 - store i64 %6, i64* %tmp.this - %7 = load i64, i64* %tmp.this - %8 = load i64, i64* %s - %9 = icmp slt i64 %7, %8 - br i1 %9, label %while_body, label %while_end + %6 = load i32, i32* %s + %7 = call i1 @_Int32_opLT(i32 %5, i32 %6) + br i1 %7, label %while_body, label %while_end while_body: ; preds = %while_block br label %if_block1 while_step: ; preds = %if_end3 - %10 = call i32 @"post_++.39"(i32* %i) + %8 = call i32 @"post_++.33"(i32* %i) br label %while_block while_end: ; preds = %while_block ret i1 true if_block1: ; preds = %while_body - %11 = load i32, i32* %i - %12 = zext i32 %11 to i64 - store i64 %12, i64* %tmp.this4 - %13 = load i64, i64* %tmp.this4 - %14 = call i32* @at.347(%"Vector[UInt]"* %this, i64 %13) - %15 = load i32, i32* %14 - %16 = load i32, i32* %i - %17 = zext i32 %16 to i64 - store i64 %17, i64* %tmp.this5 - %18 = load i64, i64* %tmp.this5 - %19 = call i32* @at.347(%"Vector[UInt]"* %other, i64 %18) - %20 = load i32, i32* %19 - %21 = icmp eq i32 %15, %20 - %22 = xor i1 true, %21 - br i1 %22, label %if_then2, label %if_end3 + %9 = load i32, i32* %i + %10 = call i32* @at.336(%"Vector[Int]"* %this, i32 %9) + %11 = load i32, i32* %10 + %12 = load i32, i32* %i + %13 = call i32* @at.336(%"Vector[Int]"* %other, i32 %12) + %14 = load i32, i32* %13 + %15 = call i1 @_Int32_opEQ(i32 %11, i32 %14) + %16 = xor i1 true, %15 + br i1 %16, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 ret i1 false -if_end3: ; preds = %dumy_block6, %if_block1 +if_end3: ; preds = %dumy_block4, %if_block1 br label %while_step -dumy_block6: ; No predecessors! +dumy_block4: ; No predecessors! br label %if_end3 } ; Function Attrs: inlinehint nounwind -define internal i32* @at.347(%"Vector[UInt]"* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr - %"$tmpForRef" = alloca %"RawPtr[UInt]" +define internal i32* @at.336(%"Vector[Int]"* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr + %"$tmpForRef" = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - %3 = call %"RawPtr[UInt]" @advance.215(%"RawPtr[UInt]"* %1, i64 %2) - store %"RawPtr[UInt]" %3, %"RawPtr[UInt]"* %"$tmpForRef" - %4 = call i32* @value.261(%"RawPtr[UInt]"* %"$tmpForRef") + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Int]" @advance.204(%"RawPtr[Int]"* %1, i32 %2) + store %"RawPtr[Int]" %3, %"RawPtr[Int]"* %"$tmpForRef" + %4 = call i32* @value.250(%"RawPtr[Int]"* %"$tmpForRef") ret i32* %4 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.348"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { +define internal i1 @"==.337"(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { %this.addr = alloca %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* store %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %this.addr %other.addr = alloca %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* @@ -9669,7 +9389,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %1, i32 0, i32 0 %3 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %3, i32 0, i32 0 - %5 = call i1 @"==.349"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %4) + %5 = call i1 @"==.338"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %4) br i1 %5, label %cond.true7, label %cond.false8 cond.true: ; preds = %cond.end3 @@ -9677,7 +9397,7 @@ cond.true: ; preds = %cond.end3 %7 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %6, i32 0, i32 4 %8 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %8, i32 0, i32 4 - %10 = call i1 @"==.340"(%ErrorReporter* %7, %ErrorReporter* %9) + %10 = call i1 @"==.329"(%ErrorReporter* %7, %ErrorReporter* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -9692,7 +9412,7 @@ cond.true1: ; preds = %cond.end6 %12 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %11, i32 0, i32 3 %13 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %14 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %13, i32 0, i32 3 - %15 = call i1 @"==.350"(%AstBuilder* %12, %AstBuilder* %14) + %15 = call i1 @"==.339"(%AstBuilder* %12, %AstBuilder* %14) br label %cond.end3 cond.false2: ; preds = %cond.end6 @@ -9724,7 +9444,7 @@ cond.true7: ; preds = %code %24 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %23, i32 0, i32 1 %25 = load %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"*, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %26 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %25, i32 0, i32 1 - %27 = call i1 @"==.338"(%Token* %24, %Token* %26) + %27 = call i1 @"==.327"(%Token* %24, %Token* %26) br label %cond.end9 cond.false8: ; preds = %code @@ -9736,7 +9456,7 @@ cond.end9: ; preds = %cond.false8, %cond. } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.349"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { +define internal i1 @"==.338"(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %other) #3 { %this.addr = alloca %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* store %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %this.addr %other.addr = alloca %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* @@ -9748,7 +9468,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1, i32 0, i32 0 %3 = load %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"*, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %4 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %3, i32 0, i32 0 - %5 = call i1 @"==.342"(%"SparrowLayoutDecoder[SparrowScanner]"* %2, %"SparrowLayoutDecoder[SparrowScanner]"* %4) + %5 = call i1 @"==.331"(%"SparrowLayoutDecoder[SparrowScanner]"* %2, %"SparrowLayoutDecoder[SparrowScanner]"* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -9756,7 +9476,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %6, i32 0, i32 1 %8 = load %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"*, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"** %other.addr %9 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %8, i32 0, i32 1 - %10 = call i1 @"==.344"(%"Vector[Token]"* %7, %"Vector[Token]"* %9) + %10 = call i1 @"==.333"(%"Vector[Token]"* %7, %"Vector[Token]"* %9) br label %cond.end cond.false: ; preds = %code @@ -9768,7 +9488,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.350"(%AstBuilder* %this, %AstBuilder* %other) #3 { +define internal i1 @"==.339"(%AstBuilder* %this, %AstBuilder* %other) #3 { %this.addr = alloca %AstBuilder* store %AstBuilder* %this, %AstBuilder** %this.addr %other.addr = alloca %AstBuilder* @@ -9780,7 +9500,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %1, i32 0, i32 0 %3 = load %AstBuilder*, %AstBuilder** %other.addr %4 = getelementptr inbounds %AstBuilder, %AstBuilder* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) br i1 %5, label %cond.true115, label %cond.false116 cond.true: ; preds = %cond.end3 @@ -9788,7 +9508,7 @@ cond.true: ; preds = %cond.end3 %7 = getelementptr inbounds %AstBuilder, %AstBuilder* %6, i32 0, i32 40 %8 = load %AstBuilder*, %AstBuilder** %other.addr %9 = getelementptr inbounds %AstBuilder, %AstBuilder* %8, i32 0, i32 40 - %10 = call i1 @"==.373"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %7, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %9) + %10 = call i1 @"==.362"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %7, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -9803,7 +9523,7 @@ cond.true1: ; preds = %cond.end6 %12 = getelementptr inbounds %AstBuilder, %AstBuilder* %11, i32 0, i32 39 %13 = load %AstBuilder*, %AstBuilder** %other.addr %14 = getelementptr inbounds %AstBuilder, %AstBuilder* %13, i32 0, i32 39 - %15 = call i1 @"==.364"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %12, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %14) + %15 = call i1 @"==.353"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %12, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %14) br label %cond.end3 cond.false2: ; preds = %cond.end6 @@ -9818,7 +9538,7 @@ cond.true4: ; preds = %cond.end9 %17 = getelementptr inbounds %AstBuilder, %AstBuilder* %16, i32 0, i32 38 %18 = load %AstBuilder*, %AstBuilder** %other.addr %19 = getelementptr inbounds %AstBuilder, %AstBuilder* %18, i32 0, i32 38 - %20 = call i1 @"==.364"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %17, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %19) + %20 = call i1 @"==.353"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %17, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %19) br label %cond.end6 cond.false5: ; preds = %cond.end9 @@ -9833,7 +9553,7 @@ cond.true7: ; preds = %cond.end12 %22 = getelementptr inbounds %AstBuilder, %AstBuilder* %21, i32 0, i32 37 %23 = load %AstBuilder*, %AstBuilder** %other.addr %24 = getelementptr inbounds %AstBuilder, %AstBuilder* %23, i32 0, i32 37 - %25 = call i1 @"==.374"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %22, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %24) + %25 = call i1 @"==.363"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %22, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %24) br label %cond.end9 cond.false8: ; preds = %cond.end12 @@ -9848,7 +9568,7 @@ cond.true10: ; preds = %cond.end15 %27 = getelementptr inbounds %AstBuilder, %AstBuilder* %26, i32 0, i32 36 %28 = load %AstBuilder*, %AstBuilder** %other.addr %29 = getelementptr inbounds %AstBuilder, %AstBuilder* %28, i32 0, i32 36 - %30 = call i1 @"==.355"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %27, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %29) + %30 = call i1 @"==.344"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %27, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %29) br label %cond.end12 cond.false11: ; preds = %cond.end15 @@ -9863,7 +9583,7 @@ cond.true13: ; preds = %cond.end18 %32 = getelementptr inbounds %AstBuilder, %AstBuilder* %31, i32 0, i32 35 %33 = load %AstBuilder*, %AstBuilder** %other.addr %34 = getelementptr inbounds %AstBuilder, %AstBuilder* %33, i32 0, i32 35 - %35 = call i1 @"==.374"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %32, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %34) + %35 = call i1 @"==.363"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %32, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %34) br label %cond.end15 cond.false14: ; preds = %cond.end18 @@ -9878,7 +9598,7 @@ cond.true16: ; preds = %cond.end21 %37 = getelementptr inbounds %AstBuilder, %AstBuilder* %36, i32 0, i32 34 %38 = load %AstBuilder*, %AstBuilder** %other.addr %39 = getelementptr inbounds %AstBuilder, %AstBuilder* %38, i32 0, i32 34 - %40 = call i1 @"==.373"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %37, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %39) + %40 = call i1 @"==.362"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %37, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %39) br label %cond.end18 cond.false17: ; preds = %cond.end21 @@ -9893,7 +9613,7 @@ cond.true19: ; preds = %cond.end24 %42 = getelementptr inbounds %AstBuilder, %AstBuilder* %41, i32 0, i32 33 %43 = load %AstBuilder*, %AstBuilder** %other.addr %44 = getelementptr inbounds %AstBuilder, %AstBuilder* %43, i32 0, i32 33 - %45 = call i1 @"==.362"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %42, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %44) + %45 = call i1 @"==.351"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %42, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %44) br label %cond.end21 cond.false20: ; preds = %cond.end24 @@ -9908,7 +9628,7 @@ cond.true22: ; preds = %cond.end27 %47 = getelementptr inbounds %AstBuilder, %AstBuilder* %46, i32 0, i32 32 %48 = load %AstBuilder*, %AstBuilder** %other.addr %49 = getelementptr inbounds %AstBuilder, %AstBuilder* %48, i32 0, i32 32 - %50 = call i1 @"==.372"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %47, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %49) + %50 = call i1 @"==.361"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %47, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %49) br label %cond.end24 cond.false23: ; preds = %cond.end27 @@ -9923,7 +9643,7 @@ cond.true25: ; preds = %cond.end30 %52 = getelementptr inbounds %AstBuilder, %AstBuilder* %51, i32 0, i32 31 %53 = load %AstBuilder*, %AstBuilder** %other.addr %54 = getelementptr inbounds %AstBuilder, %AstBuilder* %53, i32 0, i32 31 - %55 = call i1 @"==.371"(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %52, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %54) + %55 = call i1 @"==.360"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %52, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %54) br label %cond.end27 cond.false26: ; preds = %cond.end30 @@ -9938,7 +9658,7 @@ cond.true28: ; preds = %cond.end33 %57 = getelementptr inbounds %AstBuilder, %AstBuilder* %56, i32 0, i32 30 %58 = load %AstBuilder*, %AstBuilder** %other.addr %59 = getelementptr inbounds %AstBuilder, %AstBuilder* %58, i32 0, i32 30 - %60 = call i1 @"==.370"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %57, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %59) + %60 = call i1 @"==.359"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %57, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %59) br label %cond.end30 cond.false29: ; preds = %cond.end33 @@ -9953,7 +9673,7 @@ cond.true31: ; preds = %cond.end36 %62 = getelementptr inbounds %AstBuilder, %AstBuilder* %61, i32 0, i32 29 %63 = load %AstBuilder*, %AstBuilder** %other.addr %64 = getelementptr inbounds %AstBuilder, %AstBuilder* %63, i32 0, i32 29 - %65 = call i1 @"==.369"(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %62, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %64) + %65 = call i1 @"==.358"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %62, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %64) br label %cond.end33 cond.false32: ; preds = %cond.end36 @@ -9968,7 +9688,7 @@ cond.true34: ; preds = %cond.end39 %67 = getelementptr inbounds %AstBuilder, %AstBuilder* %66, i32 0, i32 28 %68 = load %AstBuilder*, %AstBuilder** %other.addr %69 = getelementptr inbounds %AstBuilder, %AstBuilder* %68, i32 0, i32 28 - %70 = call i1 @"==.368"(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %67, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %69) + %70 = call i1 @"==.357"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %67, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %69) br label %cond.end36 cond.false35: ; preds = %cond.end39 @@ -9983,7 +9703,7 @@ cond.true37: ; preds = %cond.end42 %72 = getelementptr inbounds %AstBuilder, %AstBuilder* %71, i32 0, i32 27 %73 = load %AstBuilder*, %AstBuilder** %other.addr %74 = getelementptr inbounds %AstBuilder, %AstBuilder* %73, i32 0, i32 27 - %75 = call i1 @"==.367"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %72, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %74) + %75 = call i1 @"==.356"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %72, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %74) br label %cond.end39 cond.false38: ; preds = %cond.end42 @@ -9998,7 +9718,7 @@ cond.true40: ; preds = %cond.end45 %77 = getelementptr inbounds %AstBuilder, %AstBuilder* %76, i32 0, i32 26 %78 = load %AstBuilder*, %AstBuilder** %other.addr %79 = getelementptr inbounds %AstBuilder, %AstBuilder* %78, i32 0, i32 26 - %80 = call i1 @"==.366"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %77, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %79) + %80 = call i1 @"==.355"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %77, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %79) br label %cond.end42 cond.false41: ; preds = %cond.end45 @@ -10013,7 +9733,7 @@ cond.true43: ; preds = %cond.end48 %82 = getelementptr inbounds %AstBuilder, %AstBuilder* %81, i32 0, i32 25 %83 = load %AstBuilder*, %AstBuilder** %other.addr %84 = getelementptr inbounds %AstBuilder, %AstBuilder* %83, i32 0, i32 25 - %85 = call i1 @"==.365"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %82, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %84) + %85 = call i1 @"==.354"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %82, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %84) br label %cond.end45 cond.false44: ; preds = %cond.end48 @@ -10028,7 +9748,7 @@ cond.true46: ; preds = %cond.end51 %87 = getelementptr inbounds %AstBuilder, %AstBuilder* %86, i32 0, i32 24 %88 = load %AstBuilder*, %AstBuilder** %other.addr %89 = getelementptr inbounds %AstBuilder, %AstBuilder* %88, i32 0, i32 24 - %90 = call i1 @"==.364"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %87, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %89) + %90 = call i1 @"==.353"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %87, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %89) br label %cond.end48 cond.false47: ; preds = %cond.end51 @@ -10043,7 +9763,7 @@ cond.true49: ; preds = %cond.end54 %92 = getelementptr inbounds %AstBuilder, %AstBuilder* %91, i32 0, i32 23 %93 = load %AstBuilder*, %AstBuilder** %other.addr %94 = getelementptr inbounds %AstBuilder, %AstBuilder* %93, i32 0, i32 23 - %95 = call i1 @"==.363"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %92, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %94) + %95 = call i1 @"==.352"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %92, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %94) br label %cond.end51 cond.false50: ; preds = %cond.end54 @@ -10058,7 +9778,7 @@ cond.true52: ; preds = %cond.end57 %97 = getelementptr inbounds %AstBuilder, %AstBuilder* %96, i32 0, i32 22 %98 = load %AstBuilder*, %AstBuilder** %other.addr %99 = getelementptr inbounds %AstBuilder, %AstBuilder* %98, i32 0, i32 22 - %100 = call i1 @"==.352"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %97, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %99) + %100 = call i1 @"==.341"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %97, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %99) br label %cond.end54 cond.false53: ; preds = %cond.end57 @@ -10073,7 +9793,7 @@ cond.true55: ; preds = %cond.end60 %102 = getelementptr inbounds %AstBuilder, %AstBuilder* %101, i32 0, i32 21 %103 = load %AstBuilder*, %AstBuilder** %other.addr %104 = getelementptr inbounds %AstBuilder, %AstBuilder* %103, i32 0, i32 21 - %105 = call i1 @"==.360"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %102, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %104) + %105 = call i1 @"==.349"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %102, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %104) br label %cond.end57 cond.false56: ; preds = %cond.end60 @@ -10088,7 +9808,7 @@ cond.true58: ; preds = %cond.end63 %107 = getelementptr inbounds %AstBuilder, %AstBuilder* %106, i32 0, i32 20 %108 = load %AstBuilder*, %AstBuilder** %other.addr %109 = getelementptr inbounds %AstBuilder, %AstBuilder* %108, i32 0, i32 20 - %110 = call i1 @"==.360"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %107, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %109) + %110 = call i1 @"==.349"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %107, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %109) br label %cond.end60 cond.false59: ; preds = %cond.end63 @@ -10103,7 +9823,7 @@ cond.true61: ; preds = %cond.end66 %112 = getelementptr inbounds %AstBuilder, %AstBuilder* %111, i32 0, i32 19 %113 = load %AstBuilder*, %AstBuilder** %other.addr %114 = getelementptr inbounds %AstBuilder, %AstBuilder* %113, i32 0, i32 19 - %115 = call i1 @"==.360"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %112, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %114) + %115 = call i1 @"==.349"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %112, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %114) br label %cond.end63 cond.false62: ; preds = %cond.end66 @@ -10118,7 +9838,7 @@ cond.true64: ; preds = %cond.end69 %117 = getelementptr inbounds %AstBuilder, %AstBuilder* %116, i32 0, i32 18 %118 = load %AstBuilder*, %AstBuilder** %other.addr %119 = getelementptr inbounds %AstBuilder, %AstBuilder* %118, i32 0, i32 18 - %120 = call i1 @"==.362"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %117, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %119) + %120 = call i1 @"==.351"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %117, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %119) br label %cond.end66 cond.false65: ; preds = %cond.end69 @@ -10133,7 +9853,7 @@ cond.true67: ; preds = %cond.end72 %122 = getelementptr inbounds %AstBuilder, %AstBuilder* %121, i32 0, i32 17 %123 = load %AstBuilder*, %AstBuilder** %other.addr %124 = getelementptr inbounds %AstBuilder, %AstBuilder* %123, i32 0, i32 17 - %125 = call i1 @"==.354"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %122, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %124) + %125 = call i1 @"==.343"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %122, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %124) br label %cond.end69 cond.false68: ; preds = %cond.end72 @@ -10148,7 +9868,7 @@ cond.true70: ; preds = %cond.end75 %127 = getelementptr inbounds %AstBuilder, %AstBuilder* %126, i32 0, i32 16 %128 = load %AstBuilder*, %AstBuilder** %other.addr %129 = getelementptr inbounds %AstBuilder, %AstBuilder* %128, i32 0, i32 16 - %130 = call i1 @"==.361"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %127, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %129) + %130 = call i1 @"==.350"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %127, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %129) br label %cond.end72 cond.false71: ; preds = %cond.end75 @@ -10163,7 +9883,7 @@ cond.true73: ; preds = %cond.end78 %132 = getelementptr inbounds %AstBuilder, %AstBuilder* %131, i32 0, i32 15 %133 = load %AstBuilder*, %AstBuilder** %other.addr %134 = getelementptr inbounds %AstBuilder, %AstBuilder* %133, i32 0, i32 15 - %135 = call i1 @"==.360"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %132, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %134) + %135 = call i1 @"==.349"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %132, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %134) br label %cond.end75 cond.false74: ; preds = %cond.end78 @@ -10178,7 +9898,7 @@ cond.true76: ; preds = %cond.end81 %137 = getelementptr inbounds %AstBuilder, %AstBuilder* %136, i32 0, i32 14 %138 = load %AstBuilder*, %AstBuilder** %other.addr %139 = getelementptr inbounds %AstBuilder, %AstBuilder* %138, i32 0, i32 14 - %140 = call i1 @"==.359"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %137, %"FunctionPtr2[Node, UntypedPtr, Node]"* %139) + %140 = call i1 @"==.348"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %137, %"FunctionPtr2[Node, UntypedPtr, Node]"* %139) br label %cond.end78 cond.false77: ; preds = %cond.end81 @@ -10193,7 +9913,7 @@ cond.true79: ; preds = %cond.end84 %142 = getelementptr inbounds %AstBuilder, %AstBuilder* %141, i32 0, i32 13 %143 = load %AstBuilder*, %AstBuilder** %other.addr %144 = getelementptr inbounds %AstBuilder, %AstBuilder* %143, i32 0, i32 13 - %145 = call i1 @"==.358"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %142, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %144) + %145 = call i1 @"==.347"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %142, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %144) br label %cond.end81 cond.false80: ; preds = %cond.end84 @@ -10208,7 +9928,7 @@ cond.true82: ; preds = %cond.end87 %147 = getelementptr inbounds %AstBuilder, %AstBuilder* %146, i32 0, i32 12 %148 = load %AstBuilder*, %AstBuilder** %other.addr %149 = getelementptr inbounds %AstBuilder, %AstBuilder* %148, i32 0, i32 12 - %150 = call i1 @"==.353"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %147, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %149) + %150 = call i1 @"==.342"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %147, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %149) br label %cond.end84 cond.false83: ; preds = %cond.end87 @@ -10223,7 +9943,7 @@ cond.true85: ; preds = %cond.end90 %152 = getelementptr inbounds %AstBuilder, %AstBuilder* %151, i32 0, i32 11 %153 = load %AstBuilder*, %AstBuilder** %other.addr %154 = getelementptr inbounds %AstBuilder, %AstBuilder* %153, i32 0, i32 11 - %155 = call i1 @"==.353"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %152, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %154) + %155 = call i1 @"==.342"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %152, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %154) br label %cond.end87 cond.false86: ; preds = %cond.end90 @@ -10238,7 +9958,7 @@ cond.true88: ; preds = %cond.end93 %157 = getelementptr inbounds %AstBuilder, %AstBuilder* %156, i32 0, i32 10 %158 = load %AstBuilder*, %AstBuilder** %other.addr %159 = getelementptr inbounds %AstBuilder, %AstBuilder* %158, i32 0, i32 10 - %160 = call i1 @"==.353"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %157, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %159) + %160 = call i1 @"==.342"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %157, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %159) br label %cond.end90 cond.false89: ; preds = %cond.end93 @@ -10253,7 +9973,7 @@ cond.true91: ; preds = %cond.end96 %162 = getelementptr inbounds %AstBuilder, %AstBuilder* %161, i32 0, i32 9 %163 = load %AstBuilder*, %AstBuilder** %other.addr %164 = getelementptr inbounds %AstBuilder, %AstBuilder* %163, i32 0, i32 9 - %165 = call i1 @"==.357"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %162, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %164) + %165 = call i1 @"==.346"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %162, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %164) br label %cond.end93 cond.false92: ; preds = %cond.end96 @@ -10268,7 +9988,7 @@ cond.true94: ; preds = %cond.end99 %167 = getelementptr inbounds %AstBuilder, %AstBuilder* %166, i32 0, i32 8 %168 = load %AstBuilder*, %AstBuilder** %other.addr %169 = getelementptr inbounds %AstBuilder, %AstBuilder* %168, i32 0, i32 8 - %170 = call i1 @"==.353"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %167, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %169) + %170 = call i1 @"==.342"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %167, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %169) br label %cond.end96 cond.false95: ; preds = %cond.end99 @@ -10283,7 +10003,7 @@ cond.true97: ; preds = %cond.end102 %172 = getelementptr inbounds %AstBuilder, %AstBuilder* %171, i32 0, i32 7 %173 = load %AstBuilder*, %AstBuilder** %other.addr %174 = getelementptr inbounds %AstBuilder, %AstBuilder* %173, i32 0, i32 7 - %175 = call i1 @"==.356"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %172, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %174) + %175 = call i1 @"==.345"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %172, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %174) br label %cond.end99 cond.false98: ; preds = %cond.end102 @@ -10298,7 +10018,7 @@ cond.true100: ; preds = %cond.end105 %177 = getelementptr inbounds %AstBuilder, %AstBuilder* %176, i32 0, i32 6 %178 = load %AstBuilder*, %AstBuilder** %other.addr %179 = getelementptr inbounds %AstBuilder, %AstBuilder* %178, i32 0, i32 6 - %180 = call i1 @"==.355"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %177, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %179) + %180 = call i1 @"==.344"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %177, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %179) br label %cond.end102 cond.false101: ; preds = %cond.end105 @@ -10313,7 +10033,7 @@ cond.true103: ; preds = %cond.end108 %182 = getelementptr inbounds %AstBuilder, %AstBuilder* %181, i32 0, i32 5 %183 = load %AstBuilder*, %AstBuilder** %other.addr %184 = getelementptr inbounds %AstBuilder, %AstBuilder* %183, i32 0, i32 5 - %185 = call i1 @"==.354"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %182, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %184) + %185 = call i1 @"==.343"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %182, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %184) br label %cond.end105 cond.false104: ; preds = %cond.end108 @@ -10328,7 +10048,7 @@ cond.true106: ; preds = %cond.end111 %187 = getelementptr inbounds %AstBuilder, %AstBuilder* %186, i32 0, i32 4 %188 = load %AstBuilder*, %AstBuilder** %other.addr %189 = getelementptr inbounds %AstBuilder, %AstBuilder* %188, i32 0, i32 4 - %190 = call i1 @"==.353"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %187, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %189) + %190 = call i1 @"==.342"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %187, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %189) br label %cond.end108 cond.false107: ; preds = %cond.end111 @@ -10343,7 +10063,7 @@ cond.true109: ; preds = %cond.end114 %192 = getelementptr inbounds %AstBuilder, %AstBuilder* %191, i32 0, i32 3 %193 = load %AstBuilder*, %AstBuilder** %other.addr %194 = getelementptr inbounds %AstBuilder, %AstBuilder* %193, i32 0, i32 3 - %195 = call i1 @"==.352"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %192, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %194) + %195 = call i1 @"==.341"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %192, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %194) br label %cond.end111 cond.false110: ; preds = %cond.end114 @@ -10358,7 +10078,7 @@ cond.true112: ; preds = %cond.end117 %197 = getelementptr inbounds %AstBuilder, %AstBuilder* %196, i32 0, i32 2 %198 = load %AstBuilder*, %AstBuilder** %other.addr %199 = getelementptr inbounds %AstBuilder, %AstBuilder* %198, i32 0, i32 2 - %200 = call i1 @"==.352"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %197, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %199) + %200 = call i1 @"==.341"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %197, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %199) br label %cond.end114 cond.false113: ; preds = %cond.end117 @@ -10373,7 +10093,7 @@ cond.true115: ; preds = %code %202 = getelementptr inbounds %AstBuilder, %AstBuilder* %201, i32 0, i32 1 %203 = load %AstBuilder*, %AstBuilder** %other.addr %204 = getelementptr inbounds %AstBuilder, %AstBuilder* %203, i32 0, i32 1 - %205 = call i1 @"==.351"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %202, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %204) + %205 = call i1 @"==.340"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %202, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %204) br label %cond.end117 cond.false116: ; preds = %code @@ -10385,7 +10105,7 @@ cond.end117: ; preds = %cond.false116, %con } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.351"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other) #3 { +define internal i1 @"==.340"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* store %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* @@ -10397,12 +10117,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Node, Node]", %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Node, UntypedPtr, Node, Node]"*, %"FunctionPtr3[Node, UntypedPtr, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Node, Node]", %"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.352"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other) #3 { +define internal i1 @"==.341"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* @@ -10414,12 +10134,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"*, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.353"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other) #3 { +define internal i1 @"==.342"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* @@ -10431,12 +10151,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"*, %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.354"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other) #3 { +define internal i1 @"==.343"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"** %this.addr %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* @@ -10448,12 +10168,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"*, %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]", %"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.355"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other) #3 { +define internal i1 @"==.344"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* store %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* @@ -10465,12 +10185,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"*, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.356"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other) #3 { +define internal i1 @"==.345"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* store %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* @@ -10482,12 +10202,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"*, %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.357"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other) #3 { +define internal i1 @"==.346"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* store %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* @@ -10499,12 +10219,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"*, %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]", %"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.358"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other) #3 { +define internal i1 @"==.347"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* store %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* @@ -10516,12 +10236,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]", %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"*, %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]", %"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.359"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %"FunctionPtr2[Node, UntypedPtr, Node]"* %other) #3 { +define internal i1 @"==.348"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %"FunctionPtr2[Node, UntypedPtr, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Node]"* store %"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %"FunctionPtr2[Node, UntypedPtr, Node]"** %this.addr %other.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Node]"* @@ -10533,12 +10253,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Node]", %"FunctionPtr2[Node, UntypedPtr, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr2[Node, UntypedPtr, Node]"*, %"FunctionPtr2[Node, UntypedPtr, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Node]", %"FunctionPtr2[Node, UntypedPtr, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.360"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other) #3 { +define internal i1 @"==.349"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %other) #3 { %this.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* store %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"** %this.addr %other.addr = alloca %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* @@ -10550,12 +10270,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"*, %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]", %"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.361"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other) #3 { +define internal i1 @"==.350"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"** %this.addr %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* @@ -10567,12 +10287,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"*, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.362"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other) #3 { +define internal i1 @"==.351"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"** %this.addr %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* @@ -10584,12 +10304,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]", %"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.363"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other) #3 { +define internal i1 @"==.352"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* store %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* @@ -10601,12 +10321,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"*, %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]", %"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.364"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other) #3 { +define internal i1 @"==.353"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %"FunctionPtr2[Node, UntypedPtr, Location const]"* %other) #3 { %this.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Location const]"* store %"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %"FunctionPtr2[Node, UntypedPtr, Location const]"** %this.addr %other.addr = alloca %"FunctionPtr2[Node, UntypedPtr, Location const]"* @@ -10618,12 +10338,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr2[Node, UntypedPtr, Location const]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr2[Node, UntypedPtr, Location const]"*, %"FunctionPtr2[Node, UntypedPtr, Location const]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr2[Node, UntypedPtr, Location const]", %"FunctionPtr2[Node, UntypedPtr, Location const]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.365"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other) #3 { +define internal i1 @"==.354"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"** %this.addr %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* @@ -10635,12 +10355,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]", %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]", %"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.366"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other) #3 { +define internal i1 @"==.355"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"** %this.addr %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* @@ -10652,63 +10372,80 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.367"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %other) #3 { - %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %this.addr - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %other.addr +define internal i1 @"==.356"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %other) #3 { + %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %this.addr + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %this.addr - %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %1, i32 0, i32 0 - %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"** %other.addr - %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %this.addr + %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %1, i32 0, i32 0 + %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"** %other.addr + %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %3, i32 0, i32 0 + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.368"(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %other) #3 { - %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %this.addr - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %other.addr +define internal i1 @"==.357"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %other) #3 { + %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %this.addr + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %this.addr - %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %1, i32 0, i32 0 - %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"** %other.addr - %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Long]", %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %this.addr + %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %1, i32 0, i32 0 + %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"** %other.addr + %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]", %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %3, i32 0, i32 0 + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.369"(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %other) #3 { - %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %this.addr - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %other.addr +define internal i1 @"==.358"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %other) #3 { + %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %this.addr + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %this.addr - %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %1, i32 0, i32 0 - %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"** %other.addr - %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]", %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %this.addr + %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %1, i32 0, i32 0 + %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"** %other.addr + %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]", %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %3, i32 0, i32 0 + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.370"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other) #3 { +define internal i1 @"==.359"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %other) #3 { + %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %this.addr + %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* + store %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %other.addr + br label %code + +code: ; preds = %0 + %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %this.addr + %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %1, i32 0, i32 0 + %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"** %other.addr + %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %3, i32 0, i32 0 + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) + ret i1 %5 +} + +; Function Attrs: alwaysinline nounwind +define internal i1 @"==.360"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %this.addr %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* @@ -10720,29 +10457,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Float]", %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) - ret i1 %5 -} - -; Function Attrs: alwaysinline nounwind -define internal i1 @"==.371"(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %other) #3 { - %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %this.addr - %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* - store %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %other, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %other.addr - br label %code - -code: ; preds = %0 - %1 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %this.addr - %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %1, i32 0, i32 0 - %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"** %other.addr - %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Double]", %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.372"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other) #3 { +define internal i1 @"==.361"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"** %this.addr %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* @@ -10754,12 +10474,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Char]", %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Char]", %"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.373"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other) #3 { +define internal i1 @"==.362"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* store %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"** %this.addr %other.addr = alloca %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* @@ -10771,12 +10491,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Node]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"*, %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr3[Node, UntypedPtr, Location const, Node]", %"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.374"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other) #3 { +define internal i1 @"==.363"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %other) #3 { %this.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* store %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"** %this.addr %other.addr = alloca %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* @@ -10788,12 +10508,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %1, i32 0, i32 0 %3 = load %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"*, %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"** %other.addr %4 = getelementptr inbounds %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]", %"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.375(%ParserContext* %this, %CharSource* %chars, %Location %loc, %AstBuilder* %astBuilder, %ErrorReporter* %reporter) #4 { +define internal void @ctor.364(%ParserContext* %this, %CharSource* %chars, %Location %loc, %AstBuilder* %astBuilder, %ErrorReporter* %reporter) #4 { %loc.addr = alloca %Location store %Location %loc, %Location* %loc.addr br label %code @@ -10801,18 +10521,18 @@ define internal void @ctor.375(%ParserContext* %this, %CharSource* %chars, %Loca code: ; preds = %0 %1 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 0 %2 = load %Location, %Location* %loc.addr - call void @ctor.376(%SparrowScanner* %1, %CharSource* %chars, %ErrorReporter* %reporter, %Location %2, i1 false) + call void @ctor.365(%SparrowScanner* %1, %CharSource* %chars, %ErrorReporter* %reporter, %Location %2, i1 false) %3 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 1 %4 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 0 - call void @ctor.389(%"SparrowLayoutDecoder[SparrowScanner]"* %3, %SparrowScanner* %4, %ErrorReporter* %reporter) + call void @ctor.378(%"SparrowLayoutDecoder[SparrowScanner]"* %3, %SparrowScanner* %4, %ErrorReporter* %reporter) %5 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 2 %6 = getelementptr inbounds %ParserContext, %ParserContext* %this, i32 0, i32 1 - call void @ctor.507(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %5, %"SparrowLayoutDecoder[SparrowScanner]"* %6, %AstBuilder* %astBuilder, %ErrorReporter* %reporter) + call void @ctor.492(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %5, %"SparrowLayoutDecoder[SparrowScanner]"* %6, %AstBuilder* %astBuilder, %ErrorReporter* %reporter) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.376(%SparrowScanner* %this, %CharSource* %chars, %ErrorReporter* %errorReporter, %Location %iniLocation, i1 %emitWitespace) #4 { +define internal void @ctor.365(%SparrowScanner* %this, %CharSource* %chars, %ErrorReporter* %errorReporter, %Location %iniLocation, i1 %emitWitespace) #4 { %iniLocation.addr = alloca %Location store %Location %iniLocation, %Location* %iniLocation.addr %emitWitespace.addr = alloca i1 @@ -10825,22 +10545,22 @@ code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 store i1 false, i1* %1 %2 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 0 - call void @ctor.169(%Location* %2, %Location* %iniLocation.addr) + call void @ctor.159(%Location* %2, %Location* %iniLocation.addr) %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 1 - call void @ctor.377(%BufferedCharSource* %3, %CharSource* %chars) + call void @ctor.366(%BufferedCharSource* %3, %CharSource* %chars) %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 1 call void @all(%BufferedCharSourceRange* %"$tmpC", %BufferedCharSource* %5) - call void @ctor.380(%"RangeWithLookahead[BufferedCharSourceRange]"* %tmp.this, %BufferedCharSourceRange* %"$tmpC") + call void @ctor.369(%"RangeWithLookahead[BufferedCharSourceRange]"* %tmp.this, %BufferedCharSourceRange* %"$tmpC") %6 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 0 - call void @ctor.379(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %4, %"RangeWithLookahead[BufferedCharSourceRange]"* %tmp.this, %Location* %6) - call void @dtor.268(%"RangeWithLookahead[BufferedCharSourceRange]"* %tmp.this) + call void @ctor.368(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %4, %"RangeWithLookahead[BufferedCharSourceRange]"* %tmp.this, %Location* %6) + call void @dtor.257(%"RangeWithLookahead[BufferedCharSourceRange]"* %tmp.this) %7 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - call void @ctor.130(%Token* %7) + call void @ctor.120(%Token* %7) %8 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 4 store i1 false, i1* %8 %9 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 5 - call void @ctor.190(%ErrorReporter* %9, %ErrorReporter* %errorReporter) + call void @ctor.179(%ErrorReporter* %9, %ErrorReporter* %errorReporter) %10 = load i1, i1* %emitWitespace.addr %11 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 store i1 %10, i1* %11 @@ -10848,52 +10568,45 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.377(%BufferedCharSource* %this, %CharSource* %src) #4 { - %tmp.this = alloca i64 +define internal void @ctor.366(%BufferedCharSource* %this, %CharSource* %src) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 0 - call void @ctor.173(%CharSource* %1, %CharSource* %src) + call void @ctor.163(%CharSource* %1, %CharSource* %src) %2 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 - call void @ctor.124(%String* %2) + call void @ctor.114(%String* %2) %3 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 - store i64 4096, i64* %tmp.this - %4 = load i64, i64* %tmp.this - call void @reserve(%String* %3, i64 %4) - %5 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 2 - store i32 0, i32* %5 + call void @reserve(%String* %3, i32 4096) + %4 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 2 + store i32 0, i32* %4 call void @_ensureBufferHasData(%BufferedCharSource* %this) ret void } ; Function Attrs: inlinehint nounwind -define internal void @reserve(%String* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %curCapacity = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this8 = alloca double +define internal void @reserve(%String* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %curCapacity = alloca i32 + %tmp.this = alloca i32 + %tmp.this7 = alloca double + %tmp.this8 = alloca i32 %tmp.this9 = alloca double - %tmp.this10 = alloca i64 - %tmp.this11 = alloca double - %curSize = alloca i64 + %curSize = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this12 = alloca i64 - %"$tmpForRef13" = alloca %"RawPtr[Char]" - %tmp.this14 = alloca i64 + %"$tmpForRef10" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 - %1 = call i64 @capacity(%String* %this) - store i64 %1, i64* %curCapacity + %1 = call i32 @capacity(%String* %this) + store i32 %1, i32* %curCapacity br label %if_block if_block: ; preds = %code - %2 = load i64, i64* %n.addr - %3 = load i64, i64* %curCapacity - %4 = icmp sle i64 %2, %3 + %2 = load i32, i32* %n.addr + %3 = load i32, i32* %curCapacity + %4 = call i1 @_Int32_opLE(i32 %2, i32 %3) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block @@ -10906,102 +10619,91 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - %5 = load i64, i64* %n.addr - store i64 16, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = icmp slt i64 %5, %6 - br i1 %7, label %if_then2, label %if_end3 + %5 = load i32, i32* %n.addr + %6 = call i1 @_Int32_opLT(i32 %5, i32 16) + br i1 %6, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 16, i64* %tmp.this4 - %8 = load i64, i64* %tmp.this4 - store i64 %8, i64* %n.addr + store i32 16, i32* %n.addr br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - br label %if_block5 + br label %if_block4 -if_block5: ; preds = %if_end3 - %9 = load i64, i64* %n.addr - %10 = sitofp i64 %9 to double - store double %10, double* %tmp.this8 - %11 = load double, double* %tmp.this8 - %12 = load i64, i64* %curCapacity - %13 = sitofp i64 %12 to double - store double %13, double* %tmp.this9 - %14 = load double, double* %tmp.this9 - %15 = call double @_Double_opMul(double 1.500000e+00, double %14) - %16 = call i1 @_Double_opLT(double %11, double %15) - br i1 %16, label %if_then6, label %if_end7 +if_block4: ; preds = %if_end3 + %7 = load i32, i32* %n.addr + %8 = load i32, i32* %curCapacity + %9 = sitofp i32 %8 to double + store double %9, double* %tmp.this7 + %10 = load double, double* %tmp.this7 + %11 = call double @_Float64_opMul(double 1.500000e+00, double %10) + %12 = fptosi double %11 to i32 + store i32 %12, i32* %tmp.this + %13 = load i32, i32* %tmp.this + %14 = call i1 @_Int32_opLT(i32 %7, i32 %13) + br i1 %14, label %if_then5, label %if_end6 -if_then6: ; preds = %if_block5 - %17 = load i64, i64* %curCapacity - %18 = sitofp i64 %17 to double - store double %18, double* %tmp.this11 - %19 = load double, double* %tmp.this11 - %20 = call double @_Double_opMul(double 1.500000e+00, double %19) - %21 = fptoui double %20 to i64 - store i64 %21, i64* %tmp.this10 - %22 = load i64, i64* %tmp.this10 - store i64 %22, i64* %n.addr - br label %if_end7 +if_then5: ; preds = %if_block4 + %15 = load i32, i32* %curCapacity + %16 = sitofp i32 %15 to double + store double %16, double* %tmp.this9 + %17 = load double, double* %tmp.this9 + %18 = call double @_Float64_opMul(double 1.500000e+00, double %17) + %19 = fptosi double %18 to i32 + store i32 %19, i32* %tmp.this8 + %20 = load i32, i32* %tmp.this8 + store i32 %20, i32* %n.addr + br label %if_end6 -if_end7: ; preds = %if_then6, %if_block5 - %23 = call i64 @size.176(%String* %this) - store i64 %23, i64* %curSize - %24 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %25 = load i64, i64* %n.addr - call void @reallocPtr(%"RawPtr[Char]"* %24, i64 %25) - %26 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %27 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %28 = load i64, i64* %curSize - store i64 %28, i64* %tmp.this12 - %29 = load i64, i64* %tmp.this12 - %30 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %27, i64 %29) - store %"RawPtr[Char]" %30, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %26, %"RawPtr[Char]"* %"$tmpForRef") - %31 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 - %32 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %33 = load i64, i64* %n.addr - store i64 %33, i64* %tmp.this14 - %34 = load i64, i64* %tmp.this14 - %35 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %32, i64 %34) - store %"RawPtr[Char]" %35, %"RawPtr[Char]"* %"$tmpForRef13" - call void @"=.186"(%"RawPtr[Char]"* %31, %"RawPtr[Char]"* %"$tmpForRef13") - ret void -} - -; Function Attrs: inlinehint nounwind -define internal i64 @capacity(%String* %this) #4 { - %tmp.this = alloca i64 +if_end6: ; preds = %if_then5, %if_block4 + %21 = call i32 @size.166(%String* %this) + store i32 %21, i32* %curSize + %22 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %23 = load i32, i32* %n.addr + call void @reallocPtr(%"RawPtr[Char]"* %22, i32 %23) + %24 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %25 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %26 = load i32, i32* %curSize + %27 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %25, i32 %26) + store %"RawPtr[Char]" %27, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %24, %"RawPtr[Char]"* %"$tmpForRef") + %28 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 + %29 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %30 = load i32, i32* %n.addr + %31 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %29, i32 %30) + store %"RawPtr[Char]" %31, %"RawPtr[Char]"* %"$tmpForRef10" + call void @"=.176"(%"RawPtr[Char]"* %28, %"RawPtr[Char]"* %"$tmpForRef10") + ret void +} + +; Function Attrs: inlinehint nounwind +define internal i32 @capacity(%String* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 %2 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %3 = load %"RawPtr[Char]", %"RawPtr[Char]"* %2 - %4 = call i64 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal void @reallocPtr(%"RawPtr[Char]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @reallocPtr(%"RawPtr[Char]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 %2 = load i8*, i8** %1 - call void @ctor.67(%UntypedPtr* %tmp.this, i8* %2) + call void @ctor.57(%UntypedPtr* %tmp.this, i8* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 1 - %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i64 %5) - %7 = call i8* @asRefOf.62(%UntypedPtr %6) + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 1) + %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i32 %5) + %7 = call i8* @asRefOf.52(%UntypedPtr %6) %8 = getelementptr inbounds %"RawPtr[Char]", %"RawPtr[Char]"* %this, i32 0, i32 0 store i8* %7, i8** %8 ret void @@ -11009,7 +10711,6 @@ code: ; preds = %0 ; Function Attrs: inlinehint nounwind define internal void @_ensureBufferHasData(%BufferedCharSource* %this) #4 { - %tmp.this = alloca i64 br label %code code: ; preds = %0 @@ -11018,22 +10719,19 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 2 %2 = load i32, i32* %1 - %3 = zext i32 %2 to i64 - store i64 %3, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 - %6 = call i64 @size.176(%String* %5) - %7 = icmp sge i64 %4, %6 - br i1 %7, label %if_then, label %if_end + %3 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 + %4 = call i32 @size.166(%String* %3) + %5 = call i1 @_Int32_opGE(i32 %2, i32 %4) + br i1 %5, label %if_then, label %if_end if_then: ; preds = %if_block - %8 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 - call void @clear(%String* %8) - %9 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 2 - store i32 0, i32* %9 - %10 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 0 - %11 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 - call void @readChars(%CharSource* %10, %String* %11, i32 4096) + %6 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 + call void @clear(%String* %6) + %7 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 2 + store i32 0, i32* %7 + %8 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 0 + %9 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %this, i32 0, i32 1 + call void @readChars(%CharSource* %8, %String* %9, i32 4096) br label %if_end if_end: ; preds = %if_then, %if_block @@ -11050,11 +10748,11 @@ code: ; preds = %0 %2 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %1) %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %4 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %3) - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) %5 = load %StringRef, %StringRef* %tmp.this call void @remove(%String* %this, %StringRef %5) %6 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %6) + call void @dtor.51(%StringRef %6) ret void } @@ -11062,59 +10760,56 @@ code: ; preds = %0 define internal void @remove(%String* %this, %StringRef %range) #4 { %range.addr = alloca %StringRef store %StringRef %range, %StringRef* %range.addr - %rSize = alloca i64 + %rSize = alloca i32 %rBegin = alloca %"RawPtr[Char]" %"$tmpForRef" = alloca %"RawPtr[Char]" %rEnd = alloca %"RawPtr[Char]" %"$tmpForRef1" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 %"$tmpForRef2" = alloca %"RawPtr[Char]" %"$tmpForRef3" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = load %StringRef, %StringRef* %range.addr - %2 = call i64 @size(%StringRef %1) - store i64 %2, i64* %rSize + %2 = call i32 @size(%StringRef %1) + store i32 %2, i32* %rSize %3 = load %StringRef, %StringRef* %range.addr %4 = call %"RawPtr[Char]" @_frontPtr(%StringRef %3) store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" - call void @ctor.178(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef") - %5 = load i64, i64* %rSize - store i64 %5, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %rBegin, i64 %6) - store %"RawPtr[Char]" %7, %"RawPtr[Char]"* %"$tmpForRef1" - call void @ctor.178(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef1") + call void @ctor.168(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef") + %5 = load i32, i32* %rSize + %6 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %rBegin, i32 %5) + store %"RawPtr[Char]" %6, %"RawPtr[Char]"* %"$tmpForRef1" + call void @ctor.168(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef1") br label %while_block while_block: ; preds = %while_step, %code - %8 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %9 = call i1 @"==.257"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %8) - %10 = xor i1 true, %9 - br i1 %10, label %while_body, label %while_end + %7 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %8 = call i1 @"==.246"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %7) + %9 = xor i1 true, %8 + br i1 %9, label %while_body, label %while_end while_body: ; preds = %while_block - %11 = call i8* @value(%"RawPtr[Char]"* %rBegin) - %12 = load i8, i8* %11 - %13 = call i8* @value(%"RawPtr[Char]"* %rEnd) - %14 = load i8, i8* %13 - %15 = call i8* @value(%"RawPtr[Char]"* %rBegin) - store i8 %14, i8* %15 - %16 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %rBegin) - store %"RawPtr[Char]" %16, %"RawPtr[Char]"* %"$tmpForRef2" - call void @"=.186"(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef2") - %17 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %rEnd) - store %"RawPtr[Char]" %17, %"RawPtr[Char]"* %"$tmpForRef3" - call void @"=.186"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef3") + %10 = call i8* @value(%"RawPtr[Char]"* %rBegin) + %11 = load i8, i8* %10 + %12 = call i8* @value(%"RawPtr[Char]"* %rEnd) + %13 = load i8, i8* %12 + %14 = call i8* @value(%"RawPtr[Char]"* %rBegin) + store i8 %13, i8* %14 + %15 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %rBegin) + store %"RawPtr[Char]" %15, %"RawPtr[Char]"* %"$tmpForRef2" + call void @"=.176"(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef2") + %16 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %rEnd) + store %"RawPtr[Char]" %16, %"RawPtr[Char]"* %"$tmpForRef3" + call void @"=.176"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef3") br label %while_step while_step: ; preds = %while_body br label %while_block while_end: ; preds = %while_block - %18 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %18, %"RawPtr[Char]"* %rBegin) + %17 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + call void @"=.176"(%"RawPtr[Char]"* %17, %"RawPtr[Char]"* %rBegin) ret void } @@ -11129,9 +10824,9 @@ define internal %"RawPtr[Char]" @_frontPtr(%StringRef %s) #4 { code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %s.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - call void @ctor.55(%UntypedPtr* %tmp.this1, %UntypedPtr %2) + call void @ctor.45(%UntypedPtr* %tmp.this1, %UntypedPtr %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - call void @ctor.180(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %3) + call void @ctor.170(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %3) %4 = load %"RawPtr[Char]", %"RawPtr[Char]"* %tmp.this ret %"RawPtr[Char]" %4 } @@ -11147,12 +10842,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %CharSource, %CharSource* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load i32, i32* %numChars.addr - call void @"().378"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %1, %UntypedPtr %3, %String* %dest, i32 %4) + call void @"().367"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %1, %UntypedPtr %3, %String* %dest, i32 %4) ret void } ; Function Attrs: inlinehint nounwind -define internal void @"().378"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %UntypedPtr %p1, %String* %p2, i32 %p3) #4 { +define internal void @"().367"(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %this, %UntypedPtr %p1, %String* %p2, i32 %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca i32 @@ -11169,7 +10864,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.379(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %fsource, %Location* %flocation) #3 { +define internal void @ctor.368(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"RangeWithLookahead[BufferedCharSourceRange]"* %fsource, %Location* %flocation) #3 { %this.addr = alloca %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* store %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %this.addr %flocation.addr = alloca %Location* @@ -11179,7 +10874,7 @@ define internal void @ctor.379(%"LocationSyncCharRange[RangeWithLookahead[Buffer code: ; preds = %0 %1 = load %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"*, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %this.addr %2 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1, i32 0, i32 0 - call void @ctor.182(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, %"RangeWithLookahead[BufferedCharSourceRange]"* %fsource) + call void @ctor.172(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, %"RangeWithLookahead[BufferedCharSourceRange]"* %fsource) %3 = load %Location*, %Location** %flocation.addr %4 = load %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"*, %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"** %this.addr %5 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %4, i32 0, i32 1 @@ -11188,33 +10883,30 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.380(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %BufferedCharSourceRange* %src) #4 { - %tmp.this = alloca i64 +define internal void @ctor.369(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, %BufferedCharSourceRange* %src) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - call void @ctor.128(%BufferedCharSourceRange* %1) + call void @ctor.118(%BufferedCharSourceRange* %1) %2 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - call void @"=.282"(%BufferedCharSourceRange* %2, %BufferedCharSourceRange* %src) + call void @"=.271"(%BufferedCharSourceRange* %2, %BufferedCharSourceRange* %src) %3 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - call void @ctor.129(%"Vector[Char]"* %3) + call void @ctor.119(%"Vector[Char]"* %3) %4 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - store i64 10, i64* %tmp.this - %5 = load i64, i64* %tmp.this - call void @reserve.381(%"Vector[Char]"* %4, i64 %5) + call void @reserve.370(%"Vector[Char]"* %4, i32 10) br label %if_block if_block: ; preds = %code - %6 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %7 = call i1 @"pre_!!"(%BufferedCharSourceRange* %6) - br i1 %7, label %if_then, label %if_end + %5 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %6 = call i1 @"pre_!!"(%BufferedCharSourceRange* %5) + br i1 %6, label %if_then, label %if_end if_then: ; preds = %if_block - %8 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %9 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %10 = call i8 @"post_++.385"(%BufferedCharSourceRange* %9) - call void @"+="(%"Vector[Char]"* %8, i8 %10) + %7 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %8 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %9 = call i8 @"post_++.374"(%BufferedCharSourceRange* %8) + call void @"+="(%"Vector[Char]"* %7, i8 %9) br label %if_end if_end: ; preds = %if_then, %if_block @@ -11222,30 +10914,28 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal void @reserve.381(%"Vector[Char]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %curCapacity = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this8 = alloca double +define internal void @reserve.370(%"Vector[Char]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %curCapacity = alloca i32 + %tmp.this = alloca i32 + %tmp.this7 = alloca double + %tmp.this8 = alloca i32 %tmp.this9 = alloca double - %tmp.this10 = alloca i64 - %tmp.this11 = alloca double - %curSize = alloca i64 + %curSize = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Char]" - %"$tmpForRef12" = alloca %"RawPtr[Char]" + %"$tmpForRef10" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 - %1 = call i64 @capacity.382(%"Vector[Char]"* %this) - store i64 %1, i64* %curCapacity + %1 = call i32 @capacity.371(%"Vector[Char]"* %this) + store i32 %1, i32* %curCapacity br label %if_block if_block: ; preds = %code - %2 = load i64, i64* %n.addr - %3 = load i64, i64* %curCapacity - %4 = icmp sle i64 %2, %3 + %2 = load i32, i32* %n.addr + %3 = load i32, i32* %curCapacity + %4 = call i1 @_Int32_opLE(i32 %2, i32 %3) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block @@ -11258,80 +10948,73 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - %5 = load i64, i64* %n.addr - store i64 8, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = icmp slt i64 %5, %6 - br i1 %7, label %if_then2, label %if_end3 + %5 = load i32, i32* %n.addr + %6 = call i1 @_Int32_opLT(i32 %5, i32 8) + br i1 %6, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 8, i64* %tmp.this4 - %8 = load i64, i64* %tmp.this4 - store i64 %8, i64* %n.addr + store i32 8, i32* %n.addr br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - br label %if_block5 + br label %if_block4 -if_block5: ; preds = %if_end3 - %9 = load i64, i64* %n.addr - %10 = sitofp i64 %9 to double - store double %10, double* %tmp.this8 - %11 = load double, double* %tmp.this8 - %12 = load i64, i64* %curCapacity - %13 = sitofp i64 %12 to double - store double %13, double* %tmp.this9 - %14 = load double, double* %tmp.this9 - %15 = call double @_Double_opMul(double 2.000000e+00, double %14) - %16 = call i1 @_Double_opLT(double %11, double %15) - br i1 %16, label %if_then6, label %if_end7 +if_block4: ; preds = %if_end3 + %7 = load i32, i32* %n.addr + %8 = load i32, i32* %curCapacity + %9 = sitofp i32 %8 to double + store double %9, double* %tmp.this7 + %10 = load double, double* %tmp.this7 + %11 = call double @_Float64_opMul(double 2.000000e+00, double %10) + %12 = fptosi double %11 to i32 + store i32 %12, i32* %tmp.this + %13 = load i32, i32* %tmp.this + %14 = call i1 @_Int32_opLT(i32 %7, i32 %13) + br i1 %14, label %if_then5, label %if_end6 -if_then6: ; preds = %if_block5 - %17 = load i64, i64* %curCapacity - %18 = sitofp i64 %17 to double - store double %18, double* %tmp.this11 - %19 = load double, double* %tmp.this11 - %20 = call double @_Double_opMul(double 2.000000e+00, double %19) - %21 = fptoui double %20 to i64 - store i64 %21, i64* %tmp.this10 - %22 = load i64, i64* %tmp.this10 - store i64 %22, i64* %n.addr - br label %if_end7 +if_then5: ; preds = %if_block4 + %15 = load i32, i32* %curCapacity + %16 = sitofp i32 %15 to double + store double %16, double* %tmp.this9 + %17 = load double, double* %tmp.this9 + %18 = call double @_Float64_opMul(double 2.000000e+00, double %17) + %19 = fptosi double %18 to i32 + store i32 %19, i32* %tmp.this8 + %20 = load i32, i32* %tmp.this8 + store i32 %20, i32* %n.addr + br label %if_end6 -if_end7: ; preds = %if_then6, %if_block5 - %23 = call i64 @size.185(%"Vector[Char]"* %this) - store i64 %23, i64* %curSize - %24 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - %25 = load i64, i64* %n.addr - call void @reallocPtr(%"RawPtr[Char]"* %24, i64 %25) - %26 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %27 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - %28 = load i64, i64* %curSize - %29 = call %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %27, i64 %28) - store %"RawPtr[Char]" %29, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %26, %"RawPtr[Char]"* %"$tmpForRef") - %30 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 - %31 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - %32 = load i64, i64* %n.addr - %33 = call %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %31, i64 %32) - store %"RawPtr[Char]" %33, %"RawPtr[Char]"* %"$tmpForRef12" - call void @"=.186"(%"RawPtr[Char]"* %30, %"RawPtr[Char]"* %"$tmpForRef12") - ret void -} - -; Function Attrs: inlinehint nounwind -define internal i64 @capacity.382(%"Vector[Char]"* %this) #4 { - %tmp.this = alloca i64 +if_end6: ; preds = %if_then5, %if_block4 + %21 = call i32 @size.175(%"Vector[Char]"* %this) + store i32 %21, i32* %curSize + %22 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 + %23 = load i32, i32* %n.addr + call void @reallocPtr(%"RawPtr[Char]"* %22, i32 %23) + %24 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 + %25 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 + %26 = load i32, i32* %curSize + %27 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %25, i32 %26) + store %"RawPtr[Char]" %27, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %24, %"RawPtr[Char]"* %"$tmpForRef") + %28 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 + %29 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 + %30 = load i32, i32* %n.addr + %31 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %29, i32 %30) + store %"RawPtr[Char]" %31, %"RawPtr[Char]"* %"$tmpForRef10" + call void @"=.176"(%"RawPtr[Char]"* %28, %"RawPtr[Char]"* %"$tmpForRef10") + ret void +} + +; Function Attrs: inlinehint nounwind +define internal i32 @capacity.371(%"Vector[Char]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 %3 = load %"RawPtr[Char]", %"RawPtr[Char]"* %2 - %4 = call i64 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind @@ -11339,31 +11022,31 @@ define internal i1 @"pre_!!"(%BufferedCharSourceRange* %r) #4 { br label %code code: ; preds = %0 - %1 = call i1 @isEmpty.383(%BufferedCharSourceRange* %r) + %1 = call i1 @isEmpty.372(%BufferedCharSourceRange* %r) %2 = xor i1 true, %1 ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.383(%BufferedCharSourceRange* %this) #4 { +define internal i1 @isEmpty.372(%BufferedCharSourceRange* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %BufferedCharSourceRange, %BufferedCharSourceRange* %this, i32 0, i32 0 %2 = load %BufferedCharSource*, %BufferedCharSource** %1 %3 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %2, i32 0, i32 1 - %4 = call i1 @isEmpty.384(%String* %3) + %4 = call i1 @isEmpty.373(%String* %3) ret i1 %4 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.384(%String* %this) #4 { +define internal i1 @isEmpty.373(%String* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %2 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %3 = call i1 @"==.257"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) + %3 = call i1 @"==.246"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) ret i1 %3 } @@ -11383,10 +11066,7 @@ code: ; preds = %0 define internal void @pushBack(%"Vector[Char]"* %this, i8 %value) #4 { %value.addr = alloca i8 store i8 %value, i8* %value.addr - %t = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 + %t = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Char]" br label %code @@ -11396,64 +11076,57 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 - %3 = call i1 @"==.257"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) + %3 = call i1 @"==.246"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block - store i64 2, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call i64 @capacity.382(%"Vector[Char]"* %this) - %6 = mul i64 %4, %5 - store i64 %6, i64* %t + %4 = call i32 @capacity.371(%"Vector[Char]"* %this) + %5 = call i32 @_Int32_opMul(i32 2, i32 %4) + store i32 %5, i32* %t br label %if_block1 if_end: ; preds = %if_end3, %if_block - %7 = load i8, i8* %value.addr - %8 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %9 = call i8* @value(%"RawPtr[Char]"* %8) - store i8 %7, i8* %9 + %6 = load i8, i8* %value.addr + %7 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 + %8 = call i8* @value(%"RawPtr[Char]"* %7) + store i8 %6, i8* %8 + %9 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %10 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %11 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %12 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %11) - store %"RawPtr[Char]" %12, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %10, %"RawPtr[Char]"* %"$tmpForRef") + %11 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %10) + store %"RawPtr[Char]" %11, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %9, %"RawPtr[Char]"* %"$tmpForRef") ret void if_block1: ; preds = %if_then - %13 = load i64, i64* %t - store i64 2, i64* %tmp.this4 - %14 = load i64, i64* %tmp.this4 - %15 = icmp slt i64 %13, %14 - br i1 %15, label %if_then2, label %if_end3 + %12 = load i32, i32* %t + %13 = call i1 @_Int32_opLT(i32 %12, i32 2) + br i1 %13, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 2, i64* %tmp.this5 - %16 = load i64, i64* %tmp.this5 - store i64 %16, i64* %t + store i32 2, i32* %t br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - %17 = load i64, i64* %t - call void @reserve.381(%"Vector[Char]"* %this, i64 %17) + %14 = load i32, i32* %t + call void @reserve.370(%"Vector[Char]"* %this, i32 %14) br label %if_end } ; Function Attrs: inlinehint nounwind -define internal i8 @"post_++.385"(%BufferedCharSourceRange* %r) #4 { +define internal i8 @"post_++.374"(%BufferedCharSourceRange* %r) #4 { %res = alloca i8 br label %code code: ; preds = %0 - %1 = call i8 @front.386(%BufferedCharSourceRange* %r) + %1 = call i8 @front.375(%BufferedCharSourceRange* %r) store i8 %1, i8* %res - call void @popFront.387(%BufferedCharSourceRange* %r) + call void @popFront.376(%BufferedCharSourceRange* %r) %2 = load i8, i8* %res ret i8 %2 } ; Function Attrs: inlinehint nounwind -define internal i8 @front.386(%BufferedCharSourceRange* %this) #4 { - %tmp.this = alloca i64 +define internal i8 @front.375(%BufferedCharSourceRange* %this) #4 { br label %code code: ; preds = %0 @@ -11464,23 +11137,20 @@ code: ; preds = %0 %5 = load %BufferedCharSource*, %BufferedCharSource** %4 %6 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %5, i32 0, i32 2 %7 = load i32, i32* %6 - %8 = zext i32 %7 to i64 - store i64 %8, i64* %tmp.this - %9 = load i64, i64* %tmp.this - %10 = call i8* @"().332"(%String* %3, i64 %9) - %11 = load i8, i8* %10 - ret i8 %11 + %8 = call i8* @"().321"(%String* %3, i32 %7) + %9 = load i8, i8* %8 + ret i8 %9 } ; Function Attrs: inlinehint nounwind -define internal void @popFront.387(%BufferedCharSourceRange* %this) #4 { +define internal void @popFront.376(%BufferedCharSourceRange* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %BufferedCharSourceRange, %BufferedCharSourceRange* %this, i32 0, i32 0 %2 = load %BufferedCharSource*, %BufferedCharSource** %1 %3 = getelementptr inbounds %BufferedCharSource, %BufferedCharSource* %2, i32 0, i32 2 - %4 = call i32 @"post_++.39"(i32* %3) + %4 = call i32 @"post_++.33"(i32* %3) %5 = getelementptr inbounds %BufferedCharSourceRange, %BufferedCharSourceRange* %this, i32 0, i32 0 %6 = load %BufferedCharSource*, %BufferedCharSource** %5 call void @_ensureBufferHasData(%BufferedCharSource* %6) @@ -11495,12 +11165,12 @@ define internal void @all(%BufferedCharSourceRange* sret %_result, %BufferedChar code: ; preds = %0 %1 = load %BufferedCharSource*, %BufferedCharSource** %this.addr - call void @ctor.388(%BufferedCharSourceRange* %_result, %BufferedCharSource* %1) + call void @ctor.377(%BufferedCharSourceRange* %_result, %BufferedCharSource* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.388(%BufferedCharSourceRange* %this, %BufferedCharSource* %f_data) #3 { +define internal void @ctor.377(%BufferedCharSourceRange* %this, %BufferedCharSource* %f_data) #3 { %this.addr = alloca %BufferedCharSourceRange* store %BufferedCharSourceRange* %this, %BufferedCharSourceRange** %this.addr %f_data.addr = alloca %BufferedCharSource* @@ -11516,67 +11186,64 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.389(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %SparrowScanner* %tokens, %ErrorReporter* %errorReporter) #4 { - %tmp.this = alloca i32 - %tmp.this1 = alloca %TokenType +define internal void @ctor.378(%"SparrowLayoutDecoder[SparrowScanner]"* %this, %SparrowScanner* %tokens, %ErrorReporter* %errorReporter) #4 { + %tmp.this = alloca %TokenType %"$tmpC" = alloca %Token - %tmp.this2 = alloca %TokenType + %tmp.this1 = alloca %TokenType br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - call void @ctor.138(%"Vector[UInt]"* %1) + call void @ctor.128(%"Vector[Int]"* %1) %2 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @ctor.129(%"Vector[Char]"* %2) + call void @ctor.119(%"Vector[Char]"* %2) %3 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @ctor.131(%TokenType* %3) + call void @ctor.121(%TokenType* %3) %4 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 store i32 0, i32* %4 %5 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @ctor.390(%"RangeWithLookahead[SparrowScanner]"* %5, %SparrowScanner* %tokens) + call void @ctor.379(%"RangeWithLookahead[SparrowScanner]"* %5, %SparrowScanner* %tokens) %6 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 1 - call void @ctor.190(%ErrorReporter* %6, %ErrorReporter* %errorReporter) + call void @ctor.179(%ErrorReporter* %6, %ErrorReporter* %errorReporter) %7 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - store i32 1, i32* %tmp.this - %8 = load i32, i32* %tmp.this - call void @"+=.474"(%"Vector[UInt]"* %7, i32 %8) - %9 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @ctor.404(%TokenType* %tmp.this1, i32 32) - call void @"=.286"(%TokenType* %9, %TokenType* %tmp.this1) - %10 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 - store i32 0, i32* %10 + call void @"+=.463"(%"Vector[Int]"* %7, i32 1) + %8 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 + call void @ctor.393(%TokenType* %tmp.this, i32 32) + call void @"=.275"(%TokenType* %8, %TokenType* %tmp.this) + %9 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 + store i32 0, i32* %9 br label %if_block if_block: ; preds = %code - %11 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - %12 = call i1 @isEmpty.479(%"RangeWithLookahead[SparrowScanner]"* %11) - %13 = xor i1 true, %12 - br i1 %13, label %cond.true, label %cond.false + %10 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 + %11 = call i1 @isEmpty.468(%"RangeWithLookahead[SparrowScanner]"* %10) + %12 = xor i1 true, %11 + br i1 %12, label %cond.true, label %cond.false if_then: ; preds = %cond.end - call void @popFront.483(%"SparrowLayoutDecoder[SparrowScanner]"* %this) + call void @popFront.472(%"SparrowLayoutDecoder[SparrowScanner]"* %this) br label %if_end if_end: ; preds = %if_then, %cond.end - br i1 %13, label %cond_destruct_alt1, label %cond_destruct_alt2 + br i1 %12, label %cond_destruct_alt1, label %cond_destruct_alt2 cond.true: ; preds = %if_block - %14 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @front.481(%Token* %"$tmpC", %"RangeWithLookahead[SparrowScanner]"* %14) - %15 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this2, i32 1) - %16 = call i1 @"==.339"(%TokenType* %15, %TokenType* %tmp.this2) + %13 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 + call void @front.470(%Token* %"$tmpC", %"RangeWithLookahead[SparrowScanner]"* %13) + %14 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this1, i32 1) + %15 = call i1 @"==.328"(%TokenType* %14, %TokenType* %tmp.this1) br label %cond.end cond.false: ; preds = %if_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %16, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %15, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %if_then, label %if_end cond_destruct_alt1: ; preds = %if_end - call void @dtor.249(%Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") br label %cond_destruct_end cond_destruct_alt2: ; preds = %if_end @@ -11587,35 +11254,32 @@ cond_destruct_end: ; preds = %cond_destruct_alt2, } ; Function Attrs: inlinehint nounwind -define internal void @ctor.390(%"RangeWithLookahead[SparrowScanner]"* %this, %SparrowScanner* %src) #4 { - %tmp.this = alloca i64 +define internal void @ctor.379(%"RangeWithLookahead[SparrowScanner]"* %this, %SparrowScanner* %src) #4 { %"$tmpC" = alloca %Token br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - call void @ctor.117(%SparrowScanner* %1) + call void @ctor.107(%SparrowScanner* %1) %2 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - call void @"=.271"(%SparrowScanner* %2, %SparrowScanner* %src) + call void @"=.260"(%SparrowScanner* %2, %SparrowScanner* %src) %3 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - call void @ctor.136(%"Vector[Token]"* %3) + call void @ctor.126(%"Vector[Token]"* %3) %4 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - store i64 10, i64* %tmp.this - %5 = load i64, i64* %tmp.this - call void @reserve.391(%"Vector[Token]"* %4, i64 %5) + call void @reserve.380(%"Vector[Token]"* %4, i32 10) br label %if_block if_block: ; preds = %code - %6 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - %7 = call i1 @"pre_!!.394"(%SparrowScanner* %6) - br i1 %7, label %if_then, label %if_end + %5 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 + %6 = call i1 @"pre_!!.383"(%SparrowScanner* %5) + br i1 %6, label %if_then, label %if_end if_then: ; preds = %if_block - %8 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - %9 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - call void @"post_++.398"(%Token* %"$tmpC", %SparrowScanner* %9) - call void @"+=.396"(%"Vector[Token]"* %8, %Token* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC") + %7 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 + %8 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 + call void @"post_++.387"(%Token* %"$tmpC", %SparrowScanner* %8) + call void @"+=.385"(%"Vector[Token]"* %7, %Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") br label %if_end if_end: ; preds = %if_then, %if_block @@ -11623,30 +11287,28 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal void @reserve.391(%"Vector[Token]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %curCapacity = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this8 = alloca double +define internal void @reserve.380(%"Vector[Token]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %curCapacity = alloca i32 + %tmp.this = alloca i32 + %tmp.this7 = alloca double + %tmp.this8 = alloca i32 %tmp.this9 = alloca double - %tmp.this10 = alloca i64 - %tmp.this11 = alloca double - %curSize = alloca i64 + %curSize = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Token]" - %"$tmpForRef12" = alloca %"RawPtr[Token]" + %"$tmpForRef10" = alloca %"RawPtr[Token]" br label %code code: ; preds = %0 - %1 = call i64 @capacity.392(%"Vector[Token]"* %this) - store i64 %1, i64* %curCapacity + %1 = call i32 @capacity.381(%"Vector[Token]"* %this) + store i32 %1, i32* %curCapacity br label %if_block if_block: ; preds = %code - %2 = load i64, i64* %n.addr - %3 = load i64, i64* %curCapacity - %4 = icmp sle i64 %2, %3 + %2 = load i32, i32* %n.addr + %3 = load i32, i32* %curCapacity + %4 = call i1 @_Int32_opLE(i32 %2, i32 %3) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block @@ -11659,115 +11321,108 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - %5 = load i64, i64* %n.addr - store i64 8, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = icmp slt i64 %5, %6 - br i1 %7, label %if_then2, label %if_end3 + %5 = load i32, i32* %n.addr + %6 = call i1 @_Int32_opLT(i32 %5, i32 8) + br i1 %6, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 8, i64* %tmp.this4 - %8 = load i64, i64* %tmp.this4 - store i64 %8, i64* %n.addr + store i32 8, i32* %n.addr br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - br label %if_block5 + br label %if_block4 -if_block5: ; preds = %if_end3 - %9 = load i64, i64* %n.addr - %10 = sitofp i64 %9 to double - store double %10, double* %tmp.this8 - %11 = load double, double* %tmp.this8 - %12 = load i64, i64* %curCapacity - %13 = sitofp i64 %12 to double - store double %13, double* %tmp.this9 - %14 = load double, double* %tmp.this9 - %15 = call double @_Double_opMul(double 2.000000e+00, double %14) - %16 = call i1 @_Double_opLT(double %11, double %15) - br i1 %16, label %if_then6, label %if_end7 +if_block4: ; preds = %if_end3 + %7 = load i32, i32* %n.addr + %8 = load i32, i32* %curCapacity + %9 = sitofp i32 %8 to double + store double %9, double* %tmp.this7 + %10 = load double, double* %tmp.this7 + %11 = call double @_Float64_opMul(double 2.000000e+00, double %10) + %12 = fptosi double %11 to i32 + store i32 %12, i32* %tmp.this + %13 = load i32, i32* %tmp.this + %14 = call i1 @_Int32_opLT(i32 %7, i32 %13) + br i1 %14, label %if_then5, label %if_end6 -if_then6: ; preds = %if_block5 - %17 = load i64, i64* %curCapacity - %18 = sitofp i64 %17 to double - store double %18, double* %tmp.this11 - %19 = load double, double* %tmp.this11 - %20 = call double @_Double_opMul(double 2.000000e+00, double %19) - %21 = fptoui double %20 to i64 - store i64 %21, i64* %tmp.this10 - %22 = load i64, i64* %tmp.this10 - store i64 %22, i64* %n.addr - br label %if_end7 +if_then5: ; preds = %if_block4 + %15 = load i32, i32* %curCapacity + %16 = sitofp i32 %15 to double + store double %16, double* %tmp.this9 + %17 = load double, double* %tmp.this9 + %18 = call double @_Float64_opMul(double 2.000000e+00, double %17) + %19 = fptosi double %18 to i32 + store i32 %19, i32* %tmp.this8 + %20 = load i32, i32* %tmp.this8 + store i32 %20, i32* %n.addr + br label %if_end6 -if_end7: ; preds = %if_then6, %if_block5 - %23 = call i64 @size.195(%"Vector[Token]"* %this) - store i64 %23, i64* %curSize - %24 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %25 = load i64, i64* %n.addr - call void @reallocPtr.393(%"RawPtr[Token]"* %24, i64 %25) - %26 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %27 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %28 = load i64, i64* %curSize - %29 = call %"RawPtr[Token]" @advance.201(%"RawPtr[Token]"* %27, i64 %28) - store %"RawPtr[Token]" %29, %"RawPtr[Token]"* %"$tmpForRef" - call void @"=.198"(%"RawPtr[Token]"* %26, %"RawPtr[Token]"* %"$tmpForRef") - %30 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 - %31 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %32 = load i64, i64* %n.addr - %33 = call %"RawPtr[Token]" @advance.201(%"RawPtr[Token]"* %31, i64 %32) - store %"RawPtr[Token]" %33, %"RawPtr[Token]"* %"$tmpForRef12" - call void @"=.198"(%"RawPtr[Token]"* %30, %"RawPtr[Token]"* %"$tmpForRef12") - ret void -} - -; Function Attrs: inlinehint nounwind -define internal i64 @capacity.392(%"Vector[Token]"* %this) #4 { - %tmp.this = alloca i64 +if_end6: ; preds = %if_then5, %if_block4 + %21 = call i32 @size.184(%"Vector[Token]"* %this) + store i32 %21, i32* %curSize + %22 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 + %23 = load i32, i32* %n.addr + call void @reallocPtr.382(%"RawPtr[Token]"* %22, i32 %23) + %24 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 + %25 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 + %26 = load i32, i32* %curSize + %27 = call %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %25, i32 %26) + store %"RawPtr[Token]" %27, %"RawPtr[Token]"* %"$tmpForRef" + call void @"=.187"(%"RawPtr[Token]"* %24, %"RawPtr[Token]"* %"$tmpForRef") + %28 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 + %29 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 + %30 = load i32, i32* %n.addr + %31 = call %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %29, i32 %30) + store %"RawPtr[Token]" %31, %"RawPtr[Token]"* %"$tmpForRef10" + call void @"=.187"(%"RawPtr[Token]"* %28, %"RawPtr[Token]"* %"$tmpForRef10") + ret void +} + +; Function Attrs: inlinehint nounwind +define internal i32 @capacity.381(%"Vector[Token]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 %3 = load %"RawPtr[Token]", %"RawPtr[Token]"* %2 - %4 = call i64 @diff.196(%"RawPtr[Token]"* %1, %"RawPtr[Token]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff.185(%"RawPtr[Token]"* %1, %"RawPtr[Token]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal void @reallocPtr.393(%"RawPtr[Token]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @reallocPtr.382(%"RawPtr[Token]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 %2 = load %Token*, %Token** %1 - call void @ctor.197(%UntypedPtr* %tmp.this, %Token* %2) + call void @ctor.186(%UntypedPtr* %tmp.this, %Token* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 72 - %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i64 %5) - %7 = call %Token* @asRefOf.203(%UntypedPtr %6) + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 72) + %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i32 %5) + %7 = call %Token* @asRefOf.192(%UntypedPtr %6) %8 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 store %Token* %7, %Token** %8 ret void } ; Function Attrs: inlinehint nounwind -define internal i1 @"pre_!!.394"(%SparrowScanner* %r) #4 { +define internal i1 @"pre_!!.383"(%SparrowScanner* %r) #4 { br label %code code: ; preds = %0 - %1 = call i1 @isEmpty.395(%SparrowScanner* %r) + %1 = call i1 @isEmpty.384(%SparrowScanner* %r) %2 = xor i1 true, %1 ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.395(%SparrowScanner* %this) #4 { +define internal i1 @isEmpty.384(%SparrowScanner* %this) #4 { br label %code code: ; preds = %0 @@ -11775,20 +11430,17 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @"+=.396"(%"Vector[Token]"* %this, %Token* %value) #4 { +define internal void @"+=.385"(%"Vector[Token]"* %this, %Token* %value) #4 { br label %code code: ; preds = %0 - call void @pushBack.397(%"Vector[Token]"* %this, %Token* %value) + call void @pushBack.386(%"Vector[Token]"* %this, %Token* %value) ret void } ; Function Attrs: inlinehint nounwind -define internal void @pushBack.397(%"Vector[Token]"* %this, %Token* %value) #4 { - %t = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 +define internal void @pushBack.386(%"Vector[Token]"* %this, %Token* %value) #4 { + %t = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Token]" br label %code @@ -11798,66 +11450,60 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 - %3 = call i1 @"==.205"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %2) + %3 = call i1 @"==.194"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block - store i64 2, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call i64 @capacity.392(%"Vector[Token]"* %this) - %6 = mul i64 %4, %5 - store i64 %6, i64* %t + %4 = call i32 @capacity.381(%"Vector[Token]"* %this) + %5 = call i32 @_Int32_opMul(i32 2, i32 %4) + store i32 %5, i32* %t br label %if_block1 if_end: ; preds = %if_end3, %if_block - %7 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %8 = call %Token* @value.206(%"RawPtr[Token]"* %7) - call void @ctor.188(%Token* %8, %Token* %value) + %6 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 + %7 = call %Token* @value.195(%"RawPtr[Token]"* %6) + call void @ctor.177(%Token* %7, %Token* %value) + %8 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %9 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %10 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %11 = call %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %10) - store %"RawPtr[Token]" %11, %"RawPtr[Token]"* %"$tmpForRef" - call void @"=.198"(%"RawPtr[Token]"* %9, %"RawPtr[Token]"* %"$tmpForRef") + %10 = call %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %9) + store %"RawPtr[Token]" %10, %"RawPtr[Token]"* %"$tmpForRef" + call void @"=.187"(%"RawPtr[Token]"* %8, %"RawPtr[Token]"* %"$tmpForRef") ret void if_block1: ; preds = %if_then - %12 = load i64, i64* %t - store i64 2, i64* %tmp.this4 - %13 = load i64, i64* %tmp.this4 - %14 = icmp slt i64 %12, %13 - br i1 %14, label %if_then2, label %if_end3 + %11 = load i32, i32* %t + %12 = call i1 @_Int32_opLT(i32 %11, i32 2) + br i1 %12, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 2, i64* %tmp.this5 - %15 = load i64, i64* %tmp.this5 - store i64 %15, i64* %t + store i32 2, i32* %t br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - %16 = load i64, i64* %t - call void @reserve.391(%"Vector[Token]"* %this, i64 %16) + %13 = load i32, i32* %t + call void @reserve.380(%"Vector[Token]"* %this, i32 %13) br label %if_end } ; Function Attrs: inlinehint nounwind -define internal void @"post_++.398"(%Token* sret %_result, %SparrowScanner* %r) #4 { +define internal void @"post_++.387"(%Token* sret %_result, %SparrowScanner* %r) #4 { %res = alloca %Token br label %code code: ; preds = %0 - call void @front.399(%Token* %res, %SparrowScanner* %r) - call void @popFront.400(%SparrowScanner* %r) - call void @ctor.188(%Token* %_result, %Token* %res) - call void @dtor.249(%Token* %res) + call void @front.388(%Token* %res, %SparrowScanner* %r) + call void @popFront.389(%SparrowScanner* %r) + call void @ctor.177(%Token* %_result, %Token* %res) + call void @dtor.238(%Token* %res) ret void dumy_block: ; No predecessors! - call void @dtor.249(%Token* %res) + call void @dtor.238(%Token* %res) ret void } ; Function Attrs: inlinehint nounwind -define internal void @front.399(%Token* sret %_result, %SparrowScanner* %this) #4 { +define internal void @front.388(%Token* sret %_result, %SparrowScanner* %this) #4 { br label %code code: ; preds = %0 @@ -11872,17 +11518,17 @@ if_block: ; preds = %code if_then: ; preds = %if_block %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 4 store i1 true, i1* %4 - call void @popFront.400(%SparrowScanner* %this) + call void @popFront.389(%SparrowScanner* %this) br label %if_end if_end: ; preds = %if_then, %if_block %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - call void @ctor.188(%Token* %_result, %Token* %5) + call void @ctor.177(%Token* %_result, %Token* %5) ret void } ; Function Attrs: inlinehint nounwind -define internal void @popFront.400(%SparrowScanner* %this) #4 { +define internal void @popFront.389(%SparrowScanner* %this) #4 { %tmp.this = alloca %TokenType %"$tmpC" = alloca %TokenType br label %code @@ -11892,7 +11538,7 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %2 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) + %2 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) br i1 %2, label %if_then, label %if_else if_then: ; preds = %if_block @@ -11902,8 +11548,8 @@ if_then: ; preds = %if_block call void @stepOver(%Location* %5) %6 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %7 = getelementptr inbounds %Token, %Token* %6, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this, i32 0) - call void @"=.286"(%TokenType* %7, %TokenType* %tmp.this) + call void @ctor.393(%TokenType* %tmp.this, i32 0) + call void @"=.275"(%TokenType* %7, %TokenType* %tmp.this) %8 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %9 = getelementptr inbounds %Token, %Token* %8, i32 0, i32 2 call void @clear(%String* %9) @@ -11912,20 +11558,20 @@ if_then: ; preds = %if_block %12 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %13 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %12, i32 0, i32 1 %14 = load %Location*, %Location** %13 - call void @"=.272"(%Location* %11, %Location* %14) + call void @"=.261"(%Location* %11, %Location* %14) br label %if_end if_else: ; preds = %if_block %15 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %16 = getelementptr inbounds %Token, %Token* %15, i32 0, i32 1 call void @nextToken(%TokenType* %"$tmpC", %SparrowScanner* %this) - call void @"=.286"(%TokenType* %16, %TokenType* %"$tmpC") + call void @"=.275"(%TokenType* %16, %TokenType* %"$tmpC") %17 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %18 = getelementptr inbounds %Token, %Token* %17, i32 0, i32 0 %19 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %20 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %19, i32 0, i32 1 %21 = load %Location*, %Location** %20 - call void @"=.272"(%Location* %18, %Location* %21) + call void @"=.261"(%Location* %18, %Location* %21) br label %if_end if_end: ; preds = %if_else, %if_then @@ -11933,33 +11579,33 @@ if_end: ; preds = %if_else, %if_then } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #4 { +define internal i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 - %2 = call i1 @isEmpty.402(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) + %2 = call i1 @isEmpty.391(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.402(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #4 { +define internal i1 @isEmpty.391(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %2 = call i1 @isEmpty.403(%"Vector[Char]"* %1) + %2 = call i1 @isEmpty.392(%"Vector[Char]"* %1) ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.403(%"Vector[Char]"* %this) #4 { +define internal i1 @isEmpty.392(%"Vector[Char]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %3 = call i1 @"==.257"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) + %3 = call i1 @"==.246"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) ret i1 %3 } @@ -11970,12 +11616,12 @@ define internal void @stepOver(%Location* %l) #4 { code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 %2 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 - call void @"=.274"(%LineCol* %1, %LineCol* %2) + call void @"=.263"(%LineCol* %1, %LineCol* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.404(%TokenType* %this, i32 %fdata) #3 { +define internal void @ctor.393(%TokenType* %this, i32 %fdata) #3 { %this.addr = alloca %TokenType* store %TokenType* %this, %TokenType** %this.addr %fdata.addr = alloca i32 @@ -11991,7 +11637,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.405(%TokenType* %this) #3 { +define internal void @dtor.394(%TokenType* %this) #3 { br label %code code: ; preds = %0 @@ -12001,32 +11647,28 @@ code: ; preds = %0 ; Function Attrs: noinline nounwind define void @nextToken(%TokenType* sret %_result, %SparrowScanner* %this) #5 { %loc = alloca %Location* - %tmp.this = alloca i32 - %tmp.this1 = alloca i32 %ch = alloca i8 %ch2 = alloca i8 - %tmp.this9 = alloca %"$lambdaEnclosureData" - %ch16 = alloca i8 - %ch217 = alloca i8 - %tmp.this21 = alloca %"$lambdaEnclosureData.0" + %tmp.this = alloca %"$lambdaEnclosureData" + %ch14 = alloca i8 + %ch215 = alloca i8 + %tmp.this19 = alloca %"$lambdaEnclosureData.0" %"$tmpC" = alloca %String %"$tmpForRef" = alloca %StringRef %tmp.StringRef = alloca %StringRef - %tmp.this30 = alloca %"$lambdaEnclosureData.1" - %tmp.this47 = alloca %"$lambdaEnclosureData.2" - %tmp.this60 = alloca i64 + %tmp.this28 = alloca %"$lambdaEnclosureData.1" + %tmp.this45 = alloca %"$lambdaEnclosureData.2" %c1 = alloca i8 %c2 = alloca i8 - %tmp.this76 = alloca %String - %tmp.StringRef77 = alloca %StringRef - %tmp.this91 = alloca i64 - %"$tmpC200" = alloca %String - %"$tmpForRef201" = alloca %StringRef - %tmp.StringRef202 = alloca %StringRef - %"$tmpForRef203" = alloca %StringRef - %tmp.StringRef204 = alloca %StringRef - %tmp.this205 = alloca i32 - %"$tmpForRef206" = alloca i8 + %tmp.this73 = alloca %String + %tmp.StringRef74 = alloca %StringRef + %"$tmpC196" = alloca %String + %"$tmpForRef197" = alloca %StringRef + %tmp.StringRef198 = alloca %StringRef + %"$tmpForRef199" = alloca %StringRef + %tmp.StringRef200 = alloca %StringRef + %tmp.this201 = alloca i32 + %"$tmpForRef202" = alloca i8 br label %code code: ; preds = %0 @@ -12041,429 +11683,427 @@ if_block: ; preds = %code %5 = getelementptr inbounds %Location, %Location* %4, i32 0, i32 1 %6 = getelementptr inbounds %LineCol, %LineCol* %5, i32 0, i32 0 %7 = load i32, i32* %6 - store i32 1, i32* %tmp.this - %8 = load i32, i32* %tmp.this - %9 = icmp eq i32 %7, %8 - br i1 %9, label %cond.true, label %cond.false + %8 = call i1 @_Int32_opEQ(i32 %7, i32 1) + br i1 %8, label %cond.true, label %cond.false if_then: ; preds = %cond.end - %10 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %11 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %10) - store i8 %11, i8* %ch - %12 = call i8 @peekChar(%SparrowScanner* %this) - store i8 %12, i8* %ch2 - br label %if_block2 + %9 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %10 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %9) + store i8 %10, i8* %ch + %11 = call i8 @peekChar(%SparrowScanner* %this) + store i8 %11, i8* %ch2 + br label %if_block1 -if_end: ; preds = %if_end4, %cond.end - br i1 %9, label %cond_destruct_alt1, label %cond_destruct_alt2 +if_end: ; preds = %if_end3, %cond.end + br label %while_block cond.true: ; preds = %if_block - %13 = load %Location*, %Location** %loc - %14 = getelementptr inbounds %Location, %Location* %13, i32 0, i32 1 - %15 = getelementptr inbounds %LineCol, %LineCol* %14, i32 0, i32 1 - %16 = load i32, i32* %15 - store i32 1, i32* %tmp.this1 - %17 = load i32, i32* %tmp.this1 - %18 = icmp eq i32 %16, %17 + %12 = load %Location*, %Location** %loc + %13 = getelementptr inbounds %Location, %Location* %12, i32 0, i32 1 + %14 = getelementptr inbounds %LineCol, %LineCol* %13, i32 0, i32 1 + %15 = load i32, i32* %14 + %16 = call i1 @_Int32_opEQ(i32 %15, i32 1) br label %cond.end cond.false: ; preds = %if_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %18, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %16, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %if_then, label %if_end -if_block2: ; preds = %if_then - %19 = load i8, i8* %ch - %20 = icmp eq i8 %19, 35 - br i1 %20, label %cond.true5, label %cond.false6 +if_block1: ; preds = %if_then + %17 = load i8, i8* %ch + %18 = icmp eq i8 %17, 35 + br i1 %18, label %cond.true4, label %cond.false5 -if_then3: ; preds = %cond.end7 - %21 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %21) - %22 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @advanceIf(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %22, %"$lambdaEnclosureData"* %tmp.this9) - br label %if_block10 +if_then2: ; preds = %cond.end6 + %19 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %19) + %20 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advanceIf(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %20, %"$lambdaEnclosureData"* %tmp.this) + br label %if_block8 -if_end4: ; preds = %if_end12, %cond.end7 +if_end3: ; preds = %if_end10, %cond.end6 br label %if_end -cond.true5: ; preds = %if_block2 - %23 = load i8, i8* %ch2 - %24 = icmp eq i8 %23, 33 - br label %cond.end7 - -cond.false6: ; preds = %if_block2 - br label %cond.end7 - -cond.end7: ; preds = %cond.false6, %cond.true5 - %cond.res8 = phi i1 [ %24, %cond.true5 ], [ false, %cond.false6 ] - br i1 %cond.res8, label %if_then3, label %if_end4 - -if_block10: ; preds = %if_then3 - %25 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %26 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %25) - br i1 %26, label %if_then11, label %if_end12 +cond.true4: ; preds = %if_block1 + %21 = load i8, i8* %ch2 + %22 = icmp eq i8 %21, 33 + br label %cond.end6 -if_then11: ; preds = %if_block10 - %27 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %27) - br label %if_end12 +cond.false5: ; preds = %if_block1 + br label %cond.end6 -if_end12: ; preds = %if_then11, %if_block10 - br label %if_end4 +cond.end6: ; preds = %cond.false5, %cond.true4 + %cond.res7 = phi i1 [ %22, %cond.true4 ], [ false, %cond.false5 ] + br i1 %cond.res7, label %if_then2, label %if_end3 -cond_destruct_alt1: ; preds = %if_end - br label %cond_destruct_end +if_block8: ; preds = %if_then2 + %23 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %24 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %23) + br i1 %24, label %if_then9, label %if_end10 -cond_destruct_alt2: ; preds = %if_end - br label %cond_destruct_end +if_then9: ; preds = %if_block8 + %25 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %25) + br label %if_end10 -cond_destruct_end: ; preds = %cond_destruct_alt2, %cond_destruct_alt1 - br label %while_block +if_end10: ; preds = %if_then9, %if_block8 + br label %if_end3 -while_block: ; preds = %while_step, %cond_destruct_end +while_block: ; preds = %while_step, %if_end br i1 true, label %while_body, label %while_end while_body: ; preds = %while_block - %28 = load %Location*, %Location** %loc - call void @stepOver(%Location* %28) - %29 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %30 = getelementptr inbounds %Token, %Token* %29, i32 0, i32 2 - call void @clear(%String* %30) - br label %if_block13 + %26 = load %Location*, %Location** %loc + call void @stepOver(%Location* %26) + %27 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %28 = getelementptr inbounds %Token, %Token* %27, i32 0, i32 2 + call void @clear(%String* %28) + br label %if_block11 -while_step: ; preds = %dumy_block207, %if_end94, %if_end81, %if_end50, %if_end33, %if_end24 +while_step: ; preds = %dumy_block203, %if_end90, %if_end78, %if_end48, %if_end31, %if_end22 br label %while_block while_end: ; preds = %while_block ret void -if_block13: ; preds = %while_body - %31 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %32 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %31) - br i1 %32, label %if_then14, label %if_end15 +if_block11: ; preds = %while_body + %29 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %30 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %29) + br i1 %30, label %if_then12, label %if_end13 -if_then14: ; preds = %if_block13 - call void @ctor.404(%TokenType* %_result, i32 0) +if_then12: ; preds = %if_block11 + call void @ctor.393(%TokenType* %_result, i32 0) ret void -if_end15: ; preds = %dumy_block, %if_block13 - %33 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %34 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %33) - store i8 %34, i8* %ch16 - %35 = call i8 @peekChar(%SparrowScanner* %this) - store i8 %35, i8* %ch217 - br label %if_block18 +if_end13: ; preds = %dumy_block, %if_block11 + %31 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %32 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %31) + store i8 %32, i8* %ch14 + %33 = call i8 @peekChar(%SparrowScanner* %this) + store i8 %33, i8* %ch215 + br label %if_block16 dumy_block: ; No predecessors! - br label %if_end15 + br label %if_end13 -if_block18: ; preds = %if_end15 - %36 = load i8, i8* %ch16 - %37 = icmp eq i8 %36, 32 - br i1 %37, label %if_then19, label %if_end20 +if_block16: ; preds = %if_end13 + %34 = load i8, i8* %ch14 + %35 = icmp eq i8 %34, 32 + br i1 %35, label %if_then17, label %if_end18 -if_then19: ; preds = %if_block18 - %38 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @advanceIf.430(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %38, %"$lambdaEnclosureData.0"* %tmp.this21) - br label %if_block22 +if_then17: ; preds = %if_block16 + %36 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advanceIf.419(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %36, %"$lambdaEnclosureData.0"* %tmp.this19) + br label %if_block20 -if_end20: ; preds = %dumy_block26, %if_block18 - br label %if_block27 +if_end18: ; preds = %dumy_block24, %if_block16 + br label %if_block25 -if_block22: ; preds = %if_then19 - %39 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 - %40 = load i1, i1* %39 - br i1 %40, label %if_then23, label %if_end24 +if_block20: ; preds = %if_then17 + %37 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 + %38 = load i1, i1* %37 + br i1 %38, label %if_then21, label %if_end22 -if_then23: ; preds = %if_block22 - call void @ctor.404(%TokenType* %_result, i32 255) +if_then21: ; preds = %if_block20 + call void @ctor.393(%TokenType* %_result, i32 255) ret void -if_end24: ; preds = %dumy_block25, %if_block22 +if_end22: ; preds = %dumy_block23, %if_block20 br label %while_step -dumy_block25: ; No predecessors! - br label %if_end24 +dumy_block23: ; No predecessors! + br label %if_end22 -dumy_block26: ; No predecessors! - br label %if_end20 +dumy_block24: ; No predecessors! + br label %if_end18 -if_block27: ; preds = %if_end20 - %41 = load i8, i8* %ch16 - %42 = icmp eq i8 %41, 9 - br i1 %42, label %if_then28, label %if_end29 +if_block25: ; preds = %if_end18 + %39 = load i8, i8* %ch14 + %40 = icmp eq i8 %39, 9 + br i1 %40, label %if_then26, label %if_end27 -if_then28: ; preds = %if_block27 - %43 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 - %44 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 - %45 = bitcast %UntypedPtr* %43 to i8** - %46 = bitcast %UntypedPtr* %44 to i8** - store i8* getelementptr inbounds ([30 x i8], [30 x i8]* @str.8, i32 0, i32 0), i8** %45 - store i8* getelementptr inbounds ([30 x i8], [30 x i8]* @str.8, i32 0, i32 29), i8** %46 - %47 = load %StringRef, %StringRef* %tmp.StringRef - store %StringRef %47, %StringRef* %"$tmpForRef" +if_then26: ; preds = %if_block25 + %41 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 + %42 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %43 = bitcast %UntypedPtr* %41 to i8** + %44 = bitcast %UntypedPtr* %42 to i8** + store i8* getelementptr inbounds ([30 x i8], [30 x i8]* @str.8, i32 0, i32 0), i8** %43 + store i8* getelementptr inbounds ([30 x i8], [30 x i8]* @str.8, i32 0, i32 29), i8** %44 + %45 = load %StringRef, %StringRef* %tmp.StringRef + store %StringRef %45, %StringRef* %"$tmpForRef" call void @toString(%String* %"$tmpC", %StringRef* %"$tmpForRef") call void @reportError(%SparrowScanner* %this, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - %48 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @advanceIf.443(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %48, %"$lambdaEnclosureData.1"* %tmp.this30) - br label %if_block31 + call void @dtor.239(%String* %"$tmpC") + %46 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advanceIf.432(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %46, %"$lambdaEnclosureData.1"* %tmp.this28) + br label %if_block29 -if_end29: ; preds = %dumy_block35, %if_block27 - br label %if_block36 +if_end27: ; preds = %dumy_block33, %if_block25 + br label %if_block34 -if_block31: ; preds = %if_then28 - %49 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 - %50 = load i1, i1* %49 - br i1 %50, label %if_then32, label %if_end33 +if_block29: ; preds = %if_then26 + %47 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 + %48 = load i1, i1* %47 + br i1 %48, label %if_then30, label %if_end31 -if_then32: ; preds = %if_block31 - call void @ctor.404(%TokenType* %_result, i32 255) +if_then30: ; preds = %if_block29 + call void @ctor.393(%TokenType* %_result, i32 255) ret void -if_end33: ; preds = %dumy_block34, %if_block31 +if_end31: ; preds = %dumy_block32, %if_block29 br label %while_step -dumy_block34: ; No predecessors! - br label %if_end33 +dumy_block32: ; No predecessors! + br label %if_end31 -dumy_block35: ; No predecessors! - br label %if_end29 +dumy_block33: ; No predecessors! + br label %if_end27 -if_block36: ; preds = %if_end29 - %51 = load i8, i8* %ch16 - %52 = icmp eq i8 %51, 10 - br i1 %52, label %if_then37, label %if_end38 +if_block34: ; preds = %if_end27 + %49 = load i8, i8* %ch14 + %50 = icmp eq i8 %49, 10 + br i1 %50, label %if_then35, label %if_end36 -if_then37: ; preds = %if_block36 - %53 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %53) - call void @ctor.404(%TokenType* %_result, i32 1) +if_then35: ; preds = %if_block34 + %51 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %51) + call void @ctor.393(%TokenType* %_result, i32 1) ret void -if_end38: ; preds = %dumy_block39, %if_block36 - br label %if_block40 +if_end36: ; preds = %dumy_block37, %if_block34 + br label %if_block38 -dumy_block39: ; No predecessors! - br label %if_end38 +dumy_block37: ; No predecessors! + br label %if_end36 -if_block40: ; preds = %if_end38 - %54 = load i8, i8* %ch16 - %55 = icmp eq i8 %54, 47 - br i1 %55, label %cond.true43, label %cond.false44 +if_block38: ; preds = %if_end36 + %52 = load i8, i8* %ch14 + %53 = icmp eq i8 %52, 47 + br i1 %53, label %cond.true41, label %cond.false42 -if_then41: ; preds = %cond.end45 - %56 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %56) - %57 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @advanceIf.450(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %57, %"$lambdaEnclosureData.2"* %tmp.this47) - br label %if_block48 +if_then39: ; preds = %cond.end43 + %54 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %54) + %55 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advanceIf.439(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %55, %"$lambdaEnclosureData.2"* %tmp.this45) + br label %if_block46 -if_end42: ; preds = %dumy_block52, %cond.end45 - br label %if_block53 +if_end40: ; preds = %dumy_block50, %cond.end43 + br label %if_block51 -cond.true43: ; preds = %if_block40 - %58 = load i8, i8* %ch217 - %59 = icmp eq i8 %58, 47 - br label %cond.end45 +cond.true41: ; preds = %if_block38 + %56 = load i8, i8* %ch215 + %57 = icmp eq i8 %56, 47 + br label %cond.end43 -cond.false44: ; preds = %if_block40 - br label %cond.end45 +cond.false42: ; preds = %if_block38 + br label %cond.end43 -cond.end45: ; preds = %cond.false44, %cond.true43 - %cond.res46 = phi i1 [ %59, %cond.true43 ], [ false, %cond.false44 ] - br i1 %cond.res46, label %if_then41, label %if_end42 +cond.end43: ; preds = %cond.false42, %cond.true41 + %cond.res44 = phi i1 [ %57, %cond.true41 ], [ false, %cond.false42 ] + br i1 %cond.res44, label %if_then39, label %if_end40 -if_block48: ; preds = %if_then41 - %60 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 - %61 = load i1, i1* %60 - br i1 %61, label %if_then49, label %if_end50 +if_block46: ; preds = %if_then39 + %58 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 + %59 = load i1, i1* %58 + br i1 %59, label %if_then47, label %if_end48 -if_then49: ; preds = %if_block48 - call void @ctor.404(%TokenType* %_result, i32 254) +if_then47: ; preds = %if_block46 + call void @ctor.393(%TokenType* %_result, i32 254) ret void -if_end50: ; preds = %dumy_block51, %if_block48 +if_end48: ; preds = %dumy_block49, %if_block46 br label %while_step -dumy_block51: ; No predecessors! - br label %if_end50 +dumy_block49: ; No predecessors! + br label %if_end48 -dumy_block52: ; No predecessors! - br label %if_end42 +dumy_block50: ; No predecessors! + br label %if_end40 -if_block53: ; preds = %if_end42 - %62 = load i8, i8* %ch16 - %63 = icmp eq i8 %62, 47 - br i1 %63, label %cond.true56, label %cond.false57 +if_block51: ; preds = %if_end40 + %60 = load i8, i8* %ch14 + %61 = icmp eq i8 %60, 47 + br i1 %61, label %cond.true54, label %cond.false55 -if_then54: ; preds = %cond.end58 - %64 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 2, i64* %tmp.this60 - %65 = load i64, i64* %tmp.this60 - call void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %64, i64 %65) +if_then52: ; preds = %cond.end56 + %62 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %62, i32 2) store i8 97, i8* %c1 store i8 97, i8* %c2 - br label %while_block61 - -if_end55: ; preds = %dumy_block83, %cond.end58 - br label %if_block84 - -cond.true56: ; preds = %if_block53 - %66 = load i8, i8* %ch217 - %67 = icmp eq i8 %66, 42 - br label %cond.end58 + br label %while_block58 -cond.false57: ; preds = %if_block53 - br label %cond.end58 +if_end53: ; preds = %dumy_block80, %cond.end56 + br label %if_block81 -cond.end58: ; preds = %cond.false57, %cond.true56 - %cond.res59 = phi i1 [ %67, %cond.true56 ], [ false, %cond.false57 ] - br i1 %cond.res59, label %if_then54, label %if_end55 +cond.true54: ; preds = %if_block51 + %63 = load i8, i8* %ch215 + %64 = icmp eq i8 %63, 42 + br label %cond.end56 -while_block61: ; preds = %while_step63, %if_then54 - %68 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %69 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %68) - br i1 %69, label %cond.true65, label %cond.false66 +cond.false55: ; preds = %if_block51 + br label %cond.end56 -while_body62: ; preds = %cond.end67 - %70 = load i8, i8* %c2 - store i8 %70, i8* %c1 - %71 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %72 = call i8 @"pre_++.458"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %71) - store i8 %72, i8* %c2 - br label %while_step63 +cond.end56: ; preds = %cond.false55, %cond.true54 + %cond.res57 = phi i1 [ %64, %cond.true54 ], [ false, %cond.false55 ] + br i1 %cond.res57, label %if_then52, label %if_end53 -while_step63: ; preds = %while_body62 - br label %while_block61 +while_block58: ; preds = %while_step60, %if_then52 + %65 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %66 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %65) + br i1 %66, label %cond.true62, label %cond.false63 -while_end64: ; preds = %cond.end67 - br label %if_block73 +while_body59: ; preds = %cond.end64 + %67 = load i8, i8* %c2 + store i8 %67, i8* %c1 + %68 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %69 = call i8 @"pre_++.447"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %68) + store i8 %69, i8* %c2 + br label %while_step60 -cond.true65: ; preds = %while_block61 - %73 = load i8, i8* %c1 - %74 = icmp ne i8 %73, 42 - br i1 %74, label %cond.true68, label %cond.false69 +while_step60: ; preds = %while_body59 + br label %while_block58 -cond.false66: ; preds = %while_block61 - br label %cond.end67 +while_end61: ; preds = %cond.end64 + br label %if_block70 -cond.end67: ; preds = %cond.false66, %cond.end70 - %cond.res72 = phi i1 [ %cond.res71, %cond.end70 ], [ false, %cond.false66 ] - br i1 %cond.res72, label %while_body62, label %while_end64 +cond.true62: ; preds = %while_block58 + %70 = load i8, i8* %c1 + %71 = icmp ne i8 %70, 42 + br i1 %71, label %cond.true65, label %cond.false66 -cond.true68: ; preds = %cond.true65 - br label %cond.end70 +cond.false63: ; preds = %while_block58 + br label %cond.end64 -cond.false69: ; preds = %cond.true65 - %75 = load i8, i8* %c2 - %76 = icmp ne i8 %75, 47 - br label %cond.end70 +cond.end64: ; preds = %cond.false63, %cond.end67 + %cond.res69 = phi i1 [ %cond.res68, %cond.end67 ], [ false, %cond.false63 ] + br i1 %cond.res69, label %while_body59, label %while_end61 -cond.end70: ; preds = %cond.false69, %cond.true68 - %cond.res71 = phi i1 [ true, %cond.true68 ], [ %76, %cond.false69 ] +cond.true65: ; preds = %cond.true62 br label %cond.end67 -if_block73: ; preds = %while_end64 - %77 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %78 = call i1 @"pre_!"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %77) - br i1 %78, label %if_then74, label %if_end75 +cond.false66: ; preds = %cond.true62 + %72 = load i8, i8* %c2 + %73 = icmp ne i8 %72, 47 + br label %cond.end67 -if_then74: ; preds = %if_block73 - %79 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef77, i32 0, i32 0 - %80 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef77, i32 0, i32 1 - %81 = bitcast %UntypedPtr* %79 to i8** - %82 = bitcast %UntypedPtr* %80 to i8** - store i8* getelementptr inbounds ([33 x i8], [33 x i8]* @str.9, i32 0, i32 0), i8** %81 - store i8* getelementptr inbounds ([33 x i8], [33 x i8]* @str.9, i32 0, i32 32), i8** %82 - %83 = load %StringRef, %StringRef* %tmp.StringRef77 - call void @ctor.459(%String* %tmp.this76, %StringRef %83) - call void @reportError(%SparrowScanner* %this, %String* %tmp.this76) - call void @dtor.250(%String* %tmp.this76) - call void @ctor.404(%TokenType* %_result, i32 0) - ret void +cond.end67: ; preds = %cond.false66, %cond.true65 + %cond.res68 = phi i1 [ true, %cond.true65 ], [ %73, %cond.false66 ] + br label %cond.end64 -if_end75: ; preds = %dumy_block78, %if_block73 - %84 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %84) - br label %if_block79 +if_block70: ; preds = %while_end61 + %74 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %75 = call i1 @"pre_!"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %74) + br i1 %75, label %if_then71, label %if_end72 + +if_then71: ; preds = %if_block70 + %76 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef74, i32 0, i32 0 + %77 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef74, i32 0, i32 1 + %78 = bitcast %UntypedPtr* %76 to i8** + %79 = bitcast %UntypedPtr* %77 to i8** + store i8* getelementptr inbounds ([33 x i8], [33 x i8]* @str.9, i32 0, i32 0), i8** %78 + store i8* getelementptr inbounds ([33 x i8], [33 x i8]* @str.9, i32 0, i32 32), i8** %79 + %80 = load %StringRef, %StringRef* %tmp.StringRef74 + call void @ctor.448(%String* %tmp.this73, %StringRef %80) + call void @reportError(%SparrowScanner* %this, %String* %tmp.this73) + call void @dtor.239(%String* %tmp.this73) + call void @ctor.393(%TokenType* %_result, i32 0) + ret void + +if_end72: ; preds = %dumy_block75, %if_block70 + %81 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %81) + br label %if_block76 -dumy_block78: ; No predecessors! - br label %if_end75 +dumy_block75: ; No predecessors! + br label %if_end72 -if_block79: ; preds = %if_end75 - %85 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 - %86 = load i1, i1* %85 - br i1 %86, label %if_then80, label %if_end81 +if_block76: ; preds = %if_end72 + %82 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 + %83 = load i1, i1* %82 + br i1 %83, label %if_then77, label %if_end78 -if_then80: ; preds = %if_block79 - call void @ctor.404(%TokenType* %_result, i32 254) +if_then77: ; preds = %if_block76 + call void @ctor.393(%TokenType* %_result, i32 254) ret void -if_end81: ; preds = %dumy_block82, %if_block79 +if_end78: ; preds = %dumy_block79, %if_block76 br label %while_step -dumy_block82: ; No predecessors! - br label %if_end81 +dumy_block79: ; No predecessors! + br label %if_end78 -dumy_block83: ; No predecessors! - br label %if_end55 +dumy_block80: ; No predecessors! + br label %if_end53 -if_block84: ; preds = %if_end55 - %87 = load i8, i8* %ch16 - %88 = icmp eq i8 %87, 92 - br i1 %88, label %cond.true87, label %cond.false88 +if_block81: ; preds = %if_end53 + %84 = load i8, i8* %ch14 + %85 = icmp eq i8 %84, 92 + br i1 %85, label %cond.true84, label %cond.false85 -if_then85: ; preds = %cond.end89 - %89 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 2, i64* %tmp.this91 - %90 = load i64, i64* %tmp.this91 - call void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %89, i64 %90) - br label %if_block92 +if_then82: ; preds = %cond.end86 + %86 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %86, i32 2) + br label %if_block88 -if_end86: ; preds = %dumy_block96, %cond.end89 - br label %if_block97 +if_end83: ; preds = %dumy_block92, %cond.end86 + br label %if_block93 -cond.true87: ; preds = %if_block84 - %91 = load i8, i8* %ch217 - %92 = icmp eq i8 %91, 10 - br label %cond.end89 +cond.true84: ; preds = %if_block81 + %87 = load i8, i8* %ch215 + %88 = icmp eq i8 %87, 10 + br label %cond.end86 -cond.false88: ; preds = %if_block84 - br label %cond.end89 +cond.false85: ; preds = %if_block81 + br label %cond.end86 -cond.end89: ; preds = %cond.false88, %cond.true87 - %cond.res90 = phi i1 [ %92, %cond.true87 ], [ false, %cond.false88 ] - br i1 %cond.res90, label %if_then85, label %if_end86 +cond.end86: ; preds = %cond.false85, %cond.true84 + %cond.res87 = phi i1 [ %88, %cond.true84 ], [ false, %cond.false85 ] + br i1 %cond.res87, label %if_then82, label %if_end83 -if_block92: ; preds = %if_then85 - %93 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 - %94 = load i1, i1* %93 - br i1 %94, label %if_then93, label %if_end94 +if_block88: ; preds = %if_then82 + %89 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 6 + %90 = load i1, i1* %89 + br i1 %90, label %if_then89, label %if_end90 -if_then93: ; preds = %if_block92 - call void @ctor.404(%TokenType* %_result, i32 253) +if_then89: ; preds = %if_block88 + call void @ctor.393(%TokenType* %_result, i32 253) ret void -if_end94: ; preds = %dumy_block95, %if_block92 +if_end90: ; preds = %dumy_block91, %if_block88 br label %while_step -dumy_block95: ; No predecessors! - br label %if_end94 +dumy_block91: ; No predecessors! + br label %if_end90 + +dumy_block92: ; No predecessors! + br label %if_end83 + +if_block93: ; preds = %if_end83 + %91 = load i8, i8* %ch14 + %92 = icmp eq i8 %91, 39 + br i1 %92, label %if_then94, label %if_end95 + +if_then94: ; preds = %if_block93 + call void @parseString(%TokenType* %_result, %SparrowScanner* %this, i8 39) + ret void + +if_end95: ; preds = %dumy_block96, %if_block93 + br label %if_block97 dumy_block96: ; No predecessors! - br label %if_end86 + br label %if_end95 -if_block97: ; preds = %if_end86 - %95 = load i8, i8* %ch16 - %96 = icmp eq i8 %95, 39 - br i1 %96, label %if_then98, label %if_end99 +if_block97: ; preds = %if_end95 + %93 = load i8, i8* %ch14 + %94 = icmp eq i8 %93, 34 + br i1 %94, label %if_then98, label %if_end99 if_then98: ; preds = %if_block97 - call void @parseString(%TokenType* %_result, %SparrowScanner* %this, i8 39) + call void @parseString(%TokenType* %_result, %SparrowScanner* %this, i8 34) ret void if_end99: ; preds = %dumy_block100, %if_block97 @@ -12473,56 +12113,58 @@ dumy_block100: ; No predecessors! br label %if_end99 if_block101: ; preds = %if_end99 - %97 = load i8, i8* %ch16 - %98 = icmp eq i8 %97, 34 - br i1 %98, label %if_then102, label %if_end103 + %95 = load i8, i8* %ch14 + %96 = icmp eq i8 %95, 60 + br i1 %96, label %cond.true104, label %cond.false105 -if_then102: ; preds = %if_block101 - call void @parseString(%TokenType* %_result, %SparrowScanner* %this, i8 34) +if_then102: ; preds = %cond.end106 + call void @parseStringNE(%TokenType* %_result, %SparrowScanner* %this) ret void -if_end103: ; preds = %dumy_block104, %if_block101 - br label %if_block105 +if_end103: ; preds = %dumy_block108, %cond.end106 + br label %if_block109 -dumy_block104: ; No predecessors! - br label %if_end103 +cond.true104: ; preds = %if_block101 + %97 = load i8, i8* %ch215 + %98 = icmp eq i8 %97, 123 + br label %cond.end106 -if_block105: ; preds = %if_end103 - %99 = load i8, i8* %ch16 - %100 = icmp eq i8 %99, 60 - br i1 %100, label %cond.true108, label %cond.false109 +cond.false105: ; preds = %if_block101 + br label %cond.end106 -if_then106: ; preds = %cond.end110 - call void @parseStringNE(%TokenType* %_result, %SparrowScanner* %this) - ret void +cond.end106: ; preds = %cond.false105, %cond.true104 + %cond.res107 = phi i1 [ %98, %cond.true104 ], [ false, %cond.false105 ] + br i1 %cond.res107, label %if_then102, label %if_end103 -if_end107: ; preds = %dumy_block112, %cond.end110 - br label %if_block113 +dumy_block108: ; No predecessors! + br label %if_end103 -cond.true108: ; preds = %if_block105 - %101 = load i8, i8* %ch217 - %102 = icmp eq i8 %101, 123 - br label %cond.end110 +if_block109: ; preds = %if_end103 + %99 = load i8, i8* %ch14 + %100 = icmp eq i8 %99, 123 + br i1 %100, label %if_then110, label %if_end111 -cond.false109: ; preds = %if_block105 - br label %cond.end110 +if_then110: ; preds = %if_block109 + %101 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %101) + call void @ctor.393(%TokenType* %_result, i32 25) + ret void -cond.end110: ; preds = %cond.false109, %cond.true108 - %cond.res111 = phi i1 [ %102, %cond.true108 ], [ false, %cond.false109 ] - br i1 %cond.res111, label %if_then106, label %if_end107 +if_end111: ; preds = %dumy_block112, %if_block109 + br label %if_block113 dumy_block112: ; No predecessors! - br label %if_end107 + br label %if_end111 -if_block113: ; preds = %if_end107 - %103 = load i8, i8* %ch16 - %104 = icmp eq i8 %103, 123 - br i1 %104, label %if_then114, label %if_end115 +if_block113: ; preds = %if_end111 + %102 = load i8, i8* %ch14 + %103 = icmp eq i8 %102, 123 + br i1 %103, label %if_then114, label %if_end115 if_then114: ; preds = %if_block113 - %105 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %105) - call void @ctor.404(%TokenType* %_result, i32 25) + %104 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %104) + call void @ctor.393(%TokenType* %_result, i32 25) ret void if_end115: ; preds = %dumy_block116, %if_block113 @@ -12532,14 +12174,14 @@ dumy_block116: ; No predecessors! br label %if_end115 if_block117: ; preds = %if_end115 - %106 = load i8, i8* %ch16 - %107 = icmp eq i8 %106, 123 - br i1 %107, label %if_then118, label %if_end119 + %105 = load i8, i8* %ch14 + %106 = icmp eq i8 %105, 125 + br i1 %106, label %if_then118, label %if_end119 if_then118: ; preds = %if_block117 - %108 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %108) - call void @ctor.404(%TokenType* %_result, i32 25) + %107 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %107) + call void @ctor.393(%TokenType* %_result, i32 26) ret void if_end119: ; preds = %dumy_block120, %if_block117 @@ -12549,14 +12191,14 @@ dumy_block120: ; No predecessors! br label %if_end119 if_block121: ; preds = %if_end119 - %109 = load i8, i8* %ch16 - %110 = icmp eq i8 %109, 125 - br i1 %110, label %if_then122, label %if_end123 + %108 = load i8, i8* %ch14 + %109 = icmp eq i8 %108, 91 + br i1 %109, label %if_then122, label %if_end123 if_then122: ; preds = %if_block121 - %111 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %111) - call void @ctor.404(%TokenType* %_result, i32 26) + %110 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %110) + call void @ctor.393(%TokenType* %_result, i32 27) ret void if_end123: ; preds = %dumy_block124, %if_block121 @@ -12566,14 +12208,14 @@ dumy_block124: ; No predecessors! br label %if_end123 if_block125: ; preds = %if_end123 - %112 = load i8, i8* %ch16 - %113 = icmp eq i8 %112, 91 - br i1 %113, label %if_then126, label %if_end127 + %111 = load i8, i8* %ch14 + %112 = icmp eq i8 %111, 93 + br i1 %112, label %if_then126, label %if_end127 if_then126: ; preds = %if_block125 - %114 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %114) - call void @ctor.404(%TokenType* %_result, i32 27) + %113 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %113) + call void @ctor.393(%TokenType* %_result, i32 28) ret void if_end127: ; preds = %dumy_block128, %if_block125 @@ -12583,14 +12225,14 @@ dumy_block128: ; No predecessors! br label %if_end127 if_block129: ; preds = %if_end127 - %115 = load i8, i8* %ch16 - %116 = icmp eq i8 %115, 93 - br i1 %116, label %if_then130, label %if_end131 + %114 = load i8, i8* %ch14 + %115 = icmp eq i8 %114, 40 + br i1 %115, label %if_then130, label %if_end131 if_then130: ; preds = %if_block129 - %117 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %117) - call void @ctor.404(%TokenType* %_result, i32 28) + %116 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %116) + call void @ctor.393(%TokenType* %_result, i32 29) ret void if_end131: ; preds = %dumy_block132, %if_block129 @@ -12600,14 +12242,14 @@ dumy_block132: ; No predecessors! br label %if_end131 if_block133: ; preds = %if_end131 - %118 = load i8, i8* %ch16 - %119 = icmp eq i8 %118, 40 - br i1 %119, label %if_then134, label %if_end135 + %117 = load i8, i8* %ch14 + %118 = icmp eq i8 %117, 41 + br i1 %118, label %if_then134, label %if_end135 if_then134: ; preds = %if_block133 - %120 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %120) - call void @ctor.404(%TokenType* %_result, i32 29) + %119 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %119) + call void @ctor.393(%TokenType* %_result, i32 30) ret void if_end135: ; preds = %dumy_block136, %if_block133 @@ -12617,14 +12259,14 @@ dumy_block136: ; No predecessors! br label %if_end135 if_block137: ; preds = %if_end135 - %121 = load i8, i8* %ch16 - %122 = icmp eq i8 %121, 41 - br i1 %122, label %if_then138, label %if_end139 + %120 = load i8, i8* %ch14 + %121 = icmp eq i8 %120, 59 + br i1 %121, label %if_then138, label %if_end139 if_then138: ; preds = %if_block137 - %123 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %123) - call void @ctor.404(%TokenType* %_result, i32 30) + %122 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %122) + call void @ctor.393(%TokenType* %_result, i32 32) ret void if_end139: ; preds = %dumy_block140, %if_block137 @@ -12634,14 +12276,14 @@ dumy_block140: ; No predecessors! br label %if_end139 if_block141: ; preds = %if_end139 - %124 = load i8, i8* %ch16 - %125 = icmp eq i8 %124, 59 - br i1 %125, label %if_then142, label %if_end143 + %123 = load i8, i8* %ch14 + %124 = icmp eq i8 %123, 44 + br i1 %124, label %if_then142, label %if_end143 if_then142: ; preds = %if_block141 - %126 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %126) - call void @ctor.404(%TokenType* %_result, i32 32) + %125 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %125) + call void @ctor.393(%TokenType* %_result, i32 33) ret void if_end143: ; preds = %dumy_block144, %if_block141 @@ -12651,14 +12293,14 @@ dumy_block144: ; No predecessors! br label %if_end143 if_block145: ; preds = %if_end143 - %127 = load i8, i8* %ch16 - %128 = icmp eq i8 %127, 44 - br i1 %128, label %if_then146, label %if_end147 + %126 = load i8, i8* %ch14 + %127 = icmp eq i8 %126, 96 + br i1 %127, label %if_then146, label %if_end147 if_then146: ; preds = %if_block145 - %129 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %129) - call void @ctor.404(%TokenType* %_result, i32 33) + %128 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %128) + call void @ctor.393(%TokenType* %_result, i32 35) ret void if_end147: ; preds = %dumy_block148, %if_block145 @@ -12668,217 +12310,200 @@ dumy_block148: ; No predecessors! br label %if_end147 if_block149: ; preds = %if_end147 - %130 = load i8, i8* %ch16 - %131 = icmp eq i8 %130, 96 - br i1 %131, label %if_then150, label %if_end151 - -if_then150: ; preds = %if_block149 - %132 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %132) - call void @ctor.404(%TokenType* %_result, i32 35) - ret void - -if_end151: ; preds = %dumy_block152, %if_block149 - br label %if_block153 - -dumy_block152: ; No predecessors! - br label %if_end151 - -if_block153: ; preds = %if_end151 - %133 = load i8, i8* %ch16 - %134 = icmp eq i8 %133, 58 - br i1 %134, label %cond.true156, label %cond.false157 + %129 = load i8, i8* %ch14 + %130 = icmp eq i8 %129, 58 + br i1 %130, label %cond.true152, label %cond.false153 -if_then154: ; preds = %cond.end158 - %135 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %135) - call void @ctor.404(%TokenType* %_result, i32 31) +if_then150: ; preds = %cond.end154 + %131 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %131) + call void @ctor.393(%TokenType* %_result, i32 31) ret void -if_end155: ; preds = %dumy_block160, %cond.end158 - br label %if_block161 +if_end151: ; preds = %dumy_block156, %cond.end154 + br label %if_block157 -cond.true156: ; preds = %if_block153 - %136 = call i8 @peekChar(%SparrowScanner* %this) - %137 = call i1 @isOpChar(i8 %136) - %138 = xor i1 true, %137 - br label %cond.end158 +cond.true152: ; preds = %if_block149 + %132 = call i8 @peekChar(%SparrowScanner* %this) + %133 = call i1 @isOpChar(i8 %132) + %134 = xor i1 true, %133 + br label %cond.end154 -cond.false157: ; preds = %if_block153 - br label %cond.end158 +cond.false153: ; preds = %if_block149 + br label %cond.end154 -cond.end158: ; preds = %cond.false157, %cond.true156 - %cond.res159 = phi i1 [ %138, %cond.true156 ], [ false, %cond.false157 ] - br i1 %cond.res159, label %if_then154, label %if_end155 +cond.end154: ; preds = %cond.false153, %cond.true152 + %cond.res155 = phi i1 [ %134, %cond.true152 ], [ false, %cond.false153 ] + br i1 %cond.res155, label %if_then150, label %if_end151 -dumy_block160: ; No predecessors! - br label %if_end155 +dumy_block156: ; No predecessors! + br label %if_end151 -if_block161: ; preds = %if_end155 - %139 = load i8, i8* %ch16 - %140 = icmp eq i8 %139, 61 - br i1 %140, label %cond.true164, label %cond.false165 +if_block157: ; preds = %if_end151 + %135 = load i8, i8* %ch14 + %136 = icmp eq i8 %135, 61 + br i1 %136, label %cond.true160, label %cond.false161 -if_then162: ; preds = %cond.end166 - %141 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %141) - call void @ctor.404(%TokenType* %_result, i32 36) +if_then158: ; preds = %cond.end162 + %137 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %137) + call void @ctor.393(%TokenType* %_result, i32 36) ret void -if_end163: ; preds = %dumy_block168, %cond.end166 - br label %if_block169 +if_end159: ; preds = %dumy_block164, %cond.end162 + br label %if_block165 -cond.true164: ; preds = %if_block161 - %142 = call i8 @peekChar(%SparrowScanner* %this) - %143 = call i1 @isOpChar(i8 %142) - %144 = xor i1 true, %143 - br label %cond.end166 +cond.true160: ; preds = %if_block157 + %138 = call i8 @peekChar(%SparrowScanner* %this) + %139 = call i1 @isOpChar(i8 %138) + %140 = xor i1 true, %139 + br label %cond.end162 -cond.false165: ; preds = %if_block161 - br label %cond.end166 +cond.false161: ; preds = %if_block157 + br label %cond.end162 -cond.end166: ; preds = %cond.false165, %cond.true164 - %cond.res167 = phi i1 [ %144, %cond.true164 ], [ false, %cond.false165 ] - br i1 %cond.res167, label %if_then162, label %if_end163 +cond.end162: ; preds = %cond.false161, %cond.true160 + %cond.res163 = phi i1 [ %140, %cond.true160 ], [ false, %cond.false161 ] + br i1 %cond.res163, label %if_then158, label %if_end159 -dumy_block168: ; No predecessors! - br label %if_end163 +dumy_block164: ; No predecessors! + br label %if_end159 -if_block169: ; preds = %if_end163 - %145 = load i8, i8* %ch16 - %146 = call i1 @isOpCharDot(i8 %145) - br i1 %146, label %if_then170, label %if_end171 +if_block165: ; preds = %if_end159 + %141 = load i8, i8* %ch14 + %142 = call i1 @isOpCharDot(i8 %141) + br i1 %142, label %if_then166, label %if_end167 -if_then170: ; preds = %if_block169 - br label %if_block172 +if_then166: ; preds = %if_block165 + br label %if_block168 -if_end171: ; preds = %if_end174, %if_block169 - br label %if_block176 +if_end167: ; preds = %if_end170, %if_block165 + br label %if_block172 -if_block172: ; preds = %if_then170 - %147 = call i1 @parseOperator(%SparrowScanner* %this) - br i1 %147, label %if_then173, label %if_end174 +if_block168: ; preds = %if_then166 + %143 = call i1 @parseOperator(%SparrowScanner* %this) + br i1 %143, label %if_then169, label %if_end170 -if_then173: ; preds = %if_block172 - call void @ctor.404(%TokenType* %_result, i32 38) +if_then169: ; preds = %if_block168 + call void @ctor.393(%TokenType* %_result, i32 38) ret void -if_end174: ; preds = %dumy_block175, %if_block172 - br label %if_end171 +if_end170: ; preds = %dumy_block171, %if_block168 + br label %if_end167 -dumy_block175: ; No predecessors! - br label %if_end174 +dumy_block171: ; No predecessors! + br label %if_end170 -if_block176: ; preds = %if_end171 - %148 = load i8, i8* %ch16 - %149 = icmp eq i8 %148, 46 - br i1 %149, label %cond.true179, label %cond.false180 +if_block172: ; preds = %if_end167 + %144 = load i8, i8* %ch14 + %145 = icmp eq i8 %144, 46 + br i1 %145, label %cond.true175, label %cond.false176 -if_then177: ; preds = %cond.end181 - %150 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %150) - call void @ctor.404(%TokenType* %_result, i32 34) +if_then173: ; preds = %cond.end177 + %146 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %146) + call void @ctor.393(%TokenType* %_result, i32 34) ret void -if_end178: ; preds = %dumy_block183, %cond.end181 - br label %if_block184 +if_end174: ; preds = %dumy_block179, %cond.end177 + br label %if_block180 -cond.true179: ; preds = %if_block176 - %151 = load i8, i8* %ch217 - %152 = call i1 @isDigit(i8 %151) - %153 = xor i1 true, %152 - br label %cond.end181 +cond.true175: ; preds = %if_block172 + %147 = load i8, i8* %ch215 + %148 = call i1 @isDigit(i8 %147) + %149 = xor i1 true, %148 + br label %cond.end177 -cond.false180: ; preds = %if_block176 - br label %cond.end181 +cond.false176: ; preds = %if_block172 + br label %cond.end177 -cond.end181: ; preds = %cond.false180, %cond.true179 - %cond.res182 = phi i1 [ %153, %cond.true179 ], [ false, %cond.false180 ] - br i1 %cond.res182, label %if_then177, label %if_end178 +cond.end177: ; preds = %cond.false176, %cond.true175 + %cond.res178 = phi i1 [ %149, %cond.true175 ], [ false, %cond.false176 ] + br i1 %cond.res178, label %if_then173, label %if_end174 -dumy_block183: ; No predecessors! - br label %if_end178 +dumy_block179: ; No predecessors! + br label %if_end174 -if_block184: ; preds = %if_end178 - %154 = load i8, i8* %ch16 - %155 = call i1 @isAlpha(i8 %154) - br i1 %155, label %cond.true187, label %cond.false188 +if_block180: ; preds = %if_end174 + %150 = load i8, i8* %ch14 + %151 = call i1 @isAlpha(i8 %150) + br i1 %151, label %cond.true183, label %cond.false184 -if_then185: ; preds = %cond.end189 +if_then181: ; preds = %cond.end185 call void @parseIdentifer(%TokenType* %_result, %SparrowScanner* %this) ret void -if_end186: ; preds = %dumy_block191, %cond.end189 - br label %if_block192 +if_end182: ; preds = %dumy_block187, %cond.end185 + br label %if_block188 -cond.true187: ; preds = %if_block184 - br label %cond.end189 +cond.true183: ; preds = %if_block180 + br label %cond.end185 -cond.false188: ; preds = %if_block184 - %156 = load i8, i8* %ch16 - %157 = icmp eq i8 %156, 95 - br label %cond.end189 +cond.false184: ; preds = %if_block180 + %152 = load i8, i8* %ch14 + %153 = icmp eq i8 %152, 95 + br label %cond.end185 -cond.end189: ; preds = %cond.false188, %cond.true187 - %cond.res190 = phi i1 [ true, %cond.true187 ], [ %157, %cond.false188 ] - br i1 %cond.res190, label %if_then185, label %if_end186 +cond.end185: ; preds = %cond.false184, %cond.true183 + %cond.res186 = phi i1 [ true, %cond.true183 ], [ %153, %cond.false184 ] + br i1 %cond.res186, label %if_then181, label %if_end182 -dumy_block191: ; No predecessors! - br label %if_end186 +dumy_block187: ; No predecessors! + br label %if_end182 -if_block192: ; preds = %if_end186 - %158 = load i8, i8* %ch16 - %159 = call i1 @isDigit(i8 %158) - br i1 %159, label %cond.true195, label %cond.false196 +if_block188: ; preds = %if_end182 + %154 = load i8, i8* %ch14 + %155 = call i1 @isDigit(i8 %154) + br i1 %155, label %cond.true191, label %cond.false192 -if_then193: ; preds = %cond.end197 +if_then189: ; preds = %cond.end193 call void @parseNumeric(%TokenType* %_result, %SparrowScanner* %this) ret void -if_end194: ; preds = %dumy_block199, %cond.end197 - %160 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef202, i32 0, i32 0 - %161 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef202, i32 0, i32 1 - %162 = bitcast %UntypedPtr* %160 to i8** +if_end190: ; preds = %dumy_block195, %cond.end193 + %156 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef198, i32 0, i32 0 + %157 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef198, i32 0, i32 1 + %158 = bitcast %UntypedPtr* %156 to i8** + %159 = bitcast %UntypedPtr* %157 to i8** + store i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str.38, i32 0, i32 0), i8** %158 + store i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str.38, i32 0, i32 26), i8** %159 + %160 = load %StringRef, %StringRef* %tmp.StringRef198 + store %StringRef %160, %StringRef* %"$tmpForRef197" + %161 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef200, i32 0, i32 0 + %162 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef200, i32 0, i32 1 %163 = bitcast %UntypedPtr* %161 to i8** - store i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str.38, i32 0, i32 0), i8** %162 - store i8* getelementptr inbounds ([27 x i8], [27 x i8]* @str.38, i32 0, i32 26), i8** %163 - %164 = load %StringRef, %StringRef* %tmp.StringRef202 - store %StringRef %164, %StringRef* %"$tmpForRef201" - %165 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef204, i32 0, i32 0 - %166 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef204, i32 0, i32 1 - %167 = bitcast %UntypedPtr* %165 to i8** - %168 = bitcast %UntypedPtr* %166 to i8** - store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.39, i32 0, i32 0), i8** %167 - store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.39, i32 0, i32 3), i8** %168 - %169 = load %StringRef, %StringRef* %tmp.StringRef204 - store %StringRef %169, %StringRef* %"$tmpForRef203" - %170 = load i8, i8* %ch16 - call void @_ass_32_8z(i32* %tmp.this205, i8 %170) - store i8 41, i8* %"$tmpForRef206" - call void @toString.466(%String* %"$tmpC200", %StringRef* %"$tmpForRef201", i8* %ch16, %StringRef* %"$tmpForRef203", i32* %tmp.this205, i8* %"$tmpForRef206") - call void @reportError(%SparrowScanner* %this, %String* %"$tmpC200") - call void @dtor.250(%String* %"$tmpC200") - %171 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %171) - call void @ctor.404(%TokenType* %_result, i32 0) - ret void - -cond.true195: ; preds = %if_block192 - br label %cond.end197 - -cond.false196: ; preds = %if_block192 - %172 = load i8, i8* %ch16 - %173 = icmp eq i8 %172, 46 - br label %cond.end197 - -cond.end197: ; preds = %cond.false196, %cond.true195 - %cond.res198 = phi i1 [ true, %cond.true195 ], [ %173, %cond.false196 ] - br i1 %cond.res198, label %if_then193, label %if_end194 - -dumy_block199: ; No predecessors! - br label %if_end194 - -dumy_block207: ; No predecessors! + %164 = bitcast %UntypedPtr* %162 to i8** + store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.39, i32 0, i32 0), i8** %163 + store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.39, i32 0, i32 3), i8** %164 + %165 = load %StringRef, %StringRef* %tmp.StringRef200 + store %StringRef %165, %StringRef* %"$tmpForRef199" + %166 = load i8, i8* %ch14 + call void @_ass_32_8z(i32* %tmp.this201, i8 %166) + store i8 41, i8* %"$tmpForRef202" + call void @toString.455(%String* %"$tmpC196", %StringRef* %"$tmpForRef197", i8* %ch14, %StringRef* %"$tmpForRef199", i32* %tmp.this201, i8* %"$tmpForRef202") + call void @reportError(%SparrowScanner* %this, %String* %"$tmpC196") + call void @dtor.239(%String* %"$tmpC196") + %167 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %167) + call void @ctor.393(%TokenType* %_result, i32 0) + ret void + +cond.true191: ; preds = %if_block188 + br label %cond.end193 + +cond.false192: ; preds = %if_block188 + %168 = load i8, i8* %ch14 + %169 = icmp eq i8 %168, 46 + br label %cond.end193 + +cond.end193: ; preds = %cond.false192, %cond.true191 + %cond.res194 = phi i1 [ true, %cond.true191 ], [ %169, %cond.false192 ] + br i1 %cond.res194, label %if_then189, label %if_end190 + +dumy_block195: ; No predecessors! + br label %if_end190 + +dumy_block203: ; No predecessors! br label %while_step } @@ -12887,33 +12512,33 @@ define internal i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedC br label %code code: ; preds = %0 - %1 = call i8 @front.406(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %1 = call i8 @front.395(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) ret i8 %1 } ; Function Attrs: inlinehint nounwind -define internal i8 @front.406(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #4 { +define internal i8 @front.395(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 - %2 = call i8 @front.407(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) + %2 = call i8 @front.396(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) ret i8 %2 } ; Function Attrs: inlinehint nounwind -define internal i8 @front.407(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #4 { +define internal i8 @front.396(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %2 = call i8* @front.408(%"Vector[Char]"* %1) + %2 = call i8* @front.397(%"Vector[Char]"* %1) %3 = load i8, i8* %2 ret i8 %3 } ; Function Attrs: inlinehint nounwind -define internal i8* @front.408(%"Vector[Char]"* %this) #4 { +define internal i8* @front.397(%"Vector[Char]"* %this) #4 { br label %code code: ; preds = %0 @@ -12924,26 +12549,20 @@ code: ; preds = %0 ; Function Attrs: inlinehint nounwind define internal i8 @peekChar(%SparrowScanner* %this) #4 { - %tmp.this = alloca i32 br label %code code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %2 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1, i32 0, i32 0 - store i32 1, i32* %tmp.this - %3 = load i32, i32* %tmp.this - %4 = call i8 @peek(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, i32 %3) - ret i8 %4 + %3 = call i8 @peek(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, i32 1) + ret i8 %3 } ; Function Attrs: inlinehint nounwind define internal i8 @peek(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 %n) #4 { %n.addr = alloca i32 store i32 %n, i32* %n.addr - %tmp.this = alloca i64 - %tmp.this1 = alloca i64 - %tmp.this2 = alloca i64 - %tmp.this3 = alloca i8 + %tmp.this = alloca i8 br label %code code: ; preds = %0 @@ -12951,19 +12570,16 @@ code: ; preds = %0 while_block: ; preds = %while_step, %code %1 = load i32, i32* %n.addr - %2 = zext i32 %1 to i64 - store i64 %2, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %5 = call i64 @size.185(%"Vector[Char]"* %4) - %6 = icmp sge i64 %3, %5 - br i1 %6, label %cond.true, label %cond.false + %2 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %3 = call i32 @size.175(%"Vector[Char]"* %2) + %4 = call i1 @_Int32_opGE(i32 %1, i32 %3) + br i1 %4, label %cond.true, label %cond.false while_body: ; preds = %cond.end - %7 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %8 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %9 = call i8 @"post_++.385"(%BufferedCharSourceRange* %8) - call void @"+="(%"Vector[Char]"* %7, i8 %9) + %5 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %6 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %7 = call i8 @"post_++.374"(%BufferedCharSourceRange* %6) + call void @"+="(%"Vector[Char]"* %5, i8 %7) br label %while_step while_step: ; preds = %while_body @@ -12973,72 +12589,64 @@ while_end: ; preds = %cond.end br label %if_block cond.true: ; preds = %while_block - %10 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %11 = call i1 @"pre_!!"(%BufferedCharSourceRange* %10) + %8 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %9 = call i1 @"pre_!!"(%BufferedCharSourceRange* %8) br label %cond.end cond.false: ; preds = %while_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %11, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %9, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %while_body, label %while_end if_block: ; preds = %while_end - %12 = load i32, i32* %n.addr - %13 = zext i32 %12 to i64 - store i64 %13, i64* %tmp.this1 - %14 = load i64, i64* %tmp.this1 - %15 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %16 = call i64 @size.185(%"Vector[Char]"* %15) - %17 = icmp slt i64 %14, %16 - br i1 %17, label %if_then, label %if_else + %10 = load i32, i32* %n.addr + %11 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %12 = call i32 @size.175(%"Vector[Char]"* %11) + %13 = call i1 @_Int32_opLT(i32 %10, i32 %12) + br i1 %13, label %if_then, label %if_else if_then: ; preds = %if_block - %18 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %19 = load i32, i32* %n.addr - %20 = zext i32 %19 to i64 - store i64 %20, i64* %tmp.this2 - %21 = load i64, i64* %tmp.this2 - %22 = call i8* @"().409"(%"Vector[Char]"* %18, i64 %21) - %23 = load i8, i8* %22 - ret i8 %23 + %14 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %15 = load i32, i32* %n.addr + %16 = call i8* @"().398"(%"Vector[Char]"* %14, i32 %15) + %17 = load i8, i8* %16 + ret i8 %17 if_else: ; preds = %if_block - store i8 0, i8* %tmp.this3 - %24 = load i8, i8* %tmp.this3 - ret i8 %24 + store i8 0, i8* %tmp.this + %18 = load i8, i8* %tmp.this + ret i8 %18 -if_end: ; preds = %dumy_block4, %dumy_block +if_end: ; preds = %dumy_block1, %dumy_block unreachable dumy_block: ; No predecessors! br label %if_end -dumy_block4: ; No predecessors! +dumy_block1: ; No predecessors! br label %if_end } ; Function Attrs: inlinehint nounwind -define internal i8* @"().409"(%"Vector[Char]"* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal i8* @"().398"(%"Vector[Char]"* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %"$tmpForRef" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - %3 = call %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %1, i64 %2) + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i32 %2) store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" %4 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") ret i8* %4 } ; Function Attrs: inlinehint nounwind -define internal void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #4 { - %tmp.this = alloca i32 - %tmp.this1 = alloca i32 +define internal void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this) #4 { br label %code code: ; preds = %0 @@ -13046,38 +12654,34 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 - %2 = call i8 @"pre_*.411"(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) + %2 = call i8 @"pre_*.400"(%"RangeWithLookahead[BufferedCharSourceRange]"* %1) %3 = icmp eq i8 %2, 10 br i1 %3, label %if_then, label %if_else if_then: ; preds = %if_block %4 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 1 %5 = load %Location*, %Location** %4 - store i32 1, i32* %tmp.this - %6 = load i32, i32* %tmp.this - call void @addLines(%Location* %5, i32 %6) + call void @addLines(%Location* %5, i32 1) br label %if_end if_else: ; preds = %if_block - %7 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 1 - %8 = load %Location*, %Location** %7 - store i32 1, i32* %tmp.this1 - %9 = load i32, i32* %tmp.this1 - call void @addColumns(%Location* %8, i32 %9) + %6 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 1 + %7 = load %Location*, %Location** %6 + call void @addColumns(%Location* %7, i32 1) br label %if_end if_end: ; preds = %if_else, %if_then - %10 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 - call void @popFront.412(%"RangeWithLookahead[BufferedCharSourceRange]"* %10) + %8 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %this, i32 0, i32 0 + call void @popFront.401(%"RangeWithLookahead[BufferedCharSourceRange]"* %8) ret void } ; Function Attrs: inlinehint nounwind -define internal i8 @"pre_*.411"(%"RangeWithLookahead[BufferedCharSourceRange]"* %r) #4 { +define internal i8 @"pre_*.400"(%"RangeWithLookahead[BufferedCharSourceRange]"* %r) #4 { br label %code code: ; preds = %0 - %1 = call i8 @front.407(%"RangeWithLookahead[BufferedCharSourceRange]"* %r) + %1 = call i8 @front.396(%"RangeWithLookahead[BufferedCharSourceRange]"* %r) ret i8 %1 } @@ -13085,7 +12689,6 @@ code: ; preds = %0 define internal void @addLines(%Location* %l, i32 %count) #4 { %count.addr = alloca i32 store i32 %count, i32* %count.addr - %tmp.this = alloca i32 br label %code code: ; preds = %0 @@ -13093,15 +12696,13 @@ code: ; preds = %0 %2 = getelementptr inbounds %LineCol, %LineCol* %1, i32 0, i32 0 %3 = load i32, i32* %2 %4 = load i32, i32* %count.addr - %5 = add i32 %3, %4 + %5 = call i32 @_Int32_opPlus(i32 %3, i32 %4) %6 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 %7 = getelementptr inbounds %LineCol, %LineCol* %6, i32 0, i32 0 store i32 %5, i32* %7 - store i32 1, i32* %tmp.this - %8 = load i32, i32* %tmp.this - %9 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 - %10 = getelementptr inbounds %LineCol, %LineCol* %9, i32 0, i32 1 - store i32 %8, i32* %10 + %8 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 + %9 = getelementptr inbounds %LineCol, %LineCol* %8, i32 0, i32 1 + store i32 1, i32* %9 ret void } @@ -13116,7 +12717,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %LineCol, %LineCol* %1, i32 0, i32 1 %3 = load i32, i32* %2 %4 = load i32, i32* %count.addr - %5 = add i32 %3, %4 + %5 = call i32 @_Int32_opPlus(i32 %3, i32 %4) %6 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 %7 = getelementptr inbounds %LineCol, %LineCol* %6, i32 0, i32 1 store i32 %5, i32* %7 @@ -13124,74 +12725,68 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @popFront.412(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #4 { - %tmp.this = alloca i64 +define internal void @popFront.401(%"RangeWithLookahead[BufferedCharSourceRange]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - store i64 0, i64* %tmp.this - %2 = load i64, i64* %tmp.this - call void @remove.413(%"Vector[Char]"* %1, i64 %2) + call void @remove.402(%"Vector[Char]"* %1, i32 0) br label %if_block if_block: ; preds = %code - %3 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %4 = call i1 @isEmpty.403(%"Vector[Char]"* %3) - br i1 %4, label %cond.true, label %cond.false + %2 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %3 = call i1 @isEmpty.392(%"Vector[Char]"* %2) + br i1 %3, label %cond.true, label %cond.false if_then: ; preds = %cond.end - %5 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %6 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %7 = call i8 @"post_++.385"(%BufferedCharSourceRange* %6) - call void @"+="(%"Vector[Char]"* %5, i8 %7) + %4 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %5 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %6 = call i8 @"post_++.374"(%BufferedCharSourceRange* %5) + call void @"+="(%"Vector[Char]"* %4, i8 %6) br label %if_end if_end: ; preds = %if_then, %cond.end ret void cond.true: ; preds = %if_block - %8 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %9 = call i1 @"pre_!!"(%BufferedCharSourceRange* %8) + %7 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %8 = call i1 @"pre_!!"(%BufferedCharSourceRange* %7) br label %cond.end cond.false: ; preds = %if_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %9, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %8, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %if_then, label %if_end } ; Function Attrs: inlinehint nounwind -define internal void @remove.413(%"Vector[Char]"* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal void @remove.402(%"Vector[Char]"* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %r = alloca %"ContiguousMemoryRange[Char]" %"$tmpForRef" = alloca %"ContiguousMemoryRange[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 - %1 = call %"ContiguousMemoryRange[Char]" @all.415(%"Vector[Char]"* %this) + %1 = call %"ContiguousMemoryRange[Char]" @all.404(%"Vector[Char]"* %this) store %"ContiguousMemoryRange[Char]" %1, %"ContiguousMemoryRange[Char]"* %"$tmpForRef" - call void @ctor.414(%"ContiguousMemoryRange[Char]"* %r, %"ContiguousMemoryRange[Char]"* %"$tmpForRef") - %2 = load i64, i64* %index.addr - call void @popFront.417(%"ContiguousMemoryRange[Char]"* %r, i64 %2) - %3 = call i64 @size.185(%"Vector[Char]"* %this) - %4 = load i64, i64* %index.addr - %5 = call i64 @_SizeType_opMinus(i64 %3, i64 %4) - store i64 1, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = call i64 @_SizeType_opMinus(i64 %5, i64 %6) - call void @popBack.418(%"ContiguousMemoryRange[Char]"* %r, i64 %7) - %8 = load %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %r - call void @remove.419(%"Vector[Char]"* %this, %"ContiguousMemoryRange[Char]" %8) + call void @ctor.403(%"ContiguousMemoryRange[Char]"* %r, %"ContiguousMemoryRange[Char]"* %"$tmpForRef") + %2 = load i32, i32* %index.addr + call void @popFront.406(%"ContiguousMemoryRange[Char]"* %r, i32 %2) + %3 = call i32 @size.175(%"Vector[Char]"* %this) + %4 = load i32, i32* %index.addr + %5 = call i32 @_Int32_opMinus(i32 %3, i32 %4) + %6 = call i32 @_Int32_opMinus(i32 %5, i32 1) + call void @popBack.407(%"ContiguousMemoryRange[Char]"* %r, i32 %6) + %7 = load %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %r + call void @remove.408(%"Vector[Char]"* %this, %"ContiguousMemoryRange[Char]" %7) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.414(%"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"* %other) #3 { +define internal void @ctor.403(%"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"* %other) #3 { %other.addr = alloca %"ContiguousMemoryRange[Char]"* store %"ContiguousMemoryRange[Char]"* %other, %"ContiguousMemoryRange[Char]"** %other.addr br label %code @@ -13200,16 +12795,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 %2 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %other.addr %3 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %2, i32 0, i32 0 - call void @ctor.178(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) + call void @ctor.168(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) %4 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 1 %5 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %other.addr %6 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %5, i32 0, i32 1 - call void @ctor.178(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) + call void @ctor.168(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) ret void } ; Function Attrs: inlinehint nounwind -define internal %"ContiguousMemoryRange[Char]" @all.415(%"Vector[Char]"* %this) #4 { +define internal %"ContiguousMemoryRange[Char]" @all.404(%"Vector[Char]"* %this) #4 { %tmp.this = alloca %"ContiguousMemoryRange[Char]" br label %code @@ -13218,13 +12813,13 @@ code: ; preds = %0 %2 = load %"RawPtr[Char]", %"RawPtr[Char]"* %1 %3 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %4 = load %"RawPtr[Char]", %"RawPtr[Char]"* %3 - call void @ctor.416(%"ContiguousMemoryRange[Char]"* %tmp.this, %"RawPtr[Char]" %2, %"RawPtr[Char]" %4) + call void @ctor.405(%"ContiguousMemoryRange[Char]"* %tmp.this, %"RawPtr[Char]" %2, %"RawPtr[Char]" %4) %5 = load %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %tmp.this ret %"ContiguousMemoryRange[Char]" %5 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.416(%"ContiguousMemoryRange[Char]"* %this, %"RawPtr[Char]" %f_begin, %"RawPtr[Char]" %f_end) #3 { +define internal void @ctor.405(%"ContiguousMemoryRange[Char]"* %this, %"RawPtr[Char]" %f_begin, %"RawPtr[Char]" %f_end) #3 { %this.addr = alloca %"ContiguousMemoryRange[Char]"* store %"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"** %this.addr %f_begin.addr = alloca %"RawPtr[Char]" @@ -13236,56 +12831,50 @@ define internal void @ctor.416(%"ContiguousMemoryRange[Char]"* %this, %"RawPtr[C code: ; preds = %0 %1 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %this.addr %2 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %1, i32 0, i32 0 - call void @ctor.178(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %f_begin.addr) + call void @ctor.168(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %f_begin.addr) %3 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %this.addr %4 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %3, i32 0, i32 1 - call void @ctor.178(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %f_end.addr) + call void @ctor.168(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %f_end.addr) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.417(%"ContiguousMemoryRange[Char]"* %this, i64 %n) #3 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @popFront.406(%"ContiguousMemoryRange[Char]"* %this, i32 %n) #3 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 %2 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 - %3 = load i64, i64* %n.addr - store i64 %3, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i64 %4) - store %"RawPtr[Char]" %5, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") + %3 = load i32, i32* %n.addr + %4 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i32 %3) + store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popBack.418(%"ContiguousMemoryRange[Char]"* %this, i64 %n) #3 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @popBack.407(%"ContiguousMemoryRange[Char]"* %this, i32 %n) #3 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 1 - %3 = load i64, i64* %n.addr - store i64 %3, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = sub i64 0, %4 - %6 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i64 %5) - store %"RawPtr[Char]" %6, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") + %3 = load i32, i32* %n.addr + %4 = call i32 @_Int32_opMinus1(i32 %3) + %5 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i32 %4) + store %"RawPtr[Char]" %5, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") ret void } ; Function Attrs: inlinehint nounwind -define internal void @remove.419(%"Vector[Char]"* %this, %"ContiguousMemoryRange[Char]" %range) #4 { +define internal void @remove.408(%"Vector[Char]"* %this, %"ContiguousMemoryRange[Char]" %range) #4 { %range.addr = alloca %"ContiguousMemoryRange[Char]" store %"ContiguousMemoryRange[Char]" %range, %"ContiguousMemoryRange[Char]"* %range.addr %rBegin = alloca %"RawPtr[Char]" @@ -13301,25 +12890,25 @@ define internal void @remove.419(%"Vector[Char]"* %this, %"ContiguousMemoryRange code: ; preds = %0 %1 = call %"RawPtr[Char]" @frontPtr(%"ContiguousMemoryRange[Char]"* %range.addr) store %"RawPtr[Char]" %1, %"RawPtr[Char]"* %"$tmpForRef" - call void @ctor.178(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef") + call void @ctor.168(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef") %2 = call %"RawPtr[Char]" @backPtr(%"ContiguousMemoryRange[Char]"* %range.addr) store %"RawPtr[Char]" %2, %"RawPtr[Char]"* %"$tmpForRef1" - call void @ctor.178(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef1") - call void @ctor.414(%"ContiguousMemoryRange[Char]"* %"$rangeVar", %"ContiguousMemoryRange[Char]"* %range.addr) + call void @ctor.168(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef1") + call void @ctor.403(%"ContiguousMemoryRange[Char]"* %"$rangeVar", %"ContiguousMemoryRange[Char]"* %range.addr) br label %while_block while_block: ; preds = %while_step, %code - %3 = call i1 @isEmpty.420(%"ContiguousMemoryRange[Char]"* %"$rangeVar") + %3 = call i1 @isEmpty.409(%"ContiguousMemoryRange[Char]"* %"$rangeVar") %4 = xor i1 true, %3 br i1 %4, label %while_body, label %while_end while_body: ; preds = %while_block - %5 = call i8* @front.421(%"ContiguousMemoryRange[Char]"* %"$rangeVar") + %5 = call i8* @front.410(%"ContiguousMemoryRange[Char]"* %"$rangeVar") store i8* %5, i8** %el br label %while_step while_step: ; preds = %while_body - call void @popFront.422(%"ContiguousMemoryRange[Char]"* %"$rangeVar") + call void @popFront.411(%"ContiguousMemoryRange[Char]"* %"$rangeVar") br label %while_block while_end: ; preds = %while_block @@ -13327,7 +12916,7 @@ while_end: ; preds = %while_block while_block2: ; preds = %while_step4, %while_end %6 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %7 = call i1 @"==.257"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %6) + %7 = call i1 @"==.246"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %6) %8 = xor i1 true, %7 br i1 %8, label %while_body3, label %while_end5 @@ -13338,12 +12927,12 @@ while_body3: ; preds = %while_block2 store i8 %10, i8* %11 %12 = call i8* @value(%"RawPtr[Char]"* %rEnd) %13 = load i8, i8* %12 - %14 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %rBegin) + %14 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %rBegin) store %"RawPtr[Char]" %14, %"RawPtr[Char]"* %"$tmpForRef6" - call void @"=.186"(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef6") - %15 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %rEnd) + call void @"=.176"(%"RawPtr[Char]"* %rBegin, %"RawPtr[Char]"* %"$tmpForRef6") + %15 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %rEnd) store %"RawPtr[Char]" %15, %"RawPtr[Char]"* %"$tmpForRef7" - call void @"=.186"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef7") + call void @"=.176"(%"RawPtr[Char]"* %rEnd, %"RawPtr[Char]"* %"$tmpForRef7") br label %while_step4 while_step4: ; preds = %while_body3 @@ -13351,7 +12940,7 @@ while_step4: ; preds = %while_body3 while_end5: ; preds = %while_block2 %16 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %16, %"RawPtr[Char]"* %rBegin) + call void @"=.176"(%"RawPtr[Char]"* %16, %"RawPtr[Char]"* %rBegin) ret void } @@ -13376,23 +12965,20 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.420(%"ContiguousMemoryRange[Char]"* %this) #4 { - %tmp.this = alloca i64 +define internal i1 @isEmpty.409(%"ContiguousMemoryRange[Char]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 %3 = load %"RawPtr[Char]", %"RawPtr[Char]"* %2 - %4 = call i64 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) - store i64 0, i64* %tmp.this - %5 = load i64, i64* %tmp.this - %6 = icmp sle i64 %4, %5 - ret i1 %6 + %4 = call i32 @diff(%"RawPtr[Char]"* %1, %"RawPtr[Char]" %3) + %5 = call i1 @_Int32_opLE(i32 %4, i32 0) + ret i1 %5 } ; Function Attrs: inlinehint nounwind -define internal i8* @front.421(%"ContiguousMemoryRange[Char]"* %this) #4 { +define internal i8* @front.410(%"ContiguousMemoryRange[Char]"* %this) #4 { br label %code code: ; preds = %0 @@ -13402,16 +12988,16 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.422(%"ContiguousMemoryRange[Char]"* %this) #3 { +define internal void @popFront.411(%"ContiguousMemoryRange[Char]"* %this) #3 { %"$tmpForRef" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 %2 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 - %3 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %2) + %3 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %2) store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") + call void @"=.176"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") ret void } @@ -13424,12 +13010,12 @@ code: ; preds = %0 br label %while_block while_block: ; preds = %while_step, %code - %1 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %1 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) %2 = xor i1 true, %1 br i1 %2, label %cond.true, label %cond.false while_body: ; preds = %cond.end - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) br label %while_step while_step: ; preds = %while_body @@ -13439,9 +13025,9 @@ while_end: ; preds = %cond.end ret void cond.true: ; preds = %while_block - %3 = call i8 @front.406(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %3 = call i8 @front.395(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) store i8 %3, i8* %"$tmpForRef" - %4 = call i1 @"().423"(%"$lambdaEnclosureData"* %pred, i8* %"$tmpForRef") + %4 = call i1 @"().412"(%"$lambdaEnclosureData"* %pred, i8* %"$tmpForRef") br label %cond.end cond.false: ; preds = %while_block @@ -13453,7 +13039,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"().423"(%"$lambdaEnclosureData"* %this, i8* %c) #3 { +define internal i1 @"().412"(%"$lambdaEnclosureData"* %this, i8* %c) #3 { %this.addr = alloca %"$lambdaEnclosureData"* store %"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"** %this.addr br label %code @@ -13465,7 +13051,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.424(%"$lambdaEnclosureData"* %this) #3 { +define internal void @ctor.413(%"$lambdaEnclosureData"* %this) #3 { br label %code code: ; preds = %0 @@ -13473,7 +13059,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.425(%"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"* %other) #3 { +define internal void @ctor.414(%"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData"* store %"$lambdaEnclosureData"* %other, %"$lambdaEnclosureData"** %other.addr br label %code @@ -13483,7 +13069,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.426(%"$lambdaEnclosureData"* %this) #3 { +define internal void @dtor.415(%"$lambdaEnclosureData"* %this) #3 { br label %code code: ; preds = %0 @@ -13491,7 +13077,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.427"(%"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"* %other) #3 { +define internal void @"=.416"(%"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData"* store %"$lambdaEnclosureData"* %other, %"$lambdaEnclosureData"** %other.addr br label %code @@ -13501,7 +13087,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.428"(%"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"* %other) #3 { +define internal i1 @"==.417"(%"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"* %other) #3 { %this.addr = alloca %"$lambdaEnclosureData"* store %"$lambdaEnclosureData"* %this, %"$lambdaEnclosureData"** %this.addr %other.addr = alloca %"$lambdaEnclosureData"* @@ -13513,17 +13099,17 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) #4 { +define internal i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) #4 { br label %code code: ; preds = %0 - %1 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %1 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) %2 = xor i1 true, %1 ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal void @advanceIf.430(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, %"$lambdaEnclosureData.0"* %pred) #4 { +define internal void @advanceIf.419(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, %"$lambdaEnclosureData.0"* %pred) #4 { %"$tmpForRef" = alloca i8 br label %code @@ -13531,12 +13117,12 @@ code: ; preds = %0 br label %while_block while_block: ; preds = %while_step, %code - %1 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %1 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) %2 = xor i1 true, %1 br i1 %2, label %cond.true, label %cond.false while_body: ; preds = %cond.end - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) br label %while_step while_step: ; preds = %while_body @@ -13546,9 +13132,9 @@ while_end: ; preds = %cond.end ret void cond.true: ; preds = %while_block - %3 = call i8 @front.406(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %3 = call i8 @front.395(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) store i8 %3, i8* %"$tmpForRef" - %4 = call i1 @"().431"(%"$lambdaEnclosureData.0"* %pred, i8* %"$tmpForRef") + %4 = call i1 @"().420"(%"$lambdaEnclosureData.0"* %pred, i8* %"$tmpForRef") br label %cond.end cond.false: ; preds = %while_block @@ -13560,7 +13146,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"().431"(%"$lambdaEnclosureData.0"* %this, i8* %c) #3 { +define internal i1 @"().420"(%"$lambdaEnclosureData.0"* %this, i8* %c) #3 { %this.addr = alloca %"$lambdaEnclosureData.0"* store %"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"** %this.addr br label %code @@ -13572,7 +13158,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.432(%"$lambdaEnclosureData.0"* %this) #3 { +define internal void @ctor.421(%"$lambdaEnclosureData.0"* %this) #3 { br label %code code: ; preds = %0 @@ -13580,7 +13166,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.433(%"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"* %other) #3 { +define internal void @ctor.422(%"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData.0"* store %"$lambdaEnclosureData.0"* %other, %"$lambdaEnclosureData.0"** %other.addr br label %code @@ -13590,7 +13176,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.434(%"$lambdaEnclosureData.0"* %this) #3 { +define internal void @dtor.423(%"$lambdaEnclosureData.0"* %this) #3 { br label %code code: ; preds = %0 @@ -13598,7 +13184,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.435"(%"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"* %other) #3 { +define internal void @"=.424"(%"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData.0"* store %"$lambdaEnclosureData.0"* %other, %"$lambdaEnclosureData.0"** %other.addr br label %code @@ -13608,7 +13194,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.436"(%"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"* %other) #3 { +define internal i1 @"==.425"(%"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"* %other) #3 { %this.addr = alloca %"$lambdaEnclosureData.0"* store %"$lambdaEnclosureData.0"* %this, %"$lambdaEnclosureData.0"** %this.addr %other.addr = alloca %"$lambdaEnclosureData.0"* @@ -13629,12 +13215,12 @@ code: ; preds = %0 %3 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %2, i32 0, i32 1 %4 = load %Location*, %Location** %3 %5 = load %Location, %Location* %4 - call void @reportError.437(%ErrorReporter* %1, %Location %5, %String* %msg) + call void @reportError.426(%ErrorReporter* %1, %Location %5, %String* %msg) ret void } ; Function Attrs: inlinehint nounwind -define internal void @reportError.437(%ErrorReporter* %obj, %Location %loc, %String* %msg) #4 { +define internal void @reportError.426(%ErrorReporter* %obj, %Location %loc, %String* %msg) #4 { %loc.addr = alloca %Location store %Location %loc, %Location* %loc.addr br label %code @@ -13644,12 +13230,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = call %StringRef @asStringRef(%String* %msg) - call void @"().438"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) + call void @"().427"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) ret void } ; Function Attrs: inlinehint nounwind -define internal void @"().438"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3) #4 { +define internal void @"().427"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -13675,15 +13261,15 @@ code: ; preds = %0 %2 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %1) %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %4 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %3) - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) %5 = load %StringRef, %StringRef* %tmp.this %6 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %6) + call void @dtor.51(%StringRef %6) ret %StringRef %5 dumy_block: ; No predecessors! %7 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %7) + call void @dtor.51(%StringRef %7) unreachable } @@ -13694,26 +13280,26 @@ define internal void @toString(%String* sret %_result, %StringRef* %a1) #4 { br label %code code: ; preds = %0 - call void @ctor.439(%StringOutputStream* %s) + call void @ctor.428(%StringOutputStream* %s) call void @"<<"(%StringOutputStream* %"$tmpC", %StringOutputStream* %s, %StringRef* %a1) - call void @dtor.442(%StringOutputStream* %"$tmpC") + call void @dtor.431(%StringOutputStream* %"$tmpC") %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %s, i32 0, i32 0 - call void @ctor.175(%String* %_result, %String* %1) - call void @dtor.442(%StringOutputStream* %s) + call void @ctor.165(%String* %_result, %String* %1) + call void @dtor.431(%StringOutputStream* %s) ret void dumy_block: ; No predecessors! - call void @dtor.442(%StringOutputStream* %s) + call void @dtor.431(%StringOutputStream* %s) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.439(%StringOutputStream* %this) #3 { +define internal void @ctor.428(%StringOutputStream* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 - call void @ctor.124(%String* %1) + call void @ctor.114(%String* %1) ret void } @@ -13723,13 +13309,13 @@ define internal void @"<<"(%StringOutputStream* sret %_result, %StringOutputStre code: ; preds = %0 %1 = load %StringRef, %StringRef* %x - call void @"<<<.440"(%StringOutputStream* %s, %StringRef %1) - call void @ctor.441(%StringOutputStream* %_result, %StringOutputStream* %s) + call void @"<<<.429"(%StringOutputStream* %s, %StringRef %1) + call void @ctor.430(%StringOutputStream* %_result, %StringOutputStream* %s) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"<<<.440"(%StringOutputStream* %this, %StringRef %s) #3 { +define internal void @"<<<.429"(%StringOutputStream* %this, %StringRef %s) #3 { %s.addr = alloca %StringRef store %StringRef %s, %StringRef* %s.addr br label %code @@ -13750,11 +13336,11 @@ code: ; preds = %0 %2 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %1) %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %4 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %3) - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) %5 = load %StringRef, %StringRef* %tmp.this call void @insertBefore(%String* %this, %StringRef* %range, %StringRef %5) %6 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %6) + call void @dtor.51(%StringRef %6) ret void } @@ -13763,128 +13349,113 @@ define internal void @insertBefore(%String* %this, %StringRef* %range, %StringRe %pos.addr = alloca %StringRef store %StringRef %pos, %StringRef* %pos.addr %rc = alloca %StringRef - %n = alloca i64 - %index = alloca i64 + %n = alloca i32 + %index = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Char]" %p = alloca %"RawPtr[Char]" %"$tmpForRef1" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 %q = alloca %"RawPtr[Char]" %"$tmpForRef2" = alloca %"RawPtr[Char]" - %tmp.this3 = alloca i64 + %"$tmpForRef3" = alloca %"RawPtr[Char]" %"$tmpForRef4" = alloca %"RawPtr[Char]" - %tmp.this5 = alloca i64 - %"$tmpForRef6" = alloca %"RawPtr[Char]" - %tmp.this7 = alloca i64 - %"$tmpForRef8" = alloca %"RawPtr[Char]" - %"$tmpForRef13" = alloca %"RawPtr[Char]" - %"$tmpForRef14" = alloca %"RawPtr[Char]" - %tmp.this15 = alloca i64 + %"$tmpForRef5" = alloca %"RawPtr[Char]" + %"$tmpForRef10" = alloca %"RawPtr[Char]" + %"$tmpForRef11" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = load %StringRef, %StringRef* %range - call void @ctor.59(%StringRef* %rc, %StringRef %1) + call void @ctor.49(%StringRef* %rc, %StringRef %1) %2 = load %StringRef, %StringRef* %range - %3 = call i64 @size(%StringRef %2) - store i64 %3, i64* %n + %3 = call i32 @size(%StringRef %2) + store i32 %3, i32* %n %4 = load %StringRef, %StringRef* %pos.addr %5 = call %"RawPtr[Char]" @_frontPtr(%StringRef %4) store %"RawPtr[Char]" %5, %"RawPtr[Char]"* %"$tmpForRef" %6 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %7 = load %"RawPtr[Char]", %"RawPtr[Char]"* %6 - %8 = call i64 @diff(%"RawPtr[Char]"* %"$tmpForRef", %"RawPtr[Char]" %7) - store i64 %8, i64* %index - %9 = call i64 @size.176(%String* %this) - %10 = load i64, i64* %n - %11 = add i64 %9, %10 - call void @reserve(%String* %this, i64 %11) + %8 = call i32 @diff(%"RawPtr[Char]"* %"$tmpForRef", %"RawPtr[Char]" %7) + store i32 %8, i32* %index + %9 = call i32 @size.166(%String* %this) + %10 = load i32, i32* %n + %11 = call i32 @_Int32_opPlus(i32 %9, i32 %10) + call void @reserve(%String* %this, i32 %11) %12 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this - %13 = load i64, i64* %tmp.this - %14 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %12, i64 %13) - store %"RawPtr[Char]" %14, %"RawPtr[Char]"* %"$tmpForRef1" - call void @ctor.178(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef1") - %15 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %16 = load i64, i64* %index - store i64 1, i64* %tmp.this3 - %17 = load i64, i64* %tmp.this3 - %18 = call i64 @_DiffType_opMinus(i64 %16, i64 %17) - %19 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %15, i64 %18) - store %"RawPtr[Char]" %19, %"RawPtr[Char]"* %"$tmpForRef2" - call void @ctor.178(%"RawPtr[Char]"* %q, %"RawPtr[Char]"* %"$tmpForRef2") + %13 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %12, i32 -1) + store %"RawPtr[Char]" %13, %"RawPtr[Char]"* %"$tmpForRef1" + call void @ctor.168(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef1") + %14 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %15 = load i32, i32* %index + %16 = call i32 @_Int32_opMinus(i32 %15, i32 1) + %17 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %14, i32 %16) + store %"RawPtr[Char]" %17, %"RawPtr[Char]"* %"$tmpForRef2" + call void @ctor.168(%"RawPtr[Char]"* %q, %"RawPtr[Char]"* %"$tmpForRef2") br label %while_block while_block: ; preds = %while_step, %code - %20 = call i1 @"==.257"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %q) - %21 = xor i1 true, %20 - br i1 %21, label %while_body, label %while_end + %18 = call i1 @"==.246"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %q) + %19 = xor i1 true, %18 + br i1 %19, label %while_body, label %while_end while_body: ; preds = %while_block - %22 = call i8* @value(%"RawPtr[Char]"* %p) - %23 = load i8, i8* %22 - %24 = load i64, i64* %n - store i64 %24, i64* %tmp.this5 - %25 = load i64, i64* %tmp.this5 - %26 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %p, i64 %25) - store %"RawPtr[Char]" %26, %"RawPtr[Char]"* %"$tmpForRef4" - %27 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef4") - store i8 %23, i8* %27 - %28 = call i8* @value(%"RawPtr[Char]"* %p) - %29 = load i8, i8* %28 + %20 = call i8* @value(%"RawPtr[Char]"* %p) + %21 = load i8, i8* %20 + %22 = load i32, i32* %n + %23 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %p, i32 %22) + store %"RawPtr[Char]" %23, %"RawPtr[Char]"* %"$tmpForRef3" + %24 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef3") + store i8 %21, i8* %24 + %25 = call i8* @value(%"RawPtr[Char]"* %p) + %26 = load i8, i8* %25 br label %while_step while_step: ; preds = %while_body - store i64 -1, i64* %tmp.this7 - %30 = load i64, i64* %tmp.this7 - %31 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %p, i64 %30) - store %"RawPtr[Char]" %31, %"RawPtr[Char]"* %"$tmpForRef6" - call void @"=.186"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef6") + %27 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %p, i32 -1) + store %"RawPtr[Char]" %27, %"RawPtr[Char]"* %"$tmpForRef4" + call void @"=.176"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef4") br label %while_block while_end: ; preds = %while_block - %32 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %p) - store %"RawPtr[Char]" %32, %"RawPtr[Char]"* %"$tmpForRef8" - call void @"=.186"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef8") - br label %while_block9 - -while_block9: ; preds = %while_step11, %while_end - %33 = load %StringRef, %StringRef* %rc - %34 = call i1 @isEmpty(%StringRef %33) - %35 = xor i1 true, %34 - br i1 %35, label %while_body10, label %while_end12 - -while_body10: ; preds = %while_block9 - %36 = load %StringRef, %StringRef* %rc - %37 = call i8* @front(%StringRef %36) - %38 = load i8, i8* %37 - %39 = call i8* @value(%"RawPtr[Char]"* %p) - store i8 %38, i8* %39 - %40 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %p) - store %"RawPtr[Char]" %40, %"RawPtr[Char]"* %"$tmpForRef13" - call void @"=.186"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef13") + %28 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %p) + store %"RawPtr[Char]" %28, %"RawPtr[Char]"* %"$tmpForRef5" + call void @"=.176"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef5") + br label %while_block6 + +while_block6: ; preds = %while_step8, %while_end + %29 = load %StringRef, %StringRef* %rc + %30 = call i1 @isEmpty(%StringRef %29) + %31 = xor i1 true, %30 + br i1 %31, label %while_body7, label %while_end9 + +while_body7: ; preds = %while_block6 + %32 = load %StringRef, %StringRef* %rc + %33 = call i8* @front(%StringRef %32) + %34 = load i8, i8* %33 + %35 = call i8* @value(%"RawPtr[Char]"* %p) + store i8 %34, i8* %35 + %36 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %p) + store %"RawPtr[Char]" %36, %"RawPtr[Char]"* %"$tmpForRef10" + call void @"=.176"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef10") call void @popFront(%StringRef* %rc) - br label %while_step11 + br label %while_step8 -while_step11: ; preds = %while_body10 - br label %while_block9 +while_step8: ; preds = %while_body7 + br label %while_block6 -while_end12: ; preds = %while_block9 - %41 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %42 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %43 = load i64, i64* %n - store i64 %43, i64* %tmp.this15 - %44 = load i64, i64* %tmp.this15 - %45 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %42, i64 %44) - store %"RawPtr[Char]" %45, %"RawPtr[Char]"* %"$tmpForRef14" - call void @"=.186"(%"RawPtr[Char]"* %41, %"RawPtr[Char]"* %"$tmpForRef14") - %46 = load %StringRef, %StringRef* %rc - call void @dtor.61(%StringRef %46) +while_end9: ; preds = %while_block6 + %37 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %38 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %39 = load i32, i32* %n + %40 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %38, i32 %39) + store %"RawPtr[Char]" %40, %"RawPtr[Char]"* %"$tmpForRef11" + call void @"=.176"(%"RawPtr[Char]"* %37, %"RawPtr[Char]"* %"$tmpForRef11") + %41 = load %StringRef, %StringRef* %rc + call void @dtor.51(%StringRef %41) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.441(%StringOutputStream* %this, %StringOutputStream* %other) #3 { +define internal void @ctor.430(%StringOutputStream* %this, %StringOutputStream* %other) #3 { %other.addr = alloca %StringOutputStream* store %StringOutputStream* %other, %StringOutputStream** %other.addr br label %code @@ -13893,22 +13464,22 @@ code: ; preds = %0 %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 %2 = load %StringOutputStream*, %StringOutputStream** %other.addr %3 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %2, i32 0, i32 0 - call void @ctor.175(%String* %1, %String* %3) + call void @ctor.165(%String* %1, %String* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.442(%StringOutputStream* %this) #3 { +define internal void @dtor.431(%StringOutputStream* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 - call void @dtor.250(%String* %1) + call void @dtor.239(%String* %1) ret void } ; Function Attrs: inlinehint nounwind -define internal void @advanceIf.443(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, %"$lambdaEnclosureData.1"* %pred) #4 { +define internal void @advanceIf.432(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, %"$lambdaEnclosureData.1"* %pred) #4 { %"$tmpForRef" = alloca i8 br label %code @@ -13916,12 +13487,12 @@ code: ; preds = %0 br label %while_block while_block: ; preds = %while_step, %code - %1 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %1 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) %2 = xor i1 true, %1 br i1 %2, label %cond.true, label %cond.false while_body: ; preds = %cond.end - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) br label %while_step while_step: ; preds = %while_body @@ -13931,9 +13502,9 @@ while_end: ; preds = %cond.end ret void cond.true: ; preds = %while_block - %3 = call i8 @front.406(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %3 = call i8 @front.395(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) store i8 %3, i8* %"$tmpForRef" - %4 = call i1 @"().444"(%"$lambdaEnclosureData.1"* %pred, i8* %"$tmpForRef") + %4 = call i1 @"().433"(%"$lambdaEnclosureData.1"* %pred, i8* %"$tmpForRef") br label %cond.end cond.false: ; preds = %while_block @@ -13945,7 +13516,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"().444"(%"$lambdaEnclosureData.1"* %this, i8* %c) #3 { +define internal i1 @"().433"(%"$lambdaEnclosureData.1"* %this, i8* %c) #3 { %this.addr = alloca %"$lambdaEnclosureData.1"* store %"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"** %this.addr br label %code @@ -13957,7 +13528,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.445(%"$lambdaEnclosureData.1"* %this) #3 { +define internal void @ctor.434(%"$lambdaEnclosureData.1"* %this) #3 { br label %code code: ; preds = %0 @@ -13965,7 +13536,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.446(%"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"* %other) #3 { +define internal void @ctor.435(%"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData.1"* store %"$lambdaEnclosureData.1"* %other, %"$lambdaEnclosureData.1"** %other.addr br label %code @@ -13975,7 +13546,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.447(%"$lambdaEnclosureData.1"* %this) #3 { +define internal void @dtor.436(%"$lambdaEnclosureData.1"* %this) #3 { br label %code code: ; preds = %0 @@ -13983,7 +13554,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.448"(%"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"* %other) #3 { +define internal void @"=.437"(%"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData.1"* store %"$lambdaEnclosureData.1"* %other, %"$lambdaEnclosureData.1"** %other.addr br label %code @@ -13993,7 +13564,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.449"(%"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"* %other) #3 { +define internal i1 @"==.438"(%"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"* %other) #3 { %this.addr = alloca %"$lambdaEnclosureData.1"* store %"$lambdaEnclosureData.1"* %this, %"$lambdaEnclosureData.1"** %this.addr %other.addr = alloca %"$lambdaEnclosureData.1"* @@ -14005,7 +13576,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @advanceIf.450(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, %"$lambdaEnclosureData.2"* %pred) #4 { +define internal void @advanceIf.439(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, %"$lambdaEnclosureData.2"* %pred) #4 { %"$tmpForRef" = alloca i8 br label %code @@ -14013,12 +13584,12 @@ code: ; preds = %0 br label %while_block while_block: ; preds = %while_step, %code - %1 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %1 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) %2 = xor i1 true, %1 br i1 %2, label %cond.true, label %cond.false while_body: ; preds = %cond.end - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) br label %while_step while_step: ; preds = %while_body @@ -14028,9 +13599,9 @@ while_end: ; preds = %cond.end ret void cond.true: ; preds = %while_block - %3 = call i8 @front.406(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + %3 = call i8 @front.395(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) store i8 %3, i8* %"$tmpForRef" - %4 = call i1 @"().451"(%"$lambdaEnclosureData.2"* %pred, i8* %"$tmpForRef") + %4 = call i1 @"().440"(%"$lambdaEnclosureData.2"* %pred, i8* %"$tmpForRef") br label %cond.end cond.false: ; preds = %while_block @@ -14042,7 +13613,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal i1 @"().451"(%"$lambdaEnclosureData.2"* %this, i8* %c) #3 { +define internal i1 @"().440"(%"$lambdaEnclosureData.2"* %this, i8* %c) #3 { %this.addr = alloca %"$lambdaEnclosureData.2"* store %"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"** %this.addr br label %code @@ -14054,7 +13625,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.452(%"$lambdaEnclosureData.2"* %this) #3 { +define internal void @ctor.441(%"$lambdaEnclosureData.2"* %this) #3 { br label %code code: ; preds = %0 @@ -14062,7 +13633,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.453(%"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"* %other) #3 { +define internal void @ctor.442(%"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData.2"* store %"$lambdaEnclosureData.2"* %other, %"$lambdaEnclosureData.2"** %other.addr br label %code @@ -14072,7 +13643,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.454(%"$lambdaEnclosureData.2"* %this) #3 { +define internal void @dtor.443(%"$lambdaEnclosureData.2"* %this) #3 { br label %code code: ; preds = %0 @@ -14080,7 +13651,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.455"(%"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"* %other) #3 { +define internal void @"=.444"(%"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"* %other) #3 { %other.addr = alloca %"$lambdaEnclosureData.2"* store %"$lambdaEnclosureData.2"* %other, %"$lambdaEnclosureData.2"** %other.addr br label %code @@ -14090,7 +13661,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.456"(%"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"* %other) #3 { +define internal i1 @"==.445"(%"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"* %other) #3 { %this.addr = alloca %"$lambdaEnclosureData.2"* store %"$lambdaEnclosureData.2"* %this, %"$lambdaEnclosureData.2"** %this.addr %other.addr = alloca %"$lambdaEnclosureData.2"* @@ -14102,24 +13673,24 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %tmp.this = alloca i64 +define internal void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %nn = alloca i32 br label %code code: ; preds = %0 + %1 = load i32, i32* %n.addr + store i32 %1, i32* %nn br label %while_block while_block: ; preds = %while_step, %code - %1 = call i64 @post_--.52(i64* %n.addr) - store i64 0, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = icmp sgt i64 %1, %2 + %2 = call i32 @post_--.40(i32* %nn) + %3 = call i1 @_Int32_opGT(i32 %2, i32 0) br i1 %3, label %while_body, label %while_end while_body: ; preds = %while_block - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %range) br label %while_step while_step: ; preds = %while_body @@ -14130,12 +13701,12 @@ while_end: ; preds = %while_block } ; Function Attrs: inlinehint nounwind -define internal i8 @"pre_++.458"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) #4 { +define internal i8 @"pre_++.447"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) #4 { br label %code code: ; preds = %0 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %1 = call i8 @front.406(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %1 = call i8 @front.395(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) ret i8 %1 } @@ -14144,32 +13715,32 @@ define internal i1 @"pre_!"(%"LocationSyncCharRange[RangeWithLookahead[BufferedC br label %code code: ; preds = %0 - %1 = call i1 @isEmpty.401(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %1 = call i1 @isEmpty.390(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) ret i1 %1 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.459(%String* %this, %StringRef %other) #4 { +define internal void @ctor.448(%String* %this, %StringRef %other) #4 { %other.addr = alloca %StringRef store %StringRef %other, %StringRef* %other.addr - %size = alloca i64 + %size = alloca i32 %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 %1 = load %StringRef, %StringRef* %other.addr - %2 = call i64 @size(%StringRef %1) - store i64 %2, i64* %size - %3 = load i64, i64* %size - call void @ctor.177(%String* %this, i64 %3) + %2 = call i32 @size(%StringRef %1) + store i32 %2, i32* %size + %3 = load i32, i32* %size + call void @ctor.167(%String* %this, i32 %3) %4 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %5 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %4) %6 = getelementptr inbounds %StringRef, %StringRef* %other.addr, i32 0, i32 0 %7 = load %UntypedPtr, %UntypedPtr* %6 - call void @ctor.55(%UntypedPtr* %tmp.this, %UntypedPtr %7) + call void @ctor.45(%UntypedPtr* %tmp.this, %UntypedPtr %7) %8 = load %UntypedPtr, %UntypedPtr* %tmp.this - %9 = load i64, i64* %size - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %5, %UntypedPtr %8, i64 %9) + %9 = load i32, i32* %size + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %5, %UntypedPtr %8, i32 %9) ret void } @@ -14177,36 +13748,33 @@ code: ; preds = %0 define internal void @parseString(%TokenType* sret %_result, %SparrowScanner* %this, i8 %endChar) #4 { %endChar.addr = alloca i8 store i8 %endChar, i8* %endChar.addr - %tmp.this = alloca i32 - %tmp.this1 = alloca %String + %tmp.this = alloca %String %tmp.StringRef = alloca %StringRef - %tmp.this8 = alloca %String - %tmp.StringRef9 = alloca %StringRef + %tmp.this7 = alloca %String + %tmp.StringRef8 = alloca %StringRef br label %code code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) br label %if_block if_block: ; preds = %code - store i32 1, i32* %tmp.this - %2 = load i32, i32* %tmp.this - %3 = call i1 @hasLessThan(%SparrowScanner* %this, i32 %2) - br i1 %3, label %if_then, label %if_end + %2 = call i1 @hasLessThan(%SparrowScanner* %this, i32 1) + br i1 %2, label %if_then, label %if_end if_then: ; preds = %if_block - %4 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 - %5 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %3 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 + %4 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %5 = bitcast %UntypedPtr* %3 to i8** %6 = bitcast %UntypedPtr* %4 to i8** - %7 = bitcast %UntypedPtr* %5 to i8** - store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.10, i32 0, i32 0), i8** %6 - store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.10, i32 0, i32 39), i8** %7 - %8 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %tmp.this1, %StringRef %8) - call void @reportError(%SparrowScanner* %this, %String* %tmp.this1) - call void @dtor.250(%String* %tmp.this1) - call void @ctor.404(%TokenType* %_result, i32 0) + store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.10, i32 0, i32 0), i8** %5 + store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.10, i32 0, i32 39), i8** %6 + %7 = load %StringRef, %StringRef* %tmp.StringRef + call void @ctor.448(%String* %tmp.this, %StringRef %7) + call void @reportError(%SparrowScanner* %this, %String* %tmp.this) + call void @dtor.239(%String* %tmp.this) + call void @ctor.393(%TokenType* %_result, i32 0) ret void if_end: ; preds = %dumy_block, %if_block @@ -14216,72 +13784,72 @@ dumy_block: ; No predecessors! br label %if_end while_block: ; preds = %while_step, %if_end - %9 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %10 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %9) - br i1 %10, label %cond.true, label %cond.false + %8 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %9 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %8) + br i1 %9, label %cond.true, label %cond.false while_body: ; preds = %cond.end - br label %if_block2 + br label %if_block1 -while_step: ; preds = %if_end4 +while_step: ; preds = %if_end3 br label %while_block while_end: ; preds = %cond.end - br label %if_block5 + br label %if_block4 cond.true: ; preds = %while_block - %11 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %12 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %11) - %13 = load i8, i8* %endChar.addr - %14 = icmp ne i8 %12, %13 + %10 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %11 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %10) + %12 = load i8, i8* %endChar.addr + %13 = icmp ne i8 %11, %12 br label %cond.end cond.false: ; preds = %while_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %14, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %13, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %while_body, label %while_end -if_block2: ; preds = %while_body - %15 = call i1 @checkEscapeChar(%SparrowScanner* %this) - %16 = xor i1 true, %15 - br i1 %16, label %if_then3, label %if_end4 +if_block1: ; preds = %while_body + %14 = call i1 @checkEscapeChar(%SparrowScanner* %this) + %15 = xor i1 true, %14 + br i1 %15, label %if_then2, label %if_end3 -if_then3: ; preds = %if_block2 +if_then2: ; preds = %if_block1 call void @advanceAndCapture1(%SparrowScanner* %this) - br label %if_end4 + br label %if_end3 -if_end4: ; preds = %if_then3, %if_block2 +if_end3: ; preds = %if_then2, %if_block1 br label %while_step -if_block5: ; preds = %while_end - %17 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %18 = call i1 @"pre_!"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %17) - br i1 %18, label %if_then6, label %if_end7 +if_block4: ; preds = %while_end + %16 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %17 = call i1 @"pre_!"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %16) + br i1 %17, label %if_then5, label %if_end6 -if_then6: ; preds = %if_block5 - %19 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef9, i32 0, i32 0 - %20 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef9, i32 0, i32 1 +if_then5: ; preds = %if_block4 + %18 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef8, i32 0, i32 0 + %19 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef8, i32 0, i32 1 + %20 = bitcast %UntypedPtr* %18 to i8** %21 = bitcast %UntypedPtr* %19 to i8** - %22 = bitcast %UntypedPtr* %20 to i8** - store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.12, i32 0, i32 0), i8** %21 - store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.12, i32 0, i32 39), i8** %22 - %23 = load %StringRef, %StringRef* %tmp.StringRef9 - call void @ctor.459(%String* %tmp.this8, %StringRef %23) - call void @reportError(%SparrowScanner* %this, %String* %tmp.this8) - call void @dtor.250(%String* %tmp.this8) - call void @ctor.404(%TokenType* %_result, i32 0) + store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.12, i32 0, i32 0), i8** %20 + store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.12, i32 0, i32 39), i8** %21 + %22 = load %StringRef, %StringRef* %tmp.StringRef8 + call void @ctor.448(%String* %tmp.this7, %StringRef %22) + call void @reportError(%SparrowScanner* %this, %String* %tmp.this7) + call void @dtor.239(%String* %tmp.this7) + call void @ctor.393(%TokenType* %_result, i32 0) ret void -if_end7: ; preds = %dumy_block10, %if_block5 - %24 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %24) - call void @ctor.404(%TokenType* %_result, i32 40) +if_end6: ; preds = %dumy_block9, %if_block4 + %23 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %23) + call void @ctor.393(%TokenType* %_result, i32 40) ret void -dumy_block10: ; No predecessors! - br label %if_end7 +dumy_block9: ; No predecessors! + br label %if_end6 } ; Function Attrs: inlinehint nounwind @@ -14294,16 +13862,14 @@ code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %2 = getelementptr inbounds %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]", %"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1, i32 0, i32 0 %3 = load i32, i32* %n.addr - %4 = call i1 @hasLessThan.460(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, i32 %3) + %4 = call i1 @hasLessThan.449(%"RangeWithLookahead[BufferedCharSourceRange]"* %2, i32 %3) ret i1 %4 } ; Function Attrs: inlinehint nounwind -define internal i1 @hasLessThan.460(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 %n) #4 { +define internal i1 @hasLessThan.449(%"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 %n) #4 { %n.addr = alloca i32 store i32 %n, i32* %n.addr - %tmp.this = alloca i64 - %tmp.this1 = alloca i64 br label %code code: ; preds = %0 @@ -14311,55 +13877,48 @@ code: ; preds = %0 while_block: ; preds = %while_step, %code %1 = load i32, i32* %n.addr - %2 = zext i32 %1 to i64 - store i64 %2, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %5 = call i64 @size.185(%"Vector[Char]"* %4) - %6 = icmp sge i64 %3, %5 - br i1 %6, label %cond.true, label %cond.false + %2 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %3 = call i32 @size.175(%"Vector[Char]"* %2) + %4 = call i1 @_Int32_opGE(i32 %1, i32 %3) + br i1 %4, label %cond.true, label %cond.false while_body: ; preds = %cond.end - %7 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %8 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %9 = call i8 @"post_++.385"(%BufferedCharSourceRange* %8) - call void @"+="(%"Vector[Char]"* %7, i8 %9) + %5 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %6 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %7 = call i8 @"post_++.374"(%BufferedCharSourceRange* %6) + call void @"+="(%"Vector[Char]"* %5, i8 %7) br label %while_step while_step: ; preds = %while_body br label %while_block while_end: ; preds = %cond.end - %10 = load i32, i32* %n.addr - %11 = zext i32 %10 to i64 - store i64 %11, i64* %tmp.this1 - %12 = load i64, i64* %tmp.this1 - %13 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 - %14 = call i64 @size.185(%"Vector[Char]"* %13) - %15 = icmp sge i64 %12, %14 - ret i1 %15 + %8 = load i32, i32* %n.addr + %9 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 1 + %10 = call i32 @size.175(%"Vector[Char]"* %9) + %11 = call i1 @_Int32_opGE(i32 %8, i32 %10) + ret i1 %11 cond.true: ; preds = %while_block - %16 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 - %17 = call i1 @"pre_!!"(%BufferedCharSourceRange* %16) + %12 = getelementptr inbounds %"RangeWithLookahead[BufferedCharSourceRange]", %"RangeWithLookahead[BufferedCharSourceRange]"* %this, i32 0, i32 0 + %13 = call i1 @"pre_!!"(%BufferedCharSourceRange* %12) br label %cond.end cond.false: ; preds = %while_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %17, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %13, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %while_body, label %while_end } ; Function Attrs: noinline nounwind define i1 @checkEscapeChar(%SparrowScanner* %this) #5 { %ch = alloca i8 - %tmp.this = alloca i32 - %tmp.this39 = alloca %String + %tmp.this = alloca %String %tmp.StringRef = alloca %StringRef %charVal = alloca i32 - %tmp.this40 = alloca i8 + %tmp.this39 = alloca i8 br label %code code: ; preds = %0 @@ -14375,11 +13934,11 @@ if_block: ; preds = %code if_then: ; preds = %if_block %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %6 = call i8 @"pre_++.458"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) + %6 = call i8 @"pre_++.447"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) store i8 %6, i8* %ch br label %if_block1 -if_end: ; preds = %dumy_block41, %if_block +if_end: ; preds = %dumy_block40, %if_block ret i1 false if_block1: ; preds = %if_then @@ -14390,7 +13949,7 @@ if_block1: ; preds = %if_then if_then2: ; preds = %if_block1 %9 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %10 = getelementptr inbounds %Token, %Token* %9, i32 0, i32 2 - call void @"+=.461"(%String* %10, i8 13) + call void @"+=.450"(%String* %10, i8 13) br label %if_end3 if_else: ; preds = %if_block1 @@ -14398,7 +13957,7 @@ if_else: ; preds = %if_block1 if_end3: ; preds = %if_end7, %if_then2 %11 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %11) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %11) ret i1 true if_block4: ; preds = %if_else @@ -14409,7 +13968,7 @@ if_block4: ; preds = %if_else if_then5: ; preds = %if_block4 %14 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %15 = getelementptr inbounds %Token, %Token* %14, i32 0, i32 2 - call void @"+=.461"(%String* %15, i8 10) + call void @"+=.450"(%String* %15, i8 10) br label %if_end7 if_else6: ; preds = %if_block4 @@ -14426,7 +13985,7 @@ if_block8: ; preds = %if_else6 if_then9: ; preds = %if_block8 %18 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %19 = getelementptr inbounds %Token, %Token* %18, i32 0, i32 2 - call void @"+=.461"(%String* %19, i8 8) + call void @"+=.450"(%String* %19, i8 8) br label %if_end11 if_else10: ; preds = %if_block8 @@ -14443,7 +14002,7 @@ if_block12: ; preds = %if_else10 if_then13: ; preds = %if_block12 %22 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %23 = getelementptr inbounds %Token, %Token* %22, i32 0, i32 2 - call void @"+=.461"(%String* %23, i8 12) + call void @"+=.450"(%String* %23, i8 12) br label %if_end15 if_else14: ; preds = %if_block12 @@ -14460,7 +14019,7 @@ if_block16: ; preds = %if_else14 if_then17: ; preds = %if_block16 %26 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %27 = getelementptr inbounds %Token, %Token* %26, i32 0, i32 2 - call void @"+=.461"(%String* %27, i8 9) + call void @"+=.450"(%String* %27, i8 9) br label %if_end19 if_else18: ; preds = %if_block16 @@ -14477,7 +14036,7 @@ if_block20: ; preds = %if_else18 if_then21: ; preds = %if_block20 %30 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %31 = getelementptr inbounds %Token, %Token* %30, i32 0, i32 2 - call void @"+=.461"(%String* %31, i8 92) + call void @"+=.450"(%String* %31, i8 92) br label %if_end23 if_else22: ; preds = %if_block20 @@ -14494,7 +14053,7 @@ if_block24: ; preds = %if_else22 if_then25: ; preds = %if_block24 %34 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %35 = getelementptr inbounds %Token, %Token* %34, i32 0, i32 2 - call void @"+=.461"(%String* %35, i8 39) + call void @"+=.450"(%String* %35, i8 39) br label %if_end27 if_else26: ; preds = %if_block24 @@ -14511,7 +14070,7 @@ if_block28: ; preds = %if_else26 if_then29: ; preds = %if_block28 %38 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %39 = getelementptr inbounds %Token, %Token* %38, i32 0, i32 2 - call void @"+=.461"(%String* %39, i8 34) + call void @"+=.450"(%String* %39, i8 34) br label %if_end31 if_else30: ; preds = %if_block28 @@ -14532,8 +14091,8 @@ if_else34: ; preds = %cond.end %42 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %43 = getelementptr inbounds %Token, %Token* %42, i32 0, i32 2 %44 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %45 = call i8 @"pre_++.458"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %44) - call void @"+=.461"(%String* %43, i8 %45) + %45 = call i8 @"pre_++.447"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %44) + call void @"+=.450"(%String* %43, i8 %45) br label %if_end35 if_end35: ; preds = %if_else34, %if_end38 @@ -14552,72 +14111,67 @@ cond.end: ; preds = %cond.false, %cond.t br i1 %cond.res, label %if_then33, label %if_else34 if_block36: ; preds = %if_then33 - store i32 2, i32* %tmp.this - %48 = load i32, i32* %tmp.this - %49 = call i1 @hasLessThan(%SparrowScanner* %this, i32 %48) - br i1 %49, label %if_then37, label %if_end38 + %48 = call i1 @hasLessThan(%SparrowScanner* %this, i32 2) + br i1 %48, label %if_then37, label %if_end38 if_then37: ; preds = %if_block36 - %50 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 - %51 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %49 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 + %50 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %51 = bitcast %UntypedPtr* %49 to i8** %52 = bitcast %UntypedPtr* %50 to i8** - %53 = bitcast %UntypedPtr* %51 to i8** - store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @str.11, i32 0, i32 0), i8** %52 - store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @str.11, i32 0, i32 36), i8** %53 - %54 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %tmp.this39, %StringRef %54) - call void @reportError(%SparrowScanner* %this, %String* %tmp.this39) - call void @dtor.250(%String* %tmp.this39) + store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @str.11, i32 0, i32 0), i8** %51 + store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @str.11, i32 0, i32 36), i8** %52 + %53 = load %StringRef, %StringRef* %tmp.StringRef + call void @ctor.448(%String* %tmp.this, %StringRef %53) + call void @reportError(%SparrowScanner* %this, %String* %tmp.this) + call void @dtor.239(%String* %tmp.this) ret i1 true if_end38: ; preds = %dumy_block, %if_block36 - %55 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %56 = call i8 @"pre_++.458"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %55) - %57 = call i32 @getXdigitVal(i8 %56) - %58 = mul i32 16, %57 - store i32 %58, i32* %charVal - %59 = load i32, i32* %charVal - %60 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %61 = call i8 @"pre_++.458"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %60) - %62 = call i32 @getXdigitVal(i8 %61) - %63 = add i32 %59, %62 - store i32 %63, i32* %charVal - %64 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %65 = getelementptr inbounds %Token, %Token* %64, i32 0, i32 2 - %66 = load i32, i32* %charVal - %67 = trunc i32 %66 to i8 - store i8 %67, i8* %tmp.this40 - %68 = load i8, i8* %tmp.this40 - call void @"+=.461"(%String* %65, i8 %68) + %54 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %55 = call i8 @"pre_++.447"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %54) + %56 = call i32 @getXdigitVal(i8 %55) + %57 = call i32 @_Int32_opMul(i32 16, i32 %56) + store i32 %57, i32* %charVal + %58 = load i32, i32* %charVal + %59 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %60 = call i8 @"pre_++.447"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %59) + %61 = call i32 @getXdigitVal(i8 %60) + %62 = call i32 @_Int32_opPlus(i32 %58, i32 %61) + store i32 %62, i32* %charVal + %63 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %64 = getelementptr inbounds %Token, %Token* %63, i32 0, i32 2 + %65 = load i32, i32* %charVal + %66 = trunc i32 %65 to i8 + store i8 %66, i8* %tmp.this39 + %67 = load i8, i8* %tmp.this39 + call void @"+=.450"(%String* %64, i8 %67) br label %if_end35 dumy_block: ; No predecessors! br label %if_end38 -dumy_block41: ; No predecessors! +dumy_block40: ; No predecessors! br label %if_end } ; Function Attrs: inlinehint nounwind -define internal void @"+=.461"(%String* %this, i8 %value) #4 { +define internal void @"+=.450"(%String* %this, i8 %value) #4 { %value.addr = alloca i8 store i8 %value, i8* %value.addr br label %code code: ; preds = %0 %1 = load i8, i8* %value.addr - call void @pushBack.462(%String* %this, i8 %1) + call void @pushBack.451(%String* %this, i8 %1) ret void } ; Function Attrs: inlinehint nounwind -define internal void @pushBack.462(%String* %this, i8 %value) #4 { +define internal void @pushBack.451(%String* %this, i8 %value) #4 { %value.addr = alloca i8 store i8 %value, i8* %value.addr - %t = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 + %t = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Char]" br label %code @@ -14627,45 +14181,39 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %2 = getelementptr inbounds %String, %String* %this, i32 0, i32 2 - %3 = call i1 @"==.257"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) + %3 = call i1 @"==.246"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block - store i64 2, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call i64 @capacity(%String* %this) - %6 = mul i64 %4, %5 - store i64 %6, i64* %t + %4 = call i32 @capacity(%String* %this) + %5 = call i32 @_Int32_opMul(i32 2, i32 %4) + store i32 %5, i32* %t br label %if_block1 if_end: ; preds = %if_end3, %if_block - %7 = load i8, i8* %value.addr - %8 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %9 = call i8* @value(%"RawPtr[Char]"* %8) - store i8 %7, i8* %9 + %6 = load i8, i8* %value.addr + %7 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %8 = call i8* @value(%"RawPtr[Char]"* %7) + store i8 %6, i8* %8 + %9 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %10 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %11 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %12 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %11) - store %"RawPtr[Char]" %12, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %10, %"RawPtr[Char]"* %"$tmpForRef") + %11 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %10) + store %"RawPtr[Char]" %11, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %9, %"RawPtr[Char]"* %"$tmpForRef") ret void if_block1: ; preds = %if_then - %13 = load i64, i64* %t - store i64 2, i64* %tmp.this4 - %14 = load i64, i64* %tmp.this4 - %15 = icmp slt i64 %13, %14 - br i1 %15, label %if_then2, label %if_end3 + %12 = load i32, i32* %t + %13 = call i1 @_Int32_opLT(i32 %12, i32 2) + br i1 %13, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 2, i64* %tmp.this5 - %16 = load i64, i64* %tmp.this5 - store i64 %16, i64* %t + store i32 2, i32* %t br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - %17 = load i64, i64* %t - call void @reserve(%String* %this, i64 %17) + %14 = load i32, i32* %t + call void @reserve(%String* %this, i32 %14) br label %if_end } @@ -14690,7 +14238,7 @@ cond_alt1: ; preds = %code %4 = load i32, i32* %tmp.this call void @_ass_32_8z(i32* %tmp.this1, i8 48) %5 = load i32, i32* %tmp.this1 - %6 = sub i32 %4, %5 + %6 = call i32 @_Int32_opMinus(i32 %4, i32 %5) br label %cond_end cond_alt2: ; preds = %code @@ -14698,10 +14246,10 @@ cond_alt2: ; preds = %code %8 = call i8 @toLower(i8 %7) call void @_ass_32_8z(i32* %tmp.this2, i8 %8) %9 = load i32, i32* %tmp.this2 - %10 = add i32 10, %9 + %10 = call i32 @_Int32_opPlus(i32 10, i32 %9) call void @_ass_32_8z(i32* %tmp.this3, i8 97) %11 = load i32, i32* %tmp.this3 - %12 = sub i32 %10, %11 + %12 = call i32 @_Int32_opMinus(i32 %10, i32 %11) br label %cond_end cond_end: ; preds = %cond_alt2, %cond_alt1 @@ -14742,7 +14290,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isdigit(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -14778,31 +14326,27 @@ code: ; preds = %0 %2 = getelementptr inbounds %Token, %Token* %1, i32 0, i32 2 %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %4 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3) - call void @"+=.461"(%String* %2, i8 %4) + call void @"+=.450"(%String* %2, i8 %4) %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) ret void } ; Function Attrs: inlinehint nounwind define internal void @parseStringNE(%TokenType* sret %_result, %SparrowScanner* %this) #4 { - %tmp.this = alloca i64 - %tmp.this5 = alloca %String + %tmp.this = alloca %String %tmp.StringRef = alloca %StringRef - %tmp.this6 = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 2, i64* %tmp.this - %2 = load i64, i64* %tmp.this - call void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1, i64 %2) + call void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1, i32 2) br label %while_block while_block: ; preds = %while_step, %code - %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %4 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3) - br i1 %4, label %cond.true, label %cond.false + %2 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %3 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %2) + br i1 %3, label %cond.true, label %cond.false while_body: ; preds = %cond.end call void @advanceAndCapture1(%SparrowScanner* %this) @@ -14815,56 +14359,54 @@ while_end: ; preds = %cond.end br label %if_block cond.true: ; preds = %while_block - %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %6 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) - %7 = icmp eq i8 %6, 125 - br i1 %7, label %cond.true1, label %cond.false2 + %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %5 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %4) + %6 = icmp eq i8 %5, 125 + br i1 %6, label %cond.true1, label %cond.false2 cond.false: ; preds = %while_block br label %cond.end cond.end: ; preds = %cond.false, %cond.end3 - %cond.res4 = phi i1 [ %10, %cond.end3 ], [ false, %cond.false ] + %cond.res4 = phi i1 [ %9, %cond.end3 ], [ false, %cond.false ] br i1 %cond.res4, label %while_body, label %while_end cond.true1: ; preds = %cond.true - %8 = call i8 @peekChar(%SparrowScanner* %this) - %9 = icmp eq i8 %8, 62 + %7 = call i8 @peekChar(%SparrowScanner* %this) + %8 = icmp eq i8 %7, 62 br label %cond.end3 cond.false2: ; preds = %cond.true br label %cond.end3 cond.end3: ; preds = %cond.false2, %cond.true1 - %cond.res = phi i1 [ %9, %cond.true1 ], [ false, %cond.false2 ] - %10 = xor i1 true, %cond.res + %cond.res = phi i1 [ %8, %cond.true1 ], [ false, %cond.false2 ] + %9 = xor i1 true, %cond.res br label %cond.end if_block: ; preds = %while_end - %11 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %12 = call i1 @"pre_!"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %11) - br i1 %12, label %if_then, label %if_end + %10 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %11 = call i1 @"pre_!"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %10) + br i1 %11, label %if_then, label %if_end if_then: ; preds = %if_block - %13 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 - %14 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %12 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 + %13 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %14 = bitcast %UntypedPtr* %12 to i8** %15 = bitcast %UntypedPtr* %13 to i8** - %16 = bitcast %UntypedPtr* %14 to i8** - store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.13, i32 0, i32 0), i8** %15 - store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.13, i32 0, i32 39), i8** %16 - %17 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %tmp.this5, %StringRef %17) - call void @reportError(%SparrowScanner* %this, %String* %tmp.this5) - call void @dtor.250(%String* %tmp.this5) - call void @ctor.404(%TokenType* %_result, i32 0) + store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.13, i32 0, i32 0), i8** %14 + store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @str.13, i32 0, i32 39), i8** %15 + %16 = load %StringRef, %StringRef* %tmp.StringRef + call void @ctor.448(%String* %tmp.this, %StringRef %16) + call void @reportError(%SparrowScanner* %this, %String* %tmp.this) + call void @dtor.239(%String* %tmp.this) + call void @ctor.393(%TokenType* %_result, i32 0) ret void if_end: ; preds = %dumy_block, %if_block - %18 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 2, i64* %tmp.this6 - %19 = load i64, i64* %tmp.this6 - call void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %18, i64 %19) - call void @ctor.404(%TokenType* %_result, i32 40) + %17 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %17, i32 2) + call void @ctor.393(%TokenType* %_result, i32 40) ret void dumy_block: ; No predecessors! @@ -15130,11 +14672,9 @@ define internal i1 @parseOperator(%SparrowScanner* %this) #4 { %funptr = alloca i1 (i8)* %i = alloca i32 %c = alloca i8 - %tmp.this = alloca i32 - %tmp.this4 = alloca i32 %hasOtherDot = alloca i1 - %"$tmpForRef8" = alloca %"FunctionPtr1[Bool, Char]" - %funptr9 = alloca i1 (i8)* + %"$tmpForRef7" = alloca %"FunctionPtr1[Bool, Char]" + %funptr8 = alloca i1 (i8)* br label %code code: ; preds = %0 @@ -15170,54 +14710,50 @@ if_block1: ; preds = %if_end if_then2: ; preds = %if_block1 store i32 1, i32* %i %9 = load i32, i32* %i - store i32 %9, i32* %tmp.this - %10 = load i32, i32* %tmp.this - %11 = call i8 @peekChar.464(%SparrowScanner* %this, i32 %10) - store i8 %11, i8* %c + %10 = call i8 @peekChar.453(%SparrowScanner* %this, i32 %9) + store i8 %10, i8* %c br label %while_block -if_end3: ; preds = %if_end7, %if_block1 +if_end3: ; preds = %if_end6, %if_block1 ret i1 false while_block: ; preds = %while_step, %if_then2 - %12 = load i8, i8* %c - %13 = call i1 @isOpChar(i8 %12) - br i1 %13, label %while_body, label %while_end + %11 = load i8, i8* %c + %12 = call i1 @isOpChar(i8 %11) + br i1 %12, label %while_body, label %while_end while_body: ; preds = %while_block - %14 = call i32 @"pre_++.21"(i32* %i) - store i32 %14, i32* %tmp.this4 - %15 = load i32, i32* %tmp.this4 - %16 = call i8 @peekChar.464(%SparrowScanner* %this, i32 %15) - store i8 %16, i8* %c + %13 = call i32 @"pre_++.19"(i32* %i) + %14 = call i8 @peekChar.453(%SparrowScanner* %this, i32 %13) + store i8 %14, i8* %c br label %while_step while_step: ; preds = %while_body br label %while_block while_end: ; preds = %while_block - %17 = load i8, i8* %c - %18 = icmp eq i8 %17, 46 - store i1 %18, i1* %hasOtherDot - br label %if_block5 + %15 = load i8, i8* %c + %16 = icmp eq i8 %15, 46 + store i1 %16, i1* %hasOtherDot + br label %if_block4 -if_block5: ; preds = %while_end - %19 = load i1, i1* %hasOtherDot - br i1 %19, label %if_then6, label %if_end7 +if_block4: ; preds = %while_end + %17 = load i1, i1* %hasOtherDot + br i1 %17, label %if_then5, label %if_end6 -if_then6: ; preds = %if_block5 - store i1 (i8)* @isOpCharDot, i1 (i8)** %funptr9 - %20 = bitcast i1 (i8)** %funptr9 to %"FunctionPtr1[Bool, Char]"* - %21 = load %"FunctionPtr1[Bool, Char]", %"FunctionPtr1[Bool, Char]"* %20 - store %"FunctionPtr1[Bool, Char]" %21, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef8" - call void @advanceAndCapture(%SparrowScanner* %this, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef8") +if_then5: ; preds = %if_block4 + store i1 (i8)* @isOpCharDot, i1 (i8)** %funptr8 + %18 = bitcast i1 (i8)** %funptr8 to %"FunctionPtr1[Bool, Char]"* + %19 = load %"FunctionPtr1[Bool, Char]", %"FunctionPtr1[Bool, Char]"* %18 + store %"FunctionPtr1[Bool, Char]" %19, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef7" + call void @advanceAndCapture(%SparrowScanner* %this, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef7") ret i1 true -if_end7: ; preds = %dumy_block10, %if_block5 +if_end6: ; preds = %dumy_block9, %if_block4 br label %if_end3 -dumy_block10: ; No predecessors! - br label %if_end7 +dumy_block9: ; No predecessors! + br label %if_end6 } ; Function Attrs: inlinehint nounwind @@ -15229,7 +14765,7 @@ code: ; preds = %0 while_block: ; preds = %while_step, %code %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %2 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) + %2 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) br i1 %2, label %cond.true, label %cond.false while_body: ; preds = %cond.end @@ -15237,12 +14773,12 @@ while_body: ; preds = %cond.end %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 2 %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %6 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) - call void @"+=.461"(%String* %4, i8 %6) + call void @"+=.450"(%String* %4, i8 %6) br label %while_step while_step: ; preds = %while_body %7 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %7) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %7) br label %while_block while_end: ; preds = %cond.end @@ -15251,7 +14787,7 @@ while_end: ; preds = %cond.end cond.true: ; preds = %while_block %8 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %9 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %8) - %10 = call i1 @"().463"(%"FunctionPtr1[Bool, Char]"* %pred, i8 %9) + %10 = call i1 @"().452"(%"FunctionPtr1[Bool, Char]"* %pred, i8 %9) br label %cond.end cond.false: ; preds = %while_block @@ -15263,7 +14799,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: inlinehint nounwind -define internal i1 @"().463"(%"FunctionPtr1[Bool, Char]"* %this, i8 %p1) #4 { +define internal i1 @"().452"(%"FunctionPtr1[Bool, Char]"* %this, i8 %p1) #4 { %p1.addr = alloca i8 store i8 %p1, i8* %p1.addr br label %code @@ -15277,7 +14813,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i8 @peekChar.464(%SparrowScanner* %this, i32 %n) #4 { +define internal i8 @peekChar.453(%SparrowScanner* %this, i32 %n) #4 { %n.addr = alloca i32 store i32 %n, i32* %n.addr br label %code @@ -15302,7 +14838,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isalpha(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -15345,15 +14881,15 @@ code: ; preds = %0 %2 = getelementptr inbounds %Token, %Token* %1, i32 0, i32 2 %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %4 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3) - call void @"+=.461"(%String* %2, i8 %4) + call void @"+=.450"(%String* %2, i8 %4) %5 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %5) store i1 true, i1* %firstDot br label %while_block while_block: ; preds = %while_step, %code %6 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %7 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %6) + %7 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %6) br i1 %7, label %while_body, label %while_end while_body: ; preds = %while_block @@ -15364,14 +14900,14 @@ while_body: ; preds = %while_block while_step: ; preds = %if_end7 %10 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %10) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %10) br label %while_block while_end: ; preds = %if_then, %while_block %11 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %12 = getelementptr inbounds %Token, %Token* %11, i32 0, i32 2 %13 = call %StringRef @asStringRef(%String* %12) - call void @ctor.59(%StringRef* %data, %StringRef %13) + call void @ctor.49(%StringRef* %data, %StringRef %13) br label %if_block16 if_block: ; preds = %while_body @@ -15387,7 +14923,7 @@ if_end: ; preds = %dumy_block, %cond.e %17 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 %18 = getelementptr inbounds %Token, %Token* %17, i32 0, i32 2 %19 = load i8, i8* %ch - call void @"+=.461"(%String* %18, i8 %19) + call void @"+=.450"(%String* %18, i8 %19) br label %if_block5 cond.true: ; preds = %cond.end3 @@ -15425,7 +14961,7 @@ if_block5: ; preds = %if_end if_then6: ; preds = %cond.end10 %27 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %27) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %27) br label %if_block12 if_end7: ; preds = %if_end14, %cond.end10 @@ -15448,7 +14984,7 @@ if_block12: ; preds = %if_then6 br i1 %30, label %if_then13, label %if_end14 if_then13: ; preds = %if_block12 - call void @ctor.404(%TokenType* %_result, i32 37) + call void @ctor.393(%TokenType* %_result, i32 37) ret void if_end14: ; preds = %dumy_block15, %if_block12 @@ -15470,9 +15006,9 @@ if_block16: ; preds = %while_end br i1 %37, label %if_then17, label %if_else if_then17: ; preds = %if_block16 - call void @ctor.404(%TokenType* %_result, i32 11) + call void @ctor.393(%TokenType* %_result, i32 11) %38 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %38) + call void @dtor.51(%StringRef %38) ret void if_else: ; preds = %if_block16 @@ -15480,7 +15016,7 @@ if_else: ; preds = %if_block16 if_end18: ; preds = %if_end23, %dumy_block19 %39 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %39) + call void @dtor.51(%StringRef %39) ret void dumy_block19: ; No predecessors! @@ -15499,9 +15035,9 @@ if_block20: ; preds = %if_else br i1 %46, label %if_then21, label %if_else22 if_then21: ; preds = %if_block20 - call void @ctor.404(%TokenType* %_result, i32 12) + call void @ctor.393(%TokenType* %_result, i32 12) %47 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %47) + call void @dtor.51(%StringRef %47) ret void if_else22: ; preds = %if_block20 @@ -15526,9 +15062,9 @@ if_block26: ; preds = %if_else22 br i1 %54, label %if_then27, label %if_else28 if_then27: ; preds = %if_block26 - call void @ctor.404(%TokenType* %_result, i32 4) + call void @ctor.393(%TokenType* %_result, i32 4) %55 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %55) + call void @dtor.51(%StringRef %55) ret void if_else28: ; preds = %if_block26 @@ -15553,9 +15089,9 @@ if_block32: ; preds = %if_else28 br i1 %62, label %if_then33, label %if_else34 if_then33: ; preds = %if_block32 - call void @ctor.404(%TokenType* %_result, i32 13) + call void @ctor.393(%TokenType* %_result, i32 13) %63 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %63) + call void @dtor.51(%StringRef %63) ret void if_else34: ; preds = %if_block32 @@ -15580,9 +15116,9 @@ if_block38: ; preds = %if_else34 br i1 %70, label %if_then39, label %if_else40 if_then39: ; preds = %if_block38 - call void @ctor.404(%TokenType* %_result, i32 5) + call void @ctor.393(%TokenType* %_result, i32 5) %71 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %71) + call void @dtor.51(%StringRef %71) ret void if_else40: ; preds = %if_block38 @@ -15607,9 +15143,9 @@ if_block44: ; preds = %if_else40 br i1 %78, label %if_then45, label %if_else46 if_then45: ; preds = %if_block44 - call void @ctor.404(%TokenType* %_result, i32 6) + call void @ctor.393(%TokenType* %_result, i32 6) %79 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %79) + call void @dtor.51(%StringRef %79) ret void if_else46: ; preds = %if_block44 @@ -15634,9 +15170,9 @@ if_block50: ; preds = %if_else46 br i1 %86, label %if_then51, label %if_else52 if_then51: ; preds = %if_block50 - call void @ctor.404(%TokenType* %_result, i32 16) + call void @ctor.393(%TokenType* %_result, i32 16) %87 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %87) + call void @dtor.51(%StringRef %87) ret void if_else52: ; preds = %if_block50 @@ -15661,9 +15197,9 @@ if_block56: ; preds = %if_else52 br i1 %94, label %if_then57, label %if_else58 if_then57: ; preds = %if_block56 - call void @ctor.404(%TokenType* %_result, i32 24) + call void @ctor.393(%TokenType* %_result, i32 24) %95 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %95) + call void @dtor.51(%StringRef %95) ret void if_else58: ; preds = %if_block56 @@ -15688,9 +15224,9 @@ if_block62: ; preds = %if_else58 br i1 %102, label %if_then63, label %if_else64 if_then63: ; preds = %if_block62 - call void @ctor.404(%TokenType* %_result, i32 21) + call void @ctor.393(%TokenType* %_result, i32 21) %103 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %103) + call void @dtor.51(%StringRef %103) ret void if_else64: ; preds = %if_block62 @@ -15715,9 +15251,9 @@ if_block68: ; preds = %if_else64 br i1 %110, label %if_then69, label %if_else70 if_then69: ; preds = %if_block68 - call void @ctor.404(%TokenType* %_result, i32 14) + call void @ctor.393(%TokenType* %_result, i32 14) %111 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %111) + call void @dtor.51(%StringRef %111) ret void if_else70: ; preds = %if_block68 @@ -15742,9 +15278,9 @@ if_block74: ; preds = %if_else70 br i1 %118, label %if_then75, label %if_else76 if_then75: ; preds = %if_block74 - call void @ctor.404(%TokenType* %_result, i32 15) + call void @ctor.393(%TokenType* %_result, i32 15) %119 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %119) + call void @dtor.51(%StringRef %119) ret void if_else76: ; preds = %if_block74 @@ -15769,9 +15305,9 @@ if_block80: ; preds = %if_else76 br i1 %126, label %if_then81, label %if_else82 if_then81: ; preds = %if_block80 - call void @ctor.404(%TokenType* %_result, i32 3) + call void @ctor.393(%TokenType* %_result, i32 3) %127 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %127) + call void @dtor.51(%StringRef %127) ret void if_else82: ; preds = %if_block80 @@ -15796,9 +15332,9 @@ if_block86: ; preds = %if_else82 br i1 %134, label %if_then87, label %if_else88 if_then87: ; preds = %if_block86 - call void @ctor.404(%TokenType* %_result, i32 7) + call void @ctor.393(%TokenType* %_result, i32 7) %135 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %135) + call void @dtor.51(%StringRef %135) ret void if_else88: ; preds = %if_block86 @@ -15823,9 +15359,9 @@ if_block92: ; preds = %if_else88 br i1 %142, label %if_then93, label %if_else94 if_then93: ; preds = %if_block92 - call void @ctor.404(%TokenType* %_result, i32 2) + call void @ctor.393(%TokenType* %_result, i32 2) %143 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %143) + call void @dtor.51(%StringRef %143) ret void if_else94: ; preds = %if_block92 @@ -15850,9 +15386,9 @@ if_block98: ; preds = %if_else94 br i1 %150, label %if_then99, label %if_else100 if_then99: ; preds = %if_block98 - call void @ctor.404(%TokenType* %_result, i32 22) + call void @ctor.393(%TokenType* %_result, i32 22) %151 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %151) + call void @dtor.51(%StringRef %151) ret void if_else100: ; preds = %if_block98 @@ -15877,9 +15413,9 @@ if_block104: ; preds = %if_else100 br i1 %158, label %if_then105, label %if_else106 if_then105: ; preds = %if_block104 - call void @ctor.404(%TokenType* %_result, i32 8) + call void @ctor.393(%TokenType* %_result, i32 8) %159 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %159) + call void @dtor.51(%StringRef %159) ret void if_else106: ; preds = %if_block104 @@ -15904,9 +15440,9 @@ if_block110: ; preds = %if_else106 br i1 %166, label %if_then111, label %if_else112 if_then111: ; preds = %if_block110 - call void @ctor.404(%TokenType* %_result, i32 17) + call void @ctor.393(%TokenType* %_result, i32 17) %167 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %167) + call void @dtor.51(%StringRef %167) ret void if_else112: ; preds = %if_block110 @@ -15931,9 +15467,9 @@ if_block116: ; preds = %if_else112 br i1 %174, label %if_then117, label %if_else118 if_then117: ; preds = %if_block116 - call void @ctor.404(%TokenType* %_result, i32 18) + call void @ctor.393(%TokenType* %_result, i32 18) %175 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %175) + call void @dtor.51(%StringRef %175) ret void if_else118: ; preds = %if_block116 @@ -15958,9 +15494,9 @@ if_block122: ; preds = %if_else118 br i1 %182, label %if_then123, label %if_else124 if_then123: ; preds = %if_block122 - call void @ctor.404(%TokenType* %_result, i32 23) + call void @ctor.393(%TokenType* %_result, i32 23) %183 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %183) + call void @dtor.51(%StringRef %183) ret void if_else124: ; preds = %if_block122 @@ -15985,9 +15521,9 @@ if_block128: ; preds = %if_else124 br i1 %190, label %if_then129, label %if_else130 if_then129: ; preds = %if_block128 - call void @ctor.404(%TokenType* %_result, i32 19) + call void @ctor.393(%TokenType* %_result, i32 19) %191 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %191) + call void @dtor.51(%StringRef %191) ret void if_else130: ; preds = %if_block128 @@ -16012,9 +15548,9 @@ if_block134: ; preds = %if_else130 br i1 %198, label %if_then135, label %if_else136 if_then135: ; preds = %if_block134 - call void @ctor.404(%TokenType* %_result, i32 9) + call void @ctor.393(%TokenType* %_result, i32 9) %199 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %199) + call void @dtor.51(%StringRef %199) ret void if_else136: ; preds = %if_block134 @@ -16039,9 +15575,9 @@ if_block140: ; preds = %if_else136 br i1 %206, label %if_then141, label %if_else142 if_then141: ; preds = %if_block140 - call void @ctor.404(%TokenType* %_result, i32 10) + call void @ctor.393(%TokenType* %_result, i32 10) %207 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %207) + call void @dtor.51(%StringRef %207) ret void if_else142: ; preds = %if_block140 @@ -16066,15 +15602,15 @@ if_block146: ; preds = %if_else142 br i1 %214, label %if_then147, label %if_else148 if_then147: ; preds = %if_block146 - call void @ctor.404(%TokenType* %_result, i32 20) + call void @ctor.393(%TokenType* %_result, i32 20) %215 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %215) + call void @dtor.51(%StringRef %215) ret void if_else148: ; preds = %if_block146 - call void @ctor.404(%TokenType* %_result, i32 37) + call void @ctor.393(%TokenType* %_result, i32 37) %216 = load %StringRef, %StringRef* %data - call void @dtor.61(%StringRef %216) + call void @dtor.51(%StringRef %216) ret void if_end149: ; preds = %dumy_block152, %dumy_block151 @@ -16096,27 +15632,22 @@ define void @parseNumeric(%TokenType* sret %_result, %SparrowScanner* %this) #5 %ch = alloca i8 %ch2 = alloca i8 %ch3 = alloca i8 - %tmp.this = alloca i32 - %tmp.this1 = alloca i64 - %tmp.this2 = alloca i64 - %tmp.this11 = alloca i64 - %tmp.this12 = alloca i64 - %tmp.this21 = alloca i64 - %tmp.this22 = alloca i64 - %tmp.this23 = alloca i64 %"$tmpForRef" = alloca %"FunctionPtr1[Bool, Char]" %funptr = alloca i1 (i8)* %"$tmpForRef55" = alloca %"FunctionPtr1[Bool, Char]" %funptr56 = alloca i1 (i8)* - %tmp.this70 = alloca %String + %tmp.this = alloca %String %tmp.StringRef = alloca %StringRef - %tmp.this91 = alloca i8 + %tmp.this90 = alloca i8 + %"$tmpForRef91" = alloca %TokenType %tmp.this92 = alloca %TokenType %tmp.this93 = alloca %TokenType - %tmp.this105 = alloca %TokenType + %"$tmpForRef102" = alloca %TokenType %tmp.this106 = alloca %TokenType - %tmp.this118 = alloca %TokenType - %tmp.this119 = alloca %TokenType + %tmp.this107 = alloca %TokenType + %"$tmpForRef116" = alloca %TokenType + %tmp.this120 = alloca %TokenType + %tmp.this121 = alloca %TokenType br label %code code: ; preds = %0 @@ -16130,289 +15661,300 @@ code: ; preds = %0 %3 = call i8 @peekChar(%SparrowScanner* %this) %4 = call i8 @toLower(i8 %3) store i8 %4, i8* %ch2 - store i32 2, i32* %tmp.this - %5 = load i32, i32* %tmp.this - %6 = call i8 @peekChar.464(%SparrowScanner* %this, i32 %5) - %7 = call i8 @toLower(i8 %6) - store i8 %7, i8* %ch3 + %5 = call i8 @peekChar.453(%SparrowScanner* %this, i32 2) + %6 = call i8 @toLower(i8 %5) + store i8 %6, i8* %ch3 br label %if_block if_block: ; preds = %code - %8 = load i8, i8* %ch - %9 = icmp eq i8 %8, 48 - br i1 %9, label %cond.true, label %cond.false + %7 = load i8, i8* %ch + %8 = icmp eq i8 %7, 48 + br i1 %8, label %cond.true, label %cond.false if_then: ; preds = %cond.end + %9 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %9, i32 2) %10 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 2, i64* %tmp.this1 - %11 = load i64, i64* %tmp.this1 - call void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %10, i64 %11) - %12 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 16, i64* %tmp.this2 - %13 = load i64, i64* %tmp.this2 + %11 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %12 = getelementptr inbounds %Token, %Token* %11, i32 0, i32 2 + %13 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %10, i32 16, %String* %12) %14 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %15 = getelementptr inbounds %Token, %Token* %14, i32 0, i32 2 - %16 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %12, i64 %13, %String* %15) - %17 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %18 = getelementptr inbounds %Token, %Token* %17, i32 0, i32 3 - store i64 %16, i64* %18 + %15 = getelementptr inbounds %Token, %Token* %14, i32 0, i32 3 + store i64 %13, i64* %15 br label %if_end if_else: ; preds = %cond.end - br label %if_block3 + br label %if_block1 -if_end: ; preds = %if_end6, %if_then +if_end: ; preds = %if_end4, %if_then br label %if_block67 cond.true: ; preds = %if_block - %19 = load i8, i8* %ch2 - %20 = icmp eq i8 %19, 120 + %16 = load i8, i8* %ch2 + %17 = icmp eq i8 %16, 120 br label %cond.end cond.false: ; preds = %if_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %20, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %17, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %if_then, label %if_else -if_block3: ; preds = %if_else - %21 = load i8, i8* %ch - %22 = icmp eq i8 %21, 48 - br i1 %22, label %cond.true7, label %cond.false8 +if_block1: ; preds = %if_else + %18 = load i8, i8* %ch + %19 = icmp eq i8 %18, 48 + br i1 %19, label %cond.true5, label %cond.false6 -if_then4: ; preds = %cond.end9 - %23 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 2, i64* %tmp.this11 - %24 = load i64, i64* %tmp.this11 - call void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %23, i64 %24) - %25 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 2, i64* %tmp.this12 - %26 = load i64, i64* %tmp.this12 - %27 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %28 = getelementptr inbounds %Token, %Token* %27, i32 0, i32 2 - %29 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %25, i64 %26, %String* %28) - %30 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %31 = getelementptr inbounds %Token, %Token* %30, i32 0, i32 3 - store i64 %29, i64* %31 - br label %if_end6 +if_then2: ; preds = %cond.end7 + %20 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %20, i32 2) + %21 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %22 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %23 = getelementptr inbounds %Token, %Token* %22, i32 0, i32 2 + %24 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %21, i32 2, %String* %23) + %25 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %26 = getelementptr inbounds %Token, %Token* %25, i32 0, i32 3 + store i64 %24, i64* %26 + br label %if_end4 -if_else5: ; preds = %cond.end9 - br label %if_block13 +if_else3: ; preds = %cond.end7 + br label %if_block9 -if_end6: ; preds = %if_end16, %if_then4 +if_end4: ; preds = %if_end12, %if_then2 br label %if_end -cond.true7: ; preds = %if_block3 - %32 = load i8, i8* %ch2 - %33 = icmp eq i8 %32, 98 - br label %cond.end9 +cond.true5: ; preds = %if_block1 + %27 = load i8, i8* %ch2 + %28 = icmp eq i8 %27, 98 + br label %cond.end7 -cond.false8: ; preds = %if_block3 - br label %cond.end9 +cond.false6: ; preds = %if_block1 + br label %cond.end7 -cond.end9: ; preds = %cond.false8, %cond.true7 - %cond.res10 = phi i1 [ %33, %cond.true7 ], [ false, %cond.false8 ] - br i1 %cond.res10, label %if_then4, label %if_else5 +cond.end7: ; preds = %cond.false6, %cond.true5 + %cond.res8 = phi i1 [ %28, %cond.true5 ], [ false, %cond.false6 ] + br i1 %cond.res8, label %if_then2, label %if_else3 -if_block13: ; preds = %if_else5 - %34 = load i8, i8* %ch - %35 = icmp eq i8 %34, 48 - br i1 %35, label %cond.true17, label %cond.false18 +if_block9: ; preds = %if_else3 + %29 = load i8, i8* %ch + %30 = icmp eq i8 %29, 48 + br i1 %30, label %cond.true13, label %cond.false14 -if_then14: ; preds = %cond.end19 - %36 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 1, i64* %tmp.this21 - %37 = load i64, i64* %tmp.this21 - call void @advance.457(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %36, i64 %37) +if_then10: ; preds = %cond.end15 + %31 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @advance.446(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %31, i32 2) + %32 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %33 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %34 = getelementptr inbounds %Token, %Token* %33, i32 0, i32 2 + %35 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %32, i32 8, %String* %34) + %36 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %37 = getelementptr inbounds %Token, %Token* %36, i32 0, i32 3 + store i64 %35, i64* %37 + br label %if_end12 + +if_else11: ; preds = %cond.end15 %38 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 8, i64* %tmp.this22 - %39 = load i64, i64* %tmp.this22 - %40 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %41 = getelementptr inbounds %Token, %Token* %40, i32 0, i32 2 - %42 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %38, i64 %39, %String* %41) - %43 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %44 = getelementptr inbounds %Token, %Token* %43, i32 0, i32 3 - store i64 %42, i64* %44 - br label %if_end16 - -if_else15: ; preds = %cond.end19 - %45 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - store i64 10, i64* %tmp.this23 - %46 = load i64, i64* %tmp.this23 - %47 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %48 = getelementptr inbounds %Token, %Token* %47, i32 0, i32 2 - %49 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %45, i64 %46, %String* %48) - %50 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %51 = getelementptr inbounds %Token, %Token* %50, i32 0, i32 3 - store i64 %49, i64* %51 - br label %if_block24 + %39 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %40 = getelementptr inbounds %Token, %Token* %39, i32 0, i32 2 + %41 = call i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %38, i32 10, %String* %40) + %42 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %43 = getelementptr inbounds %Token, %Token* %42, i32 0, i32 3 + store i64 %41, i64* %43 + br label %if_block17 -if_end16: ; preds = %if_end26, %if_then14 - br label %if_end6 +if_end12: ; preds = %if_end19, %if_then10 + br label %if_end4 -cond.true17: ; preds = %if_block13 - %52 = load i8, i8* %ch2 - %53 = icmp eq i8 %52, 111 - br label %cond.end19 +cond.true13: ; preds = %if_block9 + %44 = load i8, i8* %ch2 + %45 = icmp eq i8 %44, 111 + br label %cond.end15 -cond.false18: ; preds = %if_block13 - br label %cond.end19 +cond.false14: ; preds = %if_block9 + br label %cond.end15 -cond.end19: ; preds = %cond.false18, %cond.true17 - %cond.res20 = phi i1 [ %53, %cond.true17 ], [ false, %cond.false18 ] - br i1 %cond.res20, label %if_then14, label %if_else15 +cond.end15: ; preds = %cond.false14, %cond.true13 + %cond.res16 = phi i1 [ %45, %cond.true13 ], [ false, %cond.false14 ] + br i1 %cond.res16, label %if_then10, label %if_else11 -if_block24: ; preds = %if_else15 - %54 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %55 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %54) - br i1 %55, label %if_then25, label %if_end26 +if_block17: ; preds = %if_else11 + %46 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %47 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %46) + br i1 %47, label %if_then18, label %if_end19 -if_then25: ; preds = %if_block24 - %56 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %57 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %56) - %58 = call i8 @toLower(i8 %57) - store i8 %58, i8* %ch - br label %if_block27 +if_then18: ; preds = %if_block17 + %48 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %49 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %48) + %50 = call i8 @toLower(i8 %49) + store i8 %50, i8* %ch + br label %if_block20 -if_end26: ; preds = %if_end29, %if_block24 - br label %if_end16 +if_end19: ; preds = %if_end22, %if_block17 + br label %if_end12 -if_block27: ; preds = %if_then25 - %59 = load i8, i8* %ch - %60 = icmp eq i8 %59, 46 - br i1 %60, label %cond.true39, label %cond.false40 +if_block20: ; preds = %if_then18 + %51 = load i8, i8* %ch + %52 = icmp eq i8 %51, 46 + br i1 %52, label %cond.true32, label %cond.false33 -if_then28: ; preds = %cond.end32 +if_then21: ; preds = %cond.end25 store i1 true, i1* %isFloating - br label %if_block46 + br label %if_block39 -if_end29: ; preds = %if_end59, %cond.end32 - br label %if_end26 +if_end22: ; preds = %if_end59, %cond.end25 + br label %if_end19 -cond.true30: ; preds = %cond.end35 - br label %cond.end32 +cond.true23: ; preds = %cond.end28 + br label %cond.end25 -cond.false31: ; preds = %cond.end35 - %61 = load i8, i8* %ch - %62 = icmp eq i8 %61, 100 - br label %cond.end32 +cond.false24: ; preds = %cond.end28 + %53 = load i8, i8* %ch + %54 = icmp eq i8 %53, 100 + br label %cond.end25 -cond.end32: ; preds = %cond.false31, %cond.true30 - %cond.res45 = phi i1 [ true, %cond.true30 ], [ %62, %cond.false31 ] - br i1 %cond.res45, label %if_then28, label %if_end29 +cond.end25: ; preds = %cond.false24, %cond.true23 + %cond.res38 = phi i1 [ true, %cond.true23 ], [ %54, %cond.false24 ] + br i1 %cond.res38, label %if_then21, label %if_end22 -cond.true33: ; preds = %cond.end38 - br label %cond.end35 +cond.true26: ; preds = %cond.end31 + br label %cond.end28 -cond.false34: ; preds = %cond.end38 - %63 = load i8, i8* %ch - %64 = icmp eq i8 %63, 102 - br label %cond.end35 +cond.false27: ; preds = %cond.end31 + %55 = load i8, i8* %ch + %56 = icmp eq i8 %55, 102 + br label %cond.end28 -cond.end35: ; preds = %cond.false34, %cond.true33 - %cond.res44 = phi i1 [ true, %cond.true33 ], [ %64, %cond.false34 ] - br i1 %cond.res44, label %cond.true30, label %cond.false31 +cond.end28: ; preds = %cond.false27, %cond.true26 + %cond.res37 = phi i1 [ true, %cond.true26 ], [ %56, %cond.false27 ] + br i1 %cond.res37, label %cond.true23, label %cond.false24 -cond.true36: ; preds = %cond.end41 - br label %cond.end38 +cond.true29: ; preds = %cond.end34 + br label %cond.end31 -cond.false37: ; preds = %cond.end41 - %65 = load i8, i8* %ch - %66 = icmp eq i8 %65, 101 - br label %cond.end38 +cond.false30: ; preds = %cond.end34 + %57 = load i8, i8* %ch + %58 = icmp eq i8 %57, 101 + br label %cond.end31 -cond.end38: ; preds = %cond.false37, %cond.true36 - %cond.res43 = phi i1 [ true, %cond.true36 ], [ %66, %cond.false37 ] - br i1 %cond.res43, label %cond.true33, label %cond.false34 +cond.end31: ; preds = %cond.false30, %cond.true29 + %cond.res36 = phi i1 [ true, %cond.true29 ], [ %58, %cond.false30 ] + br i1 %cond.res36, label %cond.true26, label %cond.false27 -cond.true39: ; preds = %if_block27 - %67 = call i8 @peekChar(%SparrowScanner* %this) - %68 = call i1 @isOpCharDot(i8 %67) - %69 = xor i1 true, %68 - br label %cond.end41 +cond.true32: ; preds = %if_block20 + %59 = call i8 @peekChar(%SparrowScanner* %this) + %60 = call i1 @isOpCharDot(i8 %59) + %61 = xor i1 true, %60 + br label %cond.end34 -cond.false40: ; preds = %if_block27 - br label %cond.end41 +cond.false33: ; preds = %if_block20 + br label %cond.end34 -cond.end41: ; preds = %cond.false40, %cond.true39 - %cond.res42 = phi i1 [ %69, %cond.true39 ], [ false, %cond.false40 ] - br i1 %cond.res42, label %cond.true36, label %cond.false37 +cond.end34: ; preds = %cond.false33, %cond.true32 + %cond.res35 = phi i1 [ %61, %cond.true32 ], [ false, %cond.false33 ] + br i1 %cond.res35, label %cond.true29, label %cond.false30 -if_block46: ; preds = %if_then28 - %70 = load i8, i8* %ch - %71 = icmp eq i8 %70, 46 - br i1 %71, label %if_then47, label %if_end48 +if_block39: ; preds = %if_then21 + %62 = load i8, i8* %ch + %63 = icmp eq i8 %62, 46 + br i1 %63, label %if_then40, label %if_end41 -if_then47: ; preds = %if_block46 +if_then40: ; preds = %if_block39 call void @advanceAndCapture1(%SparrowScanner* %this) store i1 (i8)* @isDigit, i1 (i8)** %funptr - %72 = bitcast i1 (i8)** %funptr to %"FunctionPtr1[Bool, Char]"* - %73 = load %"FunctionPtr1[Bool, Char]", %"FunctionPtr1[Bool, Char]"* %72 - store %"FunctionPtr1[Bool, Char]" %73, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef" + %64 = bitcast i1 (i8)** %funptr to %"FunctionPtr1[Bool, Char]"* + %65 = load %"FunctionPtr1[Bool, Char]", %"FunctionPtr1[Bool, Char]"* %64 + store %"FunctionPtr1[Bool, Char]" %65, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef" call void @advanceAndCaptureDigit(%SparrowScanner* %this, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef") - br label %if_end48 + br label %if_end41 -if_end48: ; preds = %if_then47, %if_block46 - br label %if_block49 +if_end41: ; preds = %if_then40, %if_block39 + br label %if_block42 -if_block49: ; preds = %if_end48 - %74 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %75 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %74) - br i1 %75, label %if_then50, label %if_end51 +if_block42: ; preds = %if_end41 + %66 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %67 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %66) + br i1 %67, label %if_then43, label %if_end44 -if_then50: ; preds = %if_block49 - %76 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %77 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %76) - %78 = call i8 @toLower(i8 %77) - store i8 %78, i8* %ch - br label %if_block52 +if_then43: ; preds = %if_block42 + %68 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %69 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %68) + %70 = call i8 @toLower(i8 %69) + store i8 %70, i8* %ch + br label %if_block45 -if_end51: ; preds = %if_end54, %if_block49 +if_end44: ; preds = %if_end47, %if_block42 br label %if_block57 -if_block52: ; preds = %if_then50 - %79 = load i8, i8* %ch - %80 = icmp eq i8 %79, 101 - br i1 %80, label %if_then53, label %if_end54 +if_block45: ; preds = %if_then43 + %71 = load i8, i8* %ch + %72 = icmp eq i8 %71, 101 + br i1 %72, label %if_then46, label %if_end47 + +if_then46: ; preds = %if_block45 + call void @advanceAndCapture1(%SparrowScanner* %this) + %73 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %74 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %73) + store i8 %74, i8* %ch + br label %if_block48 -if_then53: ; preds = %if_block52 +if_end47: ; preds = %if_end50, %if_block45 + br label %if_end44 + +if_block48: ; preds = %if_then46 + %75 = load i8, i8* %ch + %76 = icmp eq i8 %75, 43 + br i1 %76, label %cond.true51, label %cond.false52 + +if_then49: ; preds = %cond.end53 call void @advanceAndCapture1(%SparrowScanner* %this) + br label %if_end50 + +if_end50: ; preds = %if_then49, %cond.end53 store i1 (i8)* @isDigit, i1 (i8)** %funptr56 - %81 = bitcast i1 (i8)** %funptr56 to %"FunctionPtr1[Bool, Char]"* - %82 = load %"FunctionPtr1[Bool, Char]", %"FunctionPtr1[Bool, Char]"* %81 - store %"FunctionPtr1[Bool, Char]" %82, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef55" + %77 = bitcast i1 (i8)** %funptr56 to %"FunctionPtr1[Bool, Char]"* + %78 = load %"FunctionPtr1[Bool, Char]", %"FunctionPtr1[Bool, Char]"* %77 + store %"FunctionPtr1[Bool, Char]" %78, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef55" call void @advanceAndCaptureDigit(%SparrowScanner* %this, %"FunctionPtr1[Bool, Char]"* %"$tmpForRef55") - br label %if_end54 + br label %if_end47 -if_end54: ; preds = %if_then53, %if_block52 - br label %if_end51 +cond.true51: ; preds = %if_block48 + br label %cond.end53 -if_block57: ; preds = %if_end51 - %83 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %84 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %83) - br i1 %84, label %if_then58, label %if_end59 +cond.false52: ; preds = %if_block48 + %79 = load i8, i8* %ch + %80 = icmp eq i8 %79, 45 + br label %cond.end53 + +cond.end53: ; preds = %cond.false52, %cond.true51 + %cond.res54 = phi i1 [ true, %cond.true51 ], [ %80, %cond.false52 ] + br i1 %cond.res54, label %if_then49, label %if_end50 + +if_block57: ; preds = %if_end44 + %81 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %82 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %81) + br i1 %82, label %if_then58, label %if_end59 if_then58: ; preds = %if_block57 store i1 true, i1* %isLong - %85 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %86 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %85) - %87 = call i8 @toLower(i8 %86) - store i8 %87, i8* %ch + %83 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %84 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %83) + %85 = call i8 @toLower(i8 %84) + store i8 %85, i8* %ch br label %if_block60 if_end59: ; preds = %if_end63, %if_block57 - br label %if_end29 + br label %if_end22 if_block60: ; preds = %if_then58 - %88 = load i8, i8* %ch - %89 = icmp eq i8 %88, 102 - br i1 %89, label %if_then61, label %if_else62 + %86 = load i8, i8* %ch + %87 = icmp eq i8 %86, 102 + br i1 %87, label %if_then61, label %if_else62 if_then61: ; preds = %if_block60 store i1 false, i1* %isLong - %90 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %90) + %88 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %88) br label %if_end63 if_else62: ; preds = %if_block60 @@ -16422,149 +15964,152 @@ if_end63: ; preds = %if_end66, %if_then6 br label %if_end59 if_block64: ; preds = %if_else62 - %91 = load i8, i8* %ch - %92 = icmp eq i8 %91, 100 - br i1 %92, label %if_then65, label %if_end66 + %89 = load i8, i8* %ch + %90 = icmp eq i8 %89, 100 + br i1 %90, label %if_then65, label %if_end66 if_then65: ; preds = %if_block64 - %93 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %93) + %91 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %91) br label %if_end66 if_end66: ; preds = %if_then65, %if_block64 br label %if_end63 if_block67: ; preds = %if_end - %94 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %95 = getelementptr inbounds %Token, %Token* %94, i32 0, i32 2 - %96 = call i1 @isEmpty.384(%String* %95) - br i1 %96, label %if_then68, label %if_end69 + %92 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %93 = getelementptr inbounds %Token, %Token* %92, i32 0, i32 2 + %94 = call i1 @isEmpty.373(%String* %93) + br i1 %94, label %if_then68, label %if_end69 if_then68: ; preds = %if_block67 - %97 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 - %98 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 - %99 = bitcast %UntypedPtr* %97 to i8** - %100 = bitcast %UntypedPtr* %98 to i8** - store i8* getelementptr inbounds ([24 x i8], [24 x i8]* @str.37, i32 0, i32 0), i8** %99 - store i8* getelementptr inbounds ([24 x i8], [24 x i8]* @str.37, i32 0, i32 23), i8** %100 - %101 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %tmp.this70, %StringRef %101) - call void @reportError(%SparrowScanner* %this, %String* %tmp.this70) - call void @dtor.250(%String* %tmp.this70) - call void @ctor.404(%TokenType* %_result, i32 0) + %95 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 + %96 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %97 = bitcast %UntypedPtr* %95 to i8** + %98 = bitcast %UntypedPtr* %96 to i8** + store i8* getelementptr inbounds ([24 x i8], [24 x i8]* @str.37, i32 0, i32 0), i8** %97 + store i8* getelementptr inbounds ([24 x i8], [24 x i8]* @str.37, i32 0, i32 23), i8** %98 + %99 = load %StringRef, %StringRef* %tmp.StringRef + call void @ctor.448(%String* %tmp.this, %StringRef %99) + call void @reportError(%SparrowScanner* %this, %String* %tmp.this) + call void @dtor.239(%String* %tmp.this) + call void @ctor.393(%TokenType* %_result, i32 0) ret void if_end69: ; preds = %dumy_block, %if_block67 - br label %if_block71 + br label %if_block70 dumy_block: ; No predecessors! br label %if_end69 -if_block71: ; preds = %if_end69 - %102 = load i1, i1* %isFloating - %103 = xor i1 true, %102 - br i1 %103, label %if_then72, label %if_end73 +if_block70: ; preds = %if_end69 + %100 = load i1, i1* %isFloating + %101 = xor i1 true, %100 + br i1 %101, label %if_then71, label %if_end72 -if_then72: ; preds = %if_block71 - br label %if_block74 +if_then71: ; preds = %if_block70 + br label %if_block73 -if_end73: ; preds = %if_end83, %if_block71 - br label %if_block88 +if_end72: ; preds = %if_end82, %if_block70 + br label %if_block87 -if_block74: ; preds = %if_then72 - %104 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %105 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %104) - br i1 %105, label %cond.true77, label %cond.false78 +if_block73: ; preds = %if_then71 + %102 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %103 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %102) + br i1 %103, label %cond.true76, label %cond.false77 -if_then75: ; preds = %cond.end79 +if_then74: ; preds = %cond.end78 store i1 true, i1* %isUnsigned - %106 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %106) - br label %if_end76 + %104 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %104) + br label %if_end75 -if_end76: ; preds = %if_then75, %cond.end79 - br label %if_block81 +if_end75: ; preds = %if_then74, %cond.end78 + br label %if_block80 -cond.true77: ; preds = %if_block74 - %107 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %108 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %107) - %109 = call i8 @toLower(i8 %108) - %110 = icmp eq i8 %109, 117 - br label %cond.end79 +cond.true76: ; preds = %if_block73 + %105 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %106 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %105) + %107 = call i8 @toLower(i8 %106) + %108 = icmp eq i8 %107, 117 + br label %cond.end78 -cond.false78: ; preds = %if_block74 - br label %cond.end79 +cond.false77: ; preds = %if_block73 + br label %cond.end78 -cond.end79: ; preds = %cond.false78, %cond.true77 - %cond.res80 = phi i1 [ %110, %cond.true77 ], [ false, %cond.false78 ] - br i1 %cond.res80, label %if_then75, label %if_end76 +cond.end78: ; preds = %cond.false77, %cond.true76 + %cond.res79 = phi i1 [ %108, %cond.true76 ], [ false, %cond.false77 ] + br i1 %cond.res79, label %if_then74, label %if_end75 -if_block81: ; preds = %if_end76 - %111 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %112 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %111) - br i1 %112, label %cond.true84, label %cond.false85 +if_block80: ; preds = %if_end75 + %109 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %110 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %109) + br i1 %110, label %cond.true83, label %cond.false84 -if_then82: ; preds = %cond.end86 +if_then81: ; preds = %cond.end85 store i1 true, i1* %isLong - %113 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %113) - br label %if_end83 - -if_end83: ; preds = %if_then82, %cond.end86 - br label %if_end73 - -cond.true84: ; preds = %if_block81 - %114 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %115 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %114) - %116 = call i8 @toLower(i8 %115) - %117 = icmp eq i8 %116, 108 - br label %cond.end86 - -cond.false85: ; preds = %if_block81 - br label %cond.end86 - -cond.end86: ; preds = %cond.false85, %cond.true84 - %cond.res87 = phi i1 [ %117, %cond.true84 ], [ false, %cond.false85 ] - br i1 %cond.res87, label %if_then82, label %if_end83 + %111 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %111) + br label %if_end82 -if_block88: ; preds = %if_end73 - %118 = load i1, i1* %isFloating - br i1 %118, label %if_then89, label %if_end90 +if_end82: ; preds = %if_then81, %cond.end85 + br label %if_end72 -if_then89: ; preds = %if_block88 - %119 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %120 = getelementptr inbounds %Token, %Token* %119, i32 0, i32 2 - store i8 0, i8* %tmp.this91 - %121 = load i8, i8* %tmp.this91 - call void @"+=.461"(%String* %120, i8 %121) - %122 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %123 = getelementptr inbounds %Token, %Token* %122, i32 0, i32 2 - %124 = call %StringRef @asStringRef(%String* %123) - %125 = call double @asDouble(%StringRef %124) +cond.true83: ; preds = %if_block80 + %112 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 + %113 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %112) + %114 = call i8 @toLower(i8 %113) + %115 = icmp eq i8 %114, 108 + br label %cond.end85 + +cond.false84: ; preds = %if_block80 + br label %cond.end85 + +cond.end85: ; preds = %cond.false84, %cond.true83 + %cond.res86 = phi i1 [ %115, %cond.true83 ], [ false, %cond.false84 ] + br i1 %cond.res86, label %if_then81, label %if_end82 + +if_block87: ; preds = %if_end72 + %116 = load i1, i1* %isFloating + br i1 %116, label %if_then88, label %if_end89 + +if_then88: ; preds = %if_block87 + %117 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %118 = getelementptr inbounds %Token, %Token* %117, i32 0, i32 2 + store i8 0, i8* %tmp.this90 + %119 = load i8, i8* %tmp.this90 + call void @"+=.450"(%String* %118, i8 %119) + %120 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %121 = getelementptr inbounds %Token, %Token* %120, i32 0, i32 2 + %122 = call %StringRef @asStringRef(%String* %121) + %123 = call double @asFloat(%StringRef %122) + %124 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 + %125 = getelementptr inbounds %Token, %Token* %124, i32 0, i32 4 + store double %123, double* %125 %126 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %127 = getelementptr inbounds %Token, %Token* %126, i32 0, i32 4 - store double %125, double* %127 - %128 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 3 - %129 = getelementptr inbounds %Token, %Token* %128, i32 0, i32 2 - call void @popBack.465(%String* %129) - %130 = load i1, i1* %isLong - br i1 %130, label %cond_alt1, label %cond_alt2 - -if_end90: ; preds = %cond_destruct_end96, %if_block88 + %127 = getelementptr inbounds %Token, %Token* %126, i32 0, i32 2 + call void @popBack.454(%String* %127) + %128 = load i1, i1* %isLong + br i1 %128, label %cond_alt1, label %cond_alt2 + +if_end89: ; preds = %cond_destruct_end96, %if_block87 br label %if_block98 -cond_alt1: ; preds = %if_then89 - call void @ctor.404(%TokenType* %tmp.this92, i32 46) +cond_alt1: ; preds = %if_then88 + call void @ctor.393(%TokenType* %tmp.this92, i32 46) + %129 = load %TokenType, %TokenType* %tmp.this92 br label %cond_end -cond_alt2: ; preds = %if_then89 - call void @ctor.404(%TokenType* %tmp.this93, i32 45) +cond_alt2: ; preds = %if_then88 + call void @ctor.393(%TokenType* %tmp.this93, i32 45) + %130 = load %TokenType, %TokenType* %tmp.this93 br label %cond_end cond_end: ; preds = %cond_alt2, %cond_alt1 - %cond = phi %TokenType* [ %tmp.this92, %cond_alt1 ], [ %tmp.this93, %cond_alt2 ] - call void @ctor.189(%TokenType* %_result, %TokenType* %cond) - br i1 %130, label %cond_destruct_alt1, label %cond_destruct_alt2 + %cond = phi %TokenType [ %129, %cond_alt1 ], [ %130, %cond_alt2 ] + store %TokenType %cond, %TokenType* %"$tmpForRef91" + call void @ctor.178(%TokenType* %_result, %TokenType* %"$tmpForRef91") + br i1 %128, label %cond_destruct_alt1, label %cond_destruct_alt2 cond_destruct_alt1: ; preds = %cond_end br label %cond_destruct_end @@ -16582,103 +16127,110 @@ cond_destruct_alt295: ; preds = %dumy_block97 br label %cond_destruct_end96 cond_destruct_end96: ; preds = %cond_destruct_alt295, %cond_destruct_alt194 - br label %if_end90 + br label %if_end89 dumy_block97: ; No predecessors! - br i1 %130, label %cond_destruct_alt194, label %cond_destruct_alt295 + br i1 %128, label %cond_destruct_alt194, label %cond_destruct_alt295 -if_block98: ; preds = %if_end90 +if_block98: ; preds = %if_end89 %131 = load i1, i1* %isUnsigned br i1 %131, label %if_then99, label %if_else100 if_then99: ; preds = %if_block98 %132 = load i1, i1* %isLong - br i1 %132, label %cond_alt1102, label %cond_alt2103 + br i1 %132, label %cond_alt1103, label %cond_alt2104 if_else100: ; preds = %if_block98 %133 = load i1, i1* %isLong - br i1 %133, label %cond_alt1115, label %cond_alt2116 + br i1 %133, label %cond_alt1117, label %cond_alt2118 -if_end101: ; preds = %cond_destruct_end126, %cond_destruct_end113 +if_end101: ; preds = %cond_destruct_end128, %cond_destruct_end114 ret void -cond_alt1102: ; preds = %if_then99 - call void @ctor.404(%TokenType* %tmp.this105, i32 44) - br label %cond_end104 +cond_alt1103: ; preds = %if_then99 + call void @ctor.393(%TokenType* %tmp.this106, i32 44) + %134 = load %TokenType, %TokenType* %tmp.this106 + br label %cond_end105 -cond_alt2103: ; preds = %if_then99 - call void @ctor.404(%TokenType* %tmp.this106, i32 43) - br label %cond_end104 +cond_alt2104: ; preds = %if_then99 + call void @ctor.393(%TokenType* %tmp.this107, i32 43) + %135 = load %TokenType, %TokenType* %tmp.this107 + br label %cond_end105 -cond_end104: ; preds = %cond_alt2103, %cond_alt1102 - %cond107 = phi %TokenType* [ %tmp.this105, %cond_alt1102 ], [ %tmp.this106, %cond_alt2103 ] - call void @ctor.189(%TokenType* %_result, %TokenType* %cond107) - br i1 %132, label %cond_destruct_alt1108, label %cond_destruct_alt2109 +cond_end105: ; preds = %cond_alt2104, %cond_alt1103 + %cond108 = phi %TokenType [ %134, %cond_alt1103 ], [ %135, %cond_alt2104 ] + store %TokenType %cond108, %TokenType* %"$tmpForRef102" + call void @ctor.178(%TokenType* %_result, %TokenType* %"$tmpForRef102") + br i1 %132, label %cond_destruct_alt1109, label %cond_destruct_alt2110 -cond_destruct_alt1108: ; preds = %cond_end104 - br label %cond_destruct_end110 +cond_destruct_alt1109: ; preds = %cond_end105 + br label %cond_destruct_end111 -cond_destruct_alt2109: ; preds = %cond_end104 - br label %cond_destruct_end110 +cond_destruct_alt2110: ; preds = %cond_end105 + br label %cond_destruct_end111 -cond_destruct_end110: ; preds = %cond_destruct_alt2109, %cond_destruct_alt1108 +cond_destruct_end111: ; preds = %cond_destruct_alt2110, %cond_destruct_alt1109 ret void -cond_destruct_alt1111: ; preds = %dumy_block114 - br label %cond_destruct_end113 +cond_destruct_alt1112: ; preds = %dumy_block115 + br label %cond_destruct_end114 -cond_destruct_alt2112: ; preds = %dumy_block114 - br label %cond_destruct_end113 +cond_destruct_alt2113: ; preds = %dumy_block115 + br label %cond_destruct_end114 -cond_destruct_end113: ; preds = %cond_destruct_alt2112, %cond_destruct_alt1111 +cond_destruct_end114: ; preds = %cond_destruct_alt2113, %cond_destruct_alt1112 br label %if_end101 -dumy_block114: ; No predecessors! - br i1 %132, label %cond_destruct_alt1111, label %cond_destruct_alt2112 +dumy_block115: ; No predecessors! + br i1 %132, label %cond_destruct_alt1112, label %cond_destruct_alt2113 -cond_alt1115: ; preds = %if_else100 - call void @ctor.404(%TokenType* %tmp.this118, i32 42) - br label %cond_end117 +cond_alt1117: ; preds = %if_else100 + call void @ctor.393(%TokenType* %tmp.this120, i32 42) + %136 = load %TokenType, %TokenType* %tmp.this120 + br label %cond_end119 -cond_alt2116: ; preds = %if_else100 - call void @ctor.404(%TokenType* %tmp.this119, i32 41) - br label %cond_end117 +cond_alt2118: ; preds = %if_else100 + call void @ctor.393(%TokenType* %tmp.this121, i32 41) + %137 = load %TokenType, %TokenType* %tmp.this121 + br label %cond_end119 -cond_end117: ; preds = %cond_alt2116, %cond_alt1115 - %cond120 = phi %TokenType* [ %tmp.this118, %cond_alt1115 ], [ %tmp.this119, %cond_alt2116 ] - call void @ctor.189(%TokenType* %_result, %TokenType* %cond120) - br i1 %133, label %cond_destruct_alt1121, label %cond_destruct_alt2122 +cond_end119: ; preds = %cond_alt2118, %cond_alt1117 + %cond122 = phi %TokenType [ %136, %cond_alt1117 ], [ %137, %cond_alt2118 ] + store %TokenType %cond122, %TokenType* %"$tmpForRef116" + call void @ctor.178(%TokenType* %_result, %TokenType* %"$tmpForRef116") + br i1 %133, label %cond_destruct_alt1123, label %cond_destruct_alt2124 -cond_destruct_alt1121: ; preds = %cond_end117 - br label %cond_destruct_end123 +cond_destruct_alt1123: ; preds = %cond_end119 + br label %cond_destruct_end125 -cond_destruct_alt2122: ; preds = %cond_end117 - br label %cond_destruct_end123 +cond_destruct_alt2124: ; preds = %cond_end119 + br label %cond_destruct_end125 -cond_destruct_end123: ; preds = %cond_destruct_alt2122, %cond_destruct_alt1121 +cond_destruct_end125: ; preds = %cond_destruct_alt2124, %cond_destruct_alt1123 ret void -cond_destruct_alt1124: ; preds = %dumy_block127 - br label %cond_destruct_end126 +cond_destruct_alt1126: ; preds = %dumy_block129 + br label %cond_destruct_end128 -cond_destruct_alt2125: ; preds = %dumy_block127 - br label %cond_destruct_end126 +cond_destruct_alt2127: ; preds = %dumy_block129 + br label %cond_destruct_end128 -cond_destruct_end126: ; preds = %cond_destruct_alt2125, %cond_destruct_alt1124 +cond_destruct_end128: ; preds = %cond_destruct_alt2127, %cond_destruct_alt1126 br label %if_end101 -dumy_block127: ; No predecessors! - br i1 %133, label %cond_destruct_alt1124, label %cond_destruct_alt2125 +dumy_block129: ; No predecessors! + br i1 %133, label %cond_destruct_alt1126, label %cond_destruct_alt2127 } ; Function Attrs: inlinehint nounwind -define internal i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r, i64 %base, %String* %capture) #4 { - %base.addr = alloca i64 - store i64 %base, i64* %base.addr +define internal i64 @consumeDigits(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r, i32 %base, %String* %capture) #4 { + %base.addr = alloca i32 + store i32 %base, i32* %base.addr %res = alloca i64 %tmp.this = alloca i64 %tmp.this8 = alloca i64 %tmp.this24 = alloca i64 + %tmp.this25 = alloca i64 br label %code code: ; preds = %0 @@ -16686,11 +16238,9 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = load i64, i64* %base.addr - store i64 16, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = icmp eq i64 %1, %2 - br i1 %3, label %if_then, label %if_else + %1 = load i32, i32* %base.addr + %2 = call i1 @_Int32_opEQ(i32 %1, i32 16) + br i1 %2, label %if_then, label %if_else if_then: ; preds = %if_block br label %while_block @@ -16699,27 +16249,27 @@ if_else: ; preds = %if_block br label %while_block9 if_end: ; preds = %while_end12, %while_end - %4 = load i64, i64* %res - ret i64 %4 + %3 = load i64, i64* %res + ret i64 %3 while_block: ; preds = %while_step, %if_then - %5 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - br i1 %5, label %cond.true, label %cond.false + %4 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + br i1 %4, label %cond.true, label %cond.false while_body: ; preds = %cond.end br label %if_block5 while_step: ; preds = %if_end7 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) br label %while_block while_end: ; preds = %cond.end br label %if_end cond.true: ; preds = %while_block - %6 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %7 = call i1 @isXdigit(i8 %6) - br i1 %7, label %cond.true1, label %cond.false2 + %5 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %6 = call i1 @isXdigit(i8 %5) + br i1 %6, label %cond.true1, label %cond.false2 cond.false: ; preds = %while_block br label %cond.end @@ -16732,57 +16282,60 @@ cond.true1: ; preds = %cond.true br label %cond.end3 cond.false2: ; preds = %cond.true - %8 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %9 = icmp eq i8 %8, 95 + %7 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %8 = icmp eq i8 %7, 95 br label %cond.end3 cond.end3: ; preds = %cond.false2, %cond.true1 - %cond.res = phi i1 [ true, %cond.true1 ], [ %9, %cond.false2 ] + %cond.res = phi i1 [ true, %cond.true1 ], [ %8, %cond.false2 ] br label %cond.end if_block5: ; preds = %while_body - %10 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %11 = icmp ne i8 %10, 95 - br i1 %11, label %if_then6, label %if_end7 + %9 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %10 = icmp ne i8 %9, 95 + br i1 %10, label %if_then6, label %if_end7 if_then6: ; preds = %if_block5 - %12 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - call void @"+=.461"(%String* %capture, i8 %12) - %13 = load i64, i64* %res - %14 = load i64, i64* %base.addr - %15 = mul i64 %13, %14 - store i64 %15, i64* %res - %16 = load i64, i64* %res - %17 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %18 = call i32 @getXdigitVal(i8 %17) - %19 = zext i32 %18 to i64 - store i64 %19, i64* %tmp.this8 - %20 = load i64, i64* %tmp.this8 - %21 = add i64 %16, %20 - store i64 %21, i64* %res + %11 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + call void @"+=.450"(%String* %capture, i8 %11) + %12 = load i64, i64* %res + %13 = load i32, i32* %base.addr + %14 = zext i32 %13 to i64 + store i64 %14, i64* %tmp.this + %15 = load i64, i64* %tmp.this + %16 = call i64 @_UInt64_opMul(i64 %12, i64 %15) + store i64 %16, i64* %res + %17 = load i64, i64* %res + %18 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %19 = call i32 @getXdigitVal(i8 %18) + %20 = zext i32 %19 to i64 + store i64 %20, i64* %tmp.this8 + %21 = load i64, i64* %tmp.this8 + %22 = call i64 @_UInt64_opPlus(i64 %17, i64 %21) + store i64 %22, i64* %res br label %if_end7 if_end7: ; preds = %if_then6, %if_block5 br label %while_step while_block9: ; preds = %while_step11, %if_else - %22 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - br i1 %22, label %cond.true13, label %cond.false14 + %23 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + br i1 %23, label %cond.true13, label %cond.false14 while_body10: ; preds = %cond.end15 br label %if_block21 while_step11: ; preds = %if_end23 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) br label %while_block9 while_end12: ; preds = %cond.end15 br label %if_end cond.true13: ; preds = %while_block9 - %23 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %24 = call i1 @isXdigit(i8 %23) - br i1 %24, label %cond.true16, label %cond.false17 + %24 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %25 = call i1 @isXdigit(i8 %24) + br i1 %25, label %cond.true16, label %cond.false17 cond.false14: ; preds = %while_block9 br label %cond.end15 @@ -16795,34 +16348,37 @@ cond.true16: ; preds = %cond.true13 br label %cond.end18 cond.false17: ; preds = %cond.true13 - %25 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %26 = icmp eq i8 %25, 95 + %26 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %27 = icmp eq i8 %26, 95 br label %cond.end18 cond.end18: ; preds = %cond.false17, %cond.true16 - %cond.res19 = phi i1 [ true, %cond.true16 ], [ %26, %cond.false17 ] + %cond.res19 = phi i1 [ true, %cond.true16 ], [ %27, %cond.false17 ] br label %cond.end15 if_block21: ; preds = %while_body10 - %27 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %28 = icmp ne i8 %27, 95 - br i1 %28, label %if_then22, label %if_end23 + %28 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %29 = icmp ne i8 %28, 95 + br i1 %29, label %if_then22, label %if_end23 if_then22: ; preds = %if_block21 - %29 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - call void @"+=.461"(%String* %capture, i8 %29) - %30 = load i64, i64* %res - %31 = load i64, i64* %base.addr - %32 = mul i64 %30, %31 - store i64 %32, i64* %res - %33 = load i64, i64* %res - %34 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) - %35 = call i32 @getDigitVal(i8 %34) - %36 = zext i32 %35 to i64 - store i64 %36, i64* %tmp.this24 - %37 = load i64, i64* %tmp.this24 - %38 = add i64 %33, %37 - store i64 %38, i64* %res + %30 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + call void @"+=.450"(%String* %capture, i8 %30) + %31 = load i64, i64* %res + %32 = load i32, i32* %base.addr + %33 = zext i32 %32 to i64 + store i64 %33, i64* %tmp.this24 + %34 = load i64, i64* %tmp.this24 + %35 = call i64 @_UInt64_opMul(i64 %31, i64 %34) + store i64 %35, i64* %res + %36 = load i64, i64* %res + %37 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %r) + %38 = call i32 @getDigitVal(i8 %37) + %39 = zext i32 %38 to i64 + store i64 %39, i64* %tmp.this25 + %40 = load i64, i64* %tmp.this25 + %41 = call i64 @_UInt64_opPlus(i64 %36, i64 %40) + store i64 %41, i64* %res br label %if_end23 if_end23: ; preds = %if_then22, %if_block21 @@ -16841,7 +16397,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isxdigit(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -16861,7 +16417,7 @@ code: ; preds = %0 %2 = load i32, i32* %tmp.this call void @_ass_32_8z(i32* %tmp.this1, i8 48) %3 = load i32, i32* %tmp.this1 - %4 = sub i32 %2, %3 + %4 = call i32 @_Int32_opMinus(i32 %2, i32 %3) ret i32 %4 } @@ -16874,7 +16430,7 @@ code: ; preds = %0 while_block: ; preds = %while_step, %code %1 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - %2 = call i1 @"pre_!!.429"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) + %2 = call i1 @"pre_!!.418"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %1) br i1 %2, label %cond.true, label %cond.false while_body: ; preds = %cond.end @@ -16882,7 +16438,7 @@ while_body: ; preds = %cond.end while_step: ; preds = %if_end %3 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 - call void @popFront.410(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3) + call void @popFront.399(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %3) br label %while_block while_end: ; preds = %cond.end @@ -16891,7 +16447,7 @@ while_end: ; preds = %cond.end cond.true: ; preds = %while_block %4 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %5 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %4) - %6 = call i1 @"().463"(%"FunctionPtr1[Bool, Char]"* %pred, i8 %5) + %6 = call i1 @"().452"(%"FunctionPtr1[Bool, Char]"* %pred, i8 %5) br i1 %6, label %cond.true1, label %cond.false2 cond.false: ; preds = %while_block @@ -16925,7 +16481,7 @@ if_then: ; preds = %if_block %14 = getelementptr inbounds %Token, %Token* %13, i32 0, i32 2 %15 = getelementptr inbounds %SparrowScanner, %SparrowScanner* %this, i32 0, i32 2 %16 = call i8 @"pre_*"(%"LocationSyncCharRange[RangeWithLookahead[BufferedCharSourceRange]]"* %15) - call void @"+=.461"(%String* %14, i8 %16) + call void @"+=.450"(%String* %14, i8 %16) br label %if_end if_end: ; preds = %if_then, %if_block @@ -16933,27 +16489,24 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal void @popBack.465(%String* %this) #4 { +define internal void @popBack.454(%String* %this) #4 { %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %2 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i64 %3) - store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") - %5 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %6 = call i8* @value(%"RawPtr[Char]"* %5) - %7 = load i8, i8* %6 + %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i32 -1) + store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") + %4 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %5 = call i8* @value(%"RawPtr[Char]"* %4) + %6 = load i8, i8* %5 ret void } ; Function Attrs: inlinehint nounwind -define internal void @toString.466(%String* sret %_result, %StringRef* %a1, i8* %a2, %StringRef* %a3, i32* %a4, i8* %a5) #4 { +define internal void @toString.455(%String* sret %_result, %StringRef* %a1, i8* %a2, %StringRef* %a3, i32* %a4, i8* %a5) #4 { %s = alloca %StringOutputStream %"$tmpC" = alloca %StringOutputStream %"$tmpC1" = alloca %StringOutputStream @@ -16963,40 +16516,40 @@ define internal void @toString.466(%String* sret %_result, %StringRef* %a1, i8* br label %code code: ; preds = %0 - call void @ctor.439(%StringOutputStream* %s) + call void @ctor.428(%StringOutputStream* %s) call void @"<<"(%StringOutputStream* %"$tmpC4", %StringOutputStream* %s, %StringRef* %a1) - call void @"<<.467"(%StringOutputStream* %"$tmpC3", %StringOutputStream* %"$tmpC4", i8* %a2) + call void @"<<.456"(%StringOutputStream* %"$tmpC3", %StringOutputStream* %"$tmpC4", i8* %a2) call void @"<<"(%StringOutputStream* %"$tmpC2", %StringOutputStream* %"$tmpC3", %StringRef* %a3) - call void @"<<.471"(%StringOutputStream* %"$tmpC1", %StringOutputStream* %"$tmpC2", i32* %a4) - call void @"<<.467"(%StringOutputStream* %"$tmpC", %StringOutputStream* %"$tmpC1", i8* %a5) - call void @dtor.442(%StringOutputStream* %"$tmpC") - call void @dtor.442(%StringOutputStream* %"$tmpC1") - call void @dtor.442(%StringOutputStream* %"$tmpC2") - call void @dtor.442(%StringOutputStream* %"$tmpC3") - call void @dtor.442(%StringOutputStream* %"$tmpC4") + call void @"<<.460"(%StringOutputStream* %"$tmpC1", %StringOutputStream* %"$tmpC2", i32* %a4) + call void @"<<.456"(%StringOutputStream* %"$tmpC", %StringOutputStream* %"$tmpC1", i8* %a5) + call void @dtor.431(%StringOutputStream* %"$tmpC") + call void @dtor.431(%StringOutputStream* %"$tmpC1") + call void @dtor.431(%StringOutputStream* %"$tmpC2") + call void @dtor.431(%StringOutputStream* %"$tmpC3") + call void @dtor.431(%StringOutputStream* %"$tmpC4") %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %s, i32 0, i32 0 - call void @ctor.175(%String* %_result, %String* %1) - call void @dtor.442(%StringOutputStream* %s) + call void @ctor.165(%String* %_result, %String* %1) + call void @dtor.431(%StringOutputStream* %s) ret void dumy_block: ; No predecessors! - call void @dtor.442(%StringOutputStream* %s) + call void @dtor.431(%StringOutputStream* %s) ret void } ; Function Attrs: inlinehint nounwind -define internal void @"<<.467"(%StringOutputStream* sret %_result, %StringOutputStream* %s, i8* %x) #4 { +define internal void @"<<.456"(%StringOutputStream* sret %_result, %StringOutputStream* %s, i8* %x) #4 { br label %code code: ; preds = %0 %1 = load i8, i8* %x - call void @"<<<.468"(%StringOutputStream* %s, i8 %1) - call void @ctor.441(%StringOutputStream* %_result, %StringOutputStream* %s) + call void @"<<<.457"(%StringOutputStream* %s, i8 %1) + call void @ctor.430(%StringOutputStream* %_result, %StringOutputStream* %s) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"<<<.468"(%StringOutputStream* %this, i8 %x) #3 { +define internal void @"<<<.457"(%StringOutputStream* %this, i8 %x) #3 { %x.addr = alloca i8 store i8 %x, i8* %x.addr br label %code @@ -17004,12 +16557,12 @@ define internal void @"<<<.468"(%StringOutputStream* %this, i8 %x) #3 { code: ; preds = %0 %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 %2 = load i8, i8* %x.addr - call void @append.469(%String* %1, i8 %2) + call void @append.458(%String* %1, i8 %2) ret void } ; Function Attrs: inlinehint nounwind -define internal void @append.469(%String* %this, i8 %value) #4 { +define internal void @append.458(%String* %this, i8 %value) #4 { %value.addr = alloca i8 store i8 %value, i8* %value.addr %tmp.this = alloca %StringRef @@ -17021,34 +16574,30 @@ code: ; preds = %0 %3 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %2) %4 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %5 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %4) - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %3, %UntypedPtr %5) + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %3, %UntypedPtr %5) %6 = load %StringRef, %StringRef* %tmp.this - call void @insertBefore.470(%String* %this, i8 %1, %StringRef %6) + call void @insertBefore.459(%String* %this, i8 %1, %StringRef %6) %7 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %7) + call void @dtor.51(%StringRef %7) ret void } ; Function Attrs: inlinehint nounwind -define internal void @insertBefore.470(%String* %this, i8 %value, %StringRef %pos) #4 { +define internal void @insertBefore.459(%String* %this, i8 %value, %StringRef %pos) #4 { %value.addr = alloca i8 store i8 %value, i8* %value.addr %pos.addr = alloca %StringRef store %StringRef %pos, %StringRef* %pos.addr - %posCount = alloca i64 + %posCount = alloca i32 %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 %p = alloca %"RawPtr[Char]" %"$tmpForRef1" = alloca %"RawPtr[Char]" - %tmp.this2 = alloca i64 %q = alloca %"RawPtr[Char]" + %"$tmpForRef2" = alloca %"RawPtr[Char]" %"$tmpForRef3" = alloca %"RawPtr[Char]" - %tmp.this4 = alloca i64 + %"$tmpForRef4" = alloca %"RawPtr[Char]" %"$tmpForRef5" = alloca %"RawPtr[Char]" %"$tmpForRef6" = alloca %"RawPtr[Char]" - %tmp.this7 = alloca i64 - %"$tmpForRef8" = alloca %"RawPtr[Char]" - %"$tmpForRef9" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 @@ -17057,80 +16606,72 @@ code: ; preds = %0 store %"RawPtr[Char]" %2, %"RawPtr[Char]"* %"$tmpForRef" %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %4 = load %"RawPtr[Char]", %"RawPtr[Char]"* %3 - %5 = call i64 @diff(%"RawPtr[Char]"* %"$tmpForRef", %"RawPtr[Char]" %4) - store i64 %5, i64* %posCount - %6 = call i64 @size.176(%String* %this) - store i64 1, i64* %tmp.this - %7 = load i64, i64* %tmp.this - %8 = add i64 %6, %7 - call void @reserve(%String* %this, i64 %8) - %9 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this2 - %10 = load i64, i64* %tmp.this2 - %11 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %9, i64 %10) - store %"RawPtr[Char]" %11, %"RawPtr[Char]"* %"$tmpForRef1" - call void @ctor.178(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef1") - %12 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %13 = load i64, i64* %posCount - store i64 1, i64* %tmp.this4 - %14 = load i64, i64* %tmp.this4 - %15 = call i64 @_DiffType_opMinus(i64 %13, i64 %14) - %16 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %12, i64 %15) - store %"RawPtr[Char]" %16, %"RawPtr[Char]"* %"$tmpForRef3" - call void @ctor.178(%"RawPtr[Char]"* %q, %"RawPtr[Char]"* %"$tmpForRef3") + %5 = call i32 @diff(%"RawPtr[Char]"* %"$tmpForRef", %"RawPtr[Char]" %4) + store i32 %5, i32* %posCount + %6 = call i32 @size.166(%String* %this) + %7 = call i32 @_Int32_opPlus(i32 %6, i32 1) + call void @reserve(%String* %this, i32 %7) + %8 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %9 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %8, i32 -1) + store %"RawPtr[Char]" %9, %"RawPtr[Char]"* %"$tmpForRef1" + call void @ctor.168(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef1") + %10 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %11 = load i32, i32* %posCount + %12 = call i32 @_Int32_opMinus(i32 %11, i32 1) + %13 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %10, i32 %12) + store %"RawPtr[Char]" %13, %"RawPtr[Char]"* %"$tmpForRef2" + call void @ctor.168(%"RawPtr[Char]"* %q, %"RawPtr[Char]"* %"$tmpForRef2") br label %while_block while_block: ; preds = %while_step, %code - %17 = call i1 @"==.257"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %q) - %18 = xor i1 true, %17 - br i1 %18, label %while_body, label %while_end + %14 = call i1 @"==.246"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %q) + %15 = xor i1 true, %14 + br i1 %15, label %while_body, label %while_end while_body: ; preds = %while_block - %19 = call i8* @value(%"RawPtr[Char]"* %p) - %20 = load i8, i8* %19 - %21 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %p) - store %"RawPtr[Char]" %21, %"RawPtr[Char]"* %"$tmpForRef5" - %22 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef5") - store i8 %20, i8* %22 - %23 = call i8* @value(%"RawPtr[Char]"* %p) - %24 = load i8, i8* %23 + %16 = call i8* @value(%"RawPtr[Char]"* %p) + %17 = load i8, i8* %16 + %18 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %p) + store %"RawPtr[Char]" %18, %"RawPtr[Char]"* %"$tmpForRef3" + %19 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef3") + store i8 %17, i8* %19 + %20 = call i8* @value(%"RawPtr[Char]"* %p) + %21 = load i8, i8* %20 br label %while_step while_step: ; preds = %while_body - store i64 -1, i64* %tmp.this7 - %25 = load i64, i64* %tmp.this7 - %26 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %p, i64 %25) - store %"RawPtr[Char]" %26, %"RawPtr[Char]"* %"$tmpForRef6" - call void @"=.186"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef6") + %22 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %p, i32 -1) + store %"RawPtr[Char]" %22, %"RawPtr[Char]"* %"$tmpForRef4" + call void @"=.176"(%"RawPtr[Char]"* %p, %"RawPtr[Char]"* %"$tmpForRef4") br label %while_block while_end: ; preds = %while_block - %27 = load i8, i8* %value.addr - %28 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %p) - store %"RawPtr[Char]" %28, %"RawPtr[Char]"* %"$tmpForRef8" - %29 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef8") - store i8 %27, i8* %29 - %30 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %31 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %32 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %31) - store %"RawPtr[Char]" %32, %"RawPtr[Char]"* %"$tmpForRef9" - call void @"=.186"(%"RawPtr[Char]"* %30, %"RawPtr[Char]"* %"$tmpForRef9") + %23 = load i8, i8* %value.addr + %24 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %p) + store %"RawPtr[Char]" %24, %"RawPtr[Char]"* %"$tmpForRef5" + %25 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef5") + store i8 %23, i8* %25 + %26 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %27 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %28 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %27) + store %"RawPtr[Char]" %28, %"RawPtr[Char]"* %"$tmpForRef6" + call void @"=.176"(%"RawPtr[Char]"* %26, %"RawPtr[Char]"* %"$tmpForRef6") ret void } ; Function Attrs: inlinehint nounwind -define internal void @"<<.471"(%StringOutputStream* sret %_result, %StringOutputStream* %s, i32* %x) #4 { +define internal void @"<<.460"(%StringOutputStream* sret %_result, %StringOutputStream* %s, i32* %x) #4 { br label %code code: ; preds = %0 %1 = load i32, i32* %x - call void @"<<<.472"(%StringOutputStream* %s, i32 %1) - call void @ctor.441(%StringOutputStream* %_result, %StringOutputStream* %s) + call void @"<<<.461"(%StringOutputStream* %s, i32 %1) + call void @ctor.430(%StringOutputStream* %_result, %StringOutputStream* %s) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"<<<.472"(%StringOutputStream* %this, i32 %x) #3 { +define internal void @"<<<.461"(%StringOutputStream* %this, i32 %x) #3 { %x.addr = alloca i32 store i32 %x, i32* %x.addr %"$tmpForRef" = alloca %StringRef @@ -17141,15 +16682,15 @@ code: ; preds = %0 %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 %2 = load i32, i32* %x.addr call void @intToString(%String* %"$tmpC", i32 %2) - %3 = call %StringRef @all.473(%String* %"$tmpC") + %3 = call %StringRef @all.462(%String* %"$tmpC") store %StringRef %3, %StringRef* %"$tmpForRef" call void @append(%String* %1, %StringRef* %"$tmpForRef") - call void @dtor.250(%String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") ret void } ; Function Attrs: inlinehint nounwind -define internal %StringRef @all.473(%String* %this) #4 { +define internal %StringRef @all.462(%String* %this) #4 { %tmp.this = alloca %StringRef br label %code @@ -17158,15 +16699,15 @@ code: ; preds = %0 %2 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %1) %3 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %4 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %3) - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %2, %UntypedPtr %4) %5 = load %StringRef, %StringRef* %tmp.this %6 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %6) + call void @dtor.51(%StringRef %6) ret %StringRef %5 dumy_block: ; No predecessors! %7 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %7) + call void @dtor.51(%StringRef %7) unreachable } @@ -17183,121 +16724,107 @@ code: ; preds = %0 call void @_Int_to_CString(i32 %1, i8* %2) %3 = bitcast [12 x i8]* %buf to i8* %4 = call %StringRef @_String_fromCString(i8* %3) - call void @ctor.459(%String* %_result, %StringRef %4) + call void @ctor.448(%String* %_result, %StringRef %4) ret void } ; Function Attrs: inlinehint nounwind -define internal void @"+=.474"(%"Vector[UInt]"* %this, i32 %value) #4 { +define internal void @"+=.463"(%"Vector[Int]"* %this, i32 %value) #4 { %value.addr = alloca i32 store i32 %value, i32* %value.addr br label %code code: ; preds = %0 %1 = load i32, i32* %value.addr - call void @pushBack.475(%"Vector[UInt]"* %this, i32 %1) + call void @pushBack.464(%"Vector[Int]"* %this, i32 %1) ret void } ; Function Attrs: inlinehint nounwind -define internal void @pushBack.475(%"Vector[UInt]"* %this, i32 %value) #4 { +define internal void @pushBack.464(%"Vector[Int]"* %this, i32 %value) #4 { %value.addr = alloca i32 store i32 %value, i32* %value.addr - %t = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 - %"$tmpForRef" = alloca %"RawPtr[UInt]" + %t = alloca i32 + %"$tmpForRef" = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - %3 = call i1 @"==.260"(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]"* %2) + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + %3 = call i1 @"==.249"(%"RawPtr[Int]"* %1, %"RawPtr[Int]"* %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block - store i64 2, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call i64 @capacity.476(%"Vector[UInt]"* %this) - %6 = mul i64 %4, %5 - store i64 %6, i64* %t + %4 = call i32 @capacity.465(%"Vector[Int]"* %this) + %5 = call i32 @_Int32_opMul(i32 2, i32 %4) + store i32 %5, i32* %t br label %if_block1 if_end: ; preds = %if_end3, %if_block - %7 = load i32, i32* %value.addr - %8 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %9 = call i32* @value.261(%"RawPtr[UInt]"* %8) - store i32 %7, i32* %9 - %10 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %11 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %12 = call %"RawPtr[UInt]" @advance.262(%"RawPtr[UInt]"* %11) - store %"RawPtr[UInt]" %12, %"RawPtr[UInt]"* %"$tmpForRef" - call void @"=.212"(%"RawPtr[UInt]"* %10, %"RawPtr[UInt]"* %"$tmpForRef") + %6 = load i32, i32* %value.addr + %7 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %8 = call i32* @value.250(%"RawPtr[Int]"* %7) + store i32 %6, i32* %8 + %9 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %10 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %11 = call %"RawPtr[Int]" @advance.251(%"RawPtr[Int]"* %10) + store %"RawPtr[Int]" %11, %"RawPtr[Int]"* %"$tmpForRef" + call void @"=.201"(%"RawPtr[Int]"* %9, %"RawPtr[Int]"* %"$tmpForRef") ret void if_block1: ; preds = %if_then - %13 = load i64, i64* %t - store i64 2, i64* %tmp.this4 - %14 = load i64, i64* %tmp.this4 - %15 = icmp slt i64 %13, %14 - br i1 %15, label %if_then2, label %if_end3 + %12 = load i32, i32* %t + %13 = call i1 @_Int32_opLT(i32 %12, i32 2) + br i1 %13, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 2, i64* %tmp.this5 - %16 = load i64, i64* %tmp.this5 - store i64 %16, i64* %t + store i32 2, i32* %t br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - %17 = load i64, i64* %t - call void @reserve.477(%"Vector[UInt]"* %this, i64 %17) + %14 = load i32, i32* %t + call void @reserve.466(%"Vector[Int]"* %this, i32 %14) br label %if_end } ; Function Attrs: inlinehint nounwind -define internal i64 @capacity.476(%"Vector[UInt]"* %this) #4 { - %tmp.this = alloca i64 +define internal i32 @capacity.465(%"Vector[Int]"* %this) #4 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %3 = load %"RawPtr[UInt]", %"RawPtr[UInt]"* %2 - %4 = call i64 @diff.210(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %3 = load %"RawPtr[Int]", %"RawPtr[Int]"* %2 + %4 = call i32 @diff.199(%"RawPtr[Int]"* %1, %"RawPtr[Int]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal void @reserve.477(%"Vector[UInt]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %curCapacity = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this8 = alloca double +define internal void @reserve.466(%"Vector[Int]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %curCapacity = alloca i32 + %tmp.this = alloca i32 + %tmp.this7 = alloca double + %tmp.this8 = alloca i32 %tmp.this9 = alloca double - %tmp.this10 = alloca i64 - %tmp.this11 = alloca double - %curSize = alloca i64 - %"$tmpForRef" = alloca %"RawPtr[UInt]" - %"$tmpForRef12" = alloca %"RawPtr[UInt]" + %curSize = alloca i32 + %"$tmpForRef" = alloca %"RawPtr[Int]" + %"$tmpForRef10" = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 - %1 = call i64 @capacity.476(%"Vector[UInt]"* %this) - store i64 %1, i64* %curCapacity + %1 = call i32 @capacity.465(%"Vector[Int]"* %this) + store i32 %1, i32* %curCapacity br label %if_block if_block: ; preds = %code - %2 = load i64, i64* %n.addr - %3 = load i64, i64* %curCapacity - %4 = icmp sle i64 %2, %3 + %2 = load i32, i32* %n.addr + %3 = load i32, i32* %curCapacity + %4 = call i1 @_Int32_opLE(i32 %2, i32 %3) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block @@ -17310,132 +16837,128 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - %5 = load i64, i64* %n.addr - store i64 8, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = icmp slt i64 %5, %6 - br i1 %7, label %if_then2, label %if_end3 + %5 = load i32, i32* %n.addr + %6 = call i1 @_Int32_opLT(i32 %5, i32 8) + br i1 %6, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 8, i64* %tmp.this4 - %8 = load i64, i64* %tmp.this4 - store i64 %8, i64* %n.addr + store i32 8, i32* %n.addr br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - br label %if_block5 + br label %if_block4 -if_block5: ; preds = %if_end3 - %9 = load i64, i64* %n.addr - %10 = sitofp i64 %9 to double - store double %10, double* %tmp.this8 - %11 = load double, double* %tmp.this8 - %12 = load i64, i64* %curCapacity - %13 = sitofp i64 %12 to double - store double %13, double* %tmp.this9 - %14 = load double, double* %tmp.this9 - %15 = call double @_Double_opMul(double 2.000000e+00, double %14) - %16 = call i1 @_Double_opLT(double %11, double %15) - br i1 %16, label %if_then6, label %if_end7 +if_block4: ; preds = %if_end3 + %7 = load i32, i32* %n.addr + %8 = load i32, i32* %curCapacity + %9 = sitofp i32 %8 to double + store double %9, double* %tmp.this7 + %10 = load double, double* %tmp.this7 + %11 = call double @_Float64_opMul(double 2.000000e+00, double %10) + %12 = fptosi double %11 to i32 + store i32 %12, i32* %tmp.this + %13 = load i32, i32* %tmp.this + %14 = call i1 @_Int32_opLT(i32 %7, i32 %13) + br i1 %14, label %if_then5, label %if_end6 -if_then6: ; preds = %if_block5 - %17 = load i64, i64* %curCapacity - %18 = sitofp i64 %17 to double - store double %18, double* %tmp.this11 - %19 = load double, double* %tmp.this11 - %20 = call double @_Double_opMul(double 2.000000e+00, double %19) - %21 = fptoui double %20 to i64 - store i64 %21, i64* %tmp.this10 - %22 = load i64, i64* %tmp.this10 - store i64 %22, i64* %n.addr - br label %if_end7 +if_then5: ; preds = %if_block4 + %15 = load i32, i32* %curCapacity + %16 = sitofp i32 %15 to double + store double %16, double* %tmp.this9 + %17 = load double, double* %tmp.this9 + %18 = call double @_Float64_opMul(double 2.000000e+00, double %17) + %19 = fptosi double %18 to i32 + store i32 %19, i32* %tmp.this8 + %20 = load i32, i32* %tmp.this8 + store i32 %20, i32* %n.addr + br label %if_end6 -if_end7: ; preds = %if_then6, %if_block5 - %23 = call i64 @size.209(%"Vector[UInt]"* %this) - store i64 %23, i64* %curSize - %24 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %25 = load i64, i64* %n.addr - call void @reallocPtr.478(%"RawPtr[UInt]"* %24, i64 %25) - %26 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %27 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %28 = load i64, i64* %curSize - %29 = call %"RawPtr[UInt]" @advance.215(%"RawPtr[UInt]"* %27, i64 %28) - store %"RawPtr[UInt]" %29, %"RawPtr[UInt]"* %"$tmpForRef" - call void @"=.212"(%"RawPtr[UInt]"* %26, %"RawPtr[UInt]"* %"$tmpForRef") - %30 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - %31 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %32 = load i64, i64* %n.addr - %33 = call %"RawPtr[UInt]" @advance.215(%"RawPtr[UInt]"* %31, i64 %32) - store %"RawPtr[UInt]" %33, %"RawPtr[UInt]"* %"$tmpForRef12" - call void @"=.212"(%"RawPtr[UInt]"* %30, %"RawPtr[UInt]"* %"$tmpForRef12") - ret void -} - -; Function Attrs: inlinehint nounwind -define internal void @reallocPtr.478(%"RawPtr[UInt]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +if_end6: ; preds = %if_then5, %if_block4 + %21 = call i32 @size.198(%"Vector[Int]"* %this) + store i32 %21, i32* %curSize + %22 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %23 = load i32, i32* %n.addr + call void @reallocPtr.467(%"RawPtr[Int]"* %22, i32 %23) + %24 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %25 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %26 = load i32, i32* %curSize + %27 = call %"RawPtr[Int]" @advance.204(%"RawPtr[Int]"* %25, i32 %26) + store %"RawPtr[Int]" %27, %"RawPtr[Int]"* %"$tmpForRef" + call void @"=.201"(%"RawPtr[Int]"* %24, %"RawPtr[Int]"* %"$tmpForRef") + %28 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + %29 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %30 = load i32, i32* %n.addr + %31 = call %"RawPtr[Int]" @advance.204(%"RawPtr[Int]"* %29, i32 %30) + store %"RawPtr[Int]" %31, %"RawPtr[Int]"* %"$tmpForRef10" + call void @"=.201"(%"RawPtr[Int]"* %28, %"RawPtr[Int]"* %"$tmpForRef10") + ret void +} + +; Function Attrs: inlinehint nounwind +define internal void @reallocPtr.467(%"RawPtr[Int]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %1 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 %2 = load i32*, i32** %1 - call void @ctor.211(%UntypedPtr* %tmp.this, i32* %2) + call void @ctor.200(%UntypedPtr* %tmp.this, i32* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 4 - %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i64 %5) - %7 = call i32* @asRefOf.217(%UntypedPtr %6) - %8 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 4) + %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i32 %5) + %7 = call i32* @asRefOf.206(%UntypedPtr %6) + %8 = getelementptr inbounds %"RawPtr[Int]", %"RawPtr[Int]"* %this, i32 0, i32 0 store i32* %7, i32** %8 ret void } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.479(%"RangeWithLookahead[SparrowScanner]"* %this) #4 { +define internal i1 @isEmpty.468(%"RangeWithLookahead[SparrowScanner]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - %2 = call i1 @isEmpty.480(%"Vector[Token]"* %1) + %2 = call i1 @isEmpty.469(%"Vector[Token]"* %1) ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.480(%"Vector[Token]"* %this) #4 { +define internal i1 @isEmpty.469(%"Vector[Token]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %3 = call i1 @"==.205"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %2) + %3 = call i1 @"==.194"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %2) ret i1 %3 } ; Function Attrs: inlinehint nounwind -define internal void @front.481(%Token* sret %_result, %"RangeWithLookahead[SparrowScanner]"* %this) #4 { +define internal void @front.470(%Token* sret %_result, %"RangeWithLookahead[SparrowScanner]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - %2 = call %Token* @front.482(%"Vector[Token]"* %1) - call void @ctor.188(%Token* %_result, %Token* %2) + %2 = call %Token* @front.471(%"Vector[Token]"* %1) + call void @ctor.177(%Token* %_result, %Token* %2) ret void } ; Function Attrs: inlinehint nounwind -define internal %Token* @front.482(%"Vector[Token]"* %this) #4 { +define internal %Token* @front.471(%"Vector[Token]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %2 = call %Token* @value.206(%"RawPtr[Token]"* %1) + %2 = call %Token* @value.195(%"RawPtr[Token]"* %1) ret %Token* %2 } ; Function Attrs: noinline nounwind -define void @popFront.483(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #5 { +define void @popFront.472(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #5 { %tmp.this = alloca %TokenType %oldType = alloca %TokenType %"$tmpC" = alloca %Token @@ -17451,27 +16974,25 @@ define void @popFront.483(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #5 { %newCol = alloca i32 %oldCol = alloca i32 %tmp.this21 = alloca %TokenType - %tmp.this22 = alloca i32 - %tmp.this35 = alloca %TokenType - %tmp.this37 = alloca %TokenType - %tmp.this39 = alloca %TokenType - %tmp.this41 = alloca %TokenType - %tmp.this57 = alloca %TokenType - %tmp.this59 = alloca %TokenType - %tmp.this69 = alloca i32 + %tmp.this34 = alloca %TokenType + %tmp.this36 = alloca %TokenType + %tmp.this38 = alloca %TokenType + %tmp.this40 = alloca %TokenType + %tmp.this56 = alloca %TokenType + %tmp.this58 = alloca %TokenType %numDedents = alloca i32 - %tmp.this75 = alloca %TokenType - %"$tmpC79" = alloca %String + %tmp.this73 = alloca %TokenType + %"$tmpC77" = alloca %String %"$tmpForRef" = alloca %StringRef %tmp.StringRef = alloca %StringRef - %"$tmpForRef80" = alloca %StringRef - %tmp.StringRef81 = alloca %StringRef + %"$tmpForRef78" = alloca %StringRef + %tmp.StringRef79 = alloca %StringRef + %tmp.this83 = alloca %TokenType %tmp.this88 = alloca %TokenType %tmp.this93 = alloca %TokenType - %tmp.this98 = alloca %TokenType - %tmp.this106 = alloca %TokenType - %tmp.this115 = alloca %TokenType - %tmp.this123 = alloca %TokenType + %tmp.this101 = alloca %TokenType + %tmp.this110 = alloca %TokenType + %tmp.this118 = alloca %TokenType br label %code code: ; preds = %0 @@ -17480,29 +17001,29 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 %2 = load i32, i32* %1 - %3 = icmp sgt i32 %2, 0 + %3 = call i1 @_Int32_opGT(i32 %2, i32 0) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block %4 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 - %5 = call i32 @post_--.48(i32* %4) + %5 = call i32 @post_--.40(i32* %4) %6 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @ctor.404(%TokenType* %tmp.this, i32 26) - call void @"=.286"(%TokenType* %6, %TokenType* %tmp.this) + call void @ctor.393(%TokenType* %tmp.this, i32 26) + call void @"=.275"(%TokenType* %6, %TokenType* %tmp.this) ret void if_end: ; preds = %dumy_block, %if_block - call void @front.484(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %this) + call void @front.473(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %this) %7 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 - call void @ctor.189(%TokenType* %oldType, %TokenType* %7) - call void @dtor.249(%Token* %"$tmpC") + call void @ctor.178(%TokenType* %oldType, %TokenType* %7) + call void @dtor.238(%Token* %"$tmpC") %8 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @popFront.485(%"RangeWithLookahead[SparrowScanner]"* %8) + call void @popFront.474(%"RangeWithLookahead[SparrowScanner]"* %8) %9 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @front.481(%Token* %"$tmpC1", %"RangeWithLookahead[SparrowScanner]"* %9) + call void @front.470(%Token* %"$tmpC1", %"RangeWithLookahead[SparrowScanner]"* %9) %10 = getelementptr inbounds %Token, %Token* %"$tmpC1", i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this2, i32 1) - %11 = call i1 @"==.339"(%TokenType* %10, %TokenType* %tmp.this2) + call void @ctor.393(%TokenType* %tmp.this2, i32 1) + %11 = call i1 @"==.328"(%TokenType* %10, %TokenType* %tmp.this2) br i1 %11, label %cond.true, label %cond.false dumy_block: ; No predecessors! @@ -17513,10 +17034,10 @@ cond.true: ; preds = %if_end cond.false: ; preds = %if_end %12 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @front.481(%Token* %"$tmpC3", %"RangeWithLookahead[SparrowScanner]"* %12) + call void @front.470(%Token* %"$tmpC3", %"RangeWithLookahead[SparrowScanner]"* %12) %13 = getelementptr inbounds %Token, %Token* %"$tmpC3", i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this4, i32 0) - %14 = call i1 @"==.339"(%TokenType* %13, %TokenType* %tmp.this4) + call void @ctor.393(%TokenType* %tmp.this4, i32 0) + %14 = call i1 @"==.328"(%TokenType* %13, %TokenType* %tmp.this4) br label %cond.end cond.end: ; preds = %cond.false, %cond.true @@ -17528,35 +17049,35 @@ cond_destruct_alt1: ; preds = %cond.end br label %cond_destruct_end cond_destruct_alt2: ; preds = %cond.end - call void @dtor.249(%Token* %"$tmpC3") + call void @dtor.238(%Token* %"$tmpC3") br label %cond_destruct_end cond_destruct_end: ; preds = %cond_destruct_alt2, %cond_destruct_alt1 - call void @dtor.249(%Token* %"$tmpC1") + call void @dtor.238(%Token* %"$tmpC1") br label %while_block while_block: ; preds = %while_step, %cond_destruct_end %15 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @front.481(%Token* %"$tmpC5", %"RangeWithLookahead[SparrowScanner]"* %15) + call void @front.470(%Token* %"$tmpC5", %"RangeWithLookahead[SparrowScanner]"* %15) %16 = getelementptr inbounds %Token, %Token* %"$tmpC5", i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this6, i32 1) - %17 = call i1 @"==.339"(%TokenType* %16, %TokenType* %tmp.this6) + call void @ctor.393(%TokenType* %tmp.this6, i32 1) + %17 = call i1 @"==.328"(%TokenType* %16, %TokenType* %tmp.this6) br i1 %17, label %while_body, label %while_end while_body: ; preds = %while_block %18 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @popFront.485(%"RangeWithLookahead[SparrowScanner]"* %18) + call void @popFront.474(%"RangeWithLookahead[SparrowScanner]"* %18) br label %while_step while_step: ; preds = %while_body br label %while_block while_end: ; preds = %while_block - call void @dtor.249(%Token* %"$tmpC5") + call void @dtor.238(%Token* %"$tmpC5") %19 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @front.481(%Token* %tk, %"RangeWithLookahead[SparrowScanner]"* %19) + call void @front.470(%Token* %tk, %"RangeWithLookahead[SparrowScanner]"* %19) %20 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - %21 = call i1 @isEmpty.403(%"Vector[Char]"* %20) + %21 = call i1 @isEmpty.392(%"Vector[Char]"* %20) br i1 %21, label %cond.true7, label %cond.false8 cond.true7: ; preds = %while_end @@ -17564,7 +17085,7 @@ cond.true7: ; preds = %while_end cond.false8: ; preds = %while_end %22 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - %23 = call i8* @back.499(%"Vector[Char]"* %22) + %23 = call i8* @back.487(%"Vector[Char]"* %22) %24 = load i8, i8* %23 %25 = icmp eq i8 %24, 123 br label %cond.end9 @@ -17585,13 +17106,13 @@ if_then12: ; preds = %cond.end16 %30 = load i32, i32* %29 store i32 %30, i32* %newCol %31 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - %32 = call i32* @back.500(%"Vector[UInt]"* %31) + %32 = call i32* @back.488(%"Vector[Int]"* %31) %33 = load i32, i32* %32 store i32 %33, i32* %oldCol br label %if_block18 -if_end13: ; preds = %cond_destruct_end84, %cond.end16 - br label %if_block85 +if_end13: ; preds = %if_end64, %cond.end16 + br label %if_block80 cond.true14: ; preds = %if_block11 %34 = load i1, i1* %outsideParens @@ -17606,274 +17127,278 @@ cond.end16: ; preds = %cond.false15, %cond if_block18: ; preds = %if_then12 %35 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this21, i32 0) - %36 = call i1 @"==.339"(%TokenType* %35, %TokenType* %tmp.this21) + call void @ctor.393(%TokenType* %tmp.this21, i32 0) + %36 = call i1 @"==.328"(%TokenType* %35, %TokenType* %tmp.this21) br i1 %36, label %if_then19, label %if_end20 if_then19: ; preds = %if_block18 - store i32 1, i32* %tmp.this22 - %37 = load i32, i32* %tmp.this22 - store i32 %37, i32* %newCol + store i32 1, i32* %newCol br label %if_end20 if_end20: ; preds = %if_then19, %if_block18 - br label %if_block23 - -if_block23: ; preds = %if_end20 - %38 = load i32, i32* %newCol - %39 = load i32, i32* %oldCol - %40 = icmp eq i32 %38, %39 - br i1 %40, label %cond.true32, label %cond.false33 - -if_then24: ; preds = %cond.end28 - %41 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @ctor.404(%TokenType* %tmp.this41, i32 32) - call void @"=.286"(%TokenType* %41, %TokenType* %tmp.this41) - %42 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 - store i32 1, i32* %42 - br label %if_end25 - -if_end25: ; preds = %if_then24, %cond.end28 - br i1 %cond.res38, label %cond_destruct_alt142, label %cond_destruct_alt243 - -cond.true26: ; preds = %cond.end31 - call void @ctor.404(%TokenType* %tmp.this39, i32 26) - %43 = call i1 @"==.339"(%TokenType* %oldType, %TokenType* %tmp.this39) - %44 = xor i1 true, %43 - br label %cond.end28 + br label %if_block22 -cond.false27: ; preds = %cond.end31 - br label %cond.end28 +if_block22: ; preds = %if_end20 + %37 = load i32, i32* %newCol + %38 = load i32, i32* %oldCol + %39 = call i1 @_Int32_opEQ(i32 %37, i32 %38) + br i1 %39, label %cond.true31, label %cond.false32 + +if_then23: ; preds = %cond.end27 + %40 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 + call void @ctor.393(%TokenType* %tmp.this40, i32 32) + call void @"=.275"(%TokenType* %40, %TokenType* %tmp.this40) + %41 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 + store i32 1, i32* %41 + br label %if_end24 -cond.end28: ; preds = %cond.false27, %cond.true26 - %cond.res40 = phi i1 [ %44, %cond.true26 ], [ false, %cond.false27 ] - br i1 %cond.res40, label %if_then24, label %if_end25 +if_end24: ; preds = %if_then23, %cond.end27 + br i1 %cond.res37, label %cond_destruct_alt141, label %cond_destruct_alt242 -cond.true29: ; preds = %cond.end34 - call void @ctor.404(%TokenType* %tmp.this37, i32 32) - %45 = call i1 @"==.339"(%TokenType* %oldType, %TokenType* %tmp.this37) - %46 = xor i1 true, %45 - br label %cond.end31 +cond.true25: ; preds = %cond.end30 + call void @ctor.393(%TokenType* %tmp.this38, i32 26) + %42 = call i1 @"==.328"(%TokenType* %oldType, %TokenType* %tmp.this38) + %43 = xor i1 true, %42 + br label %cond.end27 -cond.false30: ; preds = %cond.end34 - br label %cond.end31 +cond.false26: ; preds = %cond.end30 + br label %cond.end27 -cond.end31: ; preds = %cond.false30, %cond.true29 - %cond.res38 = phi i1 [ %46, %cond.true29 ], [ false, %cond.false30 ] - br i1 %cond.res38, label %cond.true26, label %cond.false27 - -cond.true32: ; preds = %if_block23 - %47 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this35, i32 25) - %48 = call i1 @"==.339"(%TokenType* %47, %TokenType* %tmp.this35) - %49 = xor i1 true, %48 - br label %cond.end34 +cond.end27: ; preds = %cond.false26, %cond.true25 + %cond.res39 = phi i1 [ %43, %cond.true25 ], [ false, %cond.false26 ] + br i1 %cond.res39, label %if_then23, label %if_end24 -cond.false33: ; preds = %if_block23 - br label %cond.end34 +cond.true28: ; preds = %cond.end33 + call void @ctor.393(%TokenType* %tmp.this36, i32 32) + %44 = call i1 @"==.328"(%TokenType* %oldType, %TokenType* %tmp.this36) + %45 = xor i1 true, %44 + br label %cond.end30 -cond.end34: ; preds = %cond.false33, %cond.true32 - %cond.res36 = phi i1 [ %49, %cond.true32 ], [ false, %cond.false33 ] - br i1 %cond.res36, label %cond.true29, label %cond.false30 +cond.false29: ; preds = %cond.end33 + br label %cond.end30 -cond_destruct_alt142: ; preds = %if_end25 - br label %cond_destruct_end44 +cond.end30: ; preds = %cond.false29, %cond.true28 + %cond.res37 = phi i1 [ %45, %cond.true28 ], [ false, %cond.false29 ] + br i1 %cond.res37, label %cond.true25, label %cond.false26 + +cond.true31: ; preds = %if_block22 + %46 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this34, i32 25) + %47 = call i1 @"==.328"(%TokenType* %46, %TokenType* %tmp.this34) + %48 = xor i1 true, %47 + br label %cond.end33 -cond_destruct_alt243: ; preds = %if_end25 - br label %cond_destruct_end44 +cond.false32: ; preds = %if_block22 + br label %cond.end33 -cond_destruct_end44: ; preds = %cond_destruct_alt243, %cond_destruct_alt142 - br i1 %cond.res36, label %cond_destruct_alt145, label %cond_destruct_alt246 +cond.end33: ; preds = %cond.false32, %cond.true31 + %cond.res35 = phi i1 [ %48, %cond.true31 ], [ false, %cond.false32 ] + br i1 %cond.res35, label %cond.true28, label %cond.false29 -cond_destruct_alt145: ; preds = %cond_destruct_end44 - br label %cond_destruct_end47 +cond_destruct_alt141: ; preds = %if_end24 + br label %cond_destruct_end43 -cond_destruct_alt246: ; preds = %cond_destruct_end44 - br label %cond_destruct_end47 +cond_destruct_alt242: ; preds = %if_end24 + br label %cond_destruct_end43 -cond_destruct_end47: ; preds = %cond_destruct_alt246, %cond_destruct_alt145 - br i1 %40, label %cond_destruct_alt148, label %cond_destruct_alt249 +cond_destruct_end43: ; preds = %cond_destruct_alt242, %cond_destruct_alt141 + br i1 %cond.res35, label %cond_destruct_alt144, label %cond_destruct_alt245 -cond_destruct_alt148: ; preds = %cond_destruct_end47 - br label %cond_destruct_end50 +cond_destruct_alt144: ; preds = %cond_destruct_end43 + br label %cond_destruct_end46 -cond_destruct_alt249: ; preds = %cond_destruct_end47 - br label %cond_destruct_end50 +cond_destruct_alt245: ; preds = %cond_destruct_end43 + br label %cond_destruct_end46 -cond_destruct_end50: ; preds = %cond_destruct_alt249, %cond_destruct_alt148 - br label %if_block51 +cond_destruct_end46: ; preds = %cond_destruct_alt245, %cond_destruct_alt144 + br i1 %39, label %cond_destruct_alt147, label %cond_destruct_alt248 -if_block51: ; preds = %cond_destruct_end50 - %50 = load i32, i32* %newCol - %51 = load i32, i32* %oldCol - %52 = icmp sgt i32 %50, %51 - br i1 %52, label %cond.true54, label %cond.false55 +cond_destruct_alt147: ; preds = %cond_destruct_end46 + br label %cond_destruct_end49 -if_then52: ; preds = %cond.end56 - %53 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @ctor.404(%TokenType* %tmp.this59, i32 25) - call void @"=.286"(%TokenType* %53, %TokenType* %tmp.this59) - %54 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 - store i32 1, i32* %54 - %55 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - %56 = load i32, i32* %newCol - call void @"+=.474"(%"Vector[UInt]"* %55, i32 %56) - br label %if_end53 +cond_destruct_alt248: ; preds = %cond_destruct_end46 + br label %cond_destruct_end49 -if_end53: ; preds = %if_then52, %cond.end56 - br i1 %52, label %cond_destruct_alt160, label %cond_destruct_alt261 +cond_destruct_end49: ; preds = %cond_destruct_alt248, %cond_destruct_alt147 + br label %if_block50 -cond.true54: ; preds = %if_block51 - %57 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this57, i32 0) - %58 = call i1 @"==.339"(%TokenType* %57, %TokenType* %tmp.this57) - %59 = xor i1 true, %58 - br label %cond.end56 +if_block50: ; preds = %cond_destruct_end49 + %49 = load i32, i32* %newCol + %50 = load i32, i32* %oldCol + %51 = call i1 @_Int32_opGT(i32 %49, i32 %50) + br i1 %51, label %cond.true53, label %cond.false54 + +if_then51: ; preds = %cond.end55 + %52 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 + call void @ctor.393(%TokenType* %tmp.this58, i32 25) + call void @"=.275"(%TokenType* %52, %TokenType* %tmp.this58) + %53 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 + store i32 1, i32* %53 + %54 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 + %55 = load i32, i32* %newCol + call void @"+=.463"(%"Vector[Int]"* %54, i32 %55) + br label %if_end52 + +if_end52: ; preds = %if_then51, %cond.end55 + br i1 %51, label %cond_destruct_alt159, label %cond_destruct_alt260 + +cond.true53: ; preds = %if_block50 + %56 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this56, i32 0) + %57 = call i1 @"==.328"(%TokenType* %56, %TokenType* %tmp.this56) + %58 = xor i1 true, %57 + br label %cond.end55 + +cond.false54: ; preds = %if_block50 + br label %cond.end55 + +cond.end55: ; preds = %cond.false54, %cond.true53 + %cond.res57 = phi i1 [ %58, %cond.true53 ], [ false, %cond.false54 ] + br i1 %cond.res57, label %if_then51, label %if_end52 + +cond_destruct_alt159: ; preds = %if_end52 + br label %cond_destruct_end61 + +cond_destruct_alt260: ; preds = %if_end52 + br label %cond_destruct_end61 + +cond_destruct_end61: ; preds = %cond_destruct_alt260, %cond_destruct_alt159 + br label %if_block62 -cond.false55: ; preds = %if_block51 - br label %cond.end56 +if_block62: ; preds = %cond_destruct_end61 + %59 = load i32, i32* %newCol + %60 = load i32, i32* %oldCol + %61 = call i1 @_Int32_opLT(i32 %59, i32 %60) + br i1 %61, label %cond.true65, label %cond.false66 -cond.end56: ; preds = %cond.false55, %cond.true54 - %cond.res58 = phi i1 [ %59, %cond.true54 ], [ false, %cond.false55 ] - br i1 %cond.res58, label %if_then52, label %if_end53 +if_then63: ; preds = %cond.end67 + store i32 0, i32* %numDedents + br label %while_block69 -cond_destruct_alt160: ; preds = %if_end53 - br label %cond_destruct_end62 +if_end64: ; preds = %if_end76, %cond.end67 + br label %if_end13 -cond_destruct_alt261: ; preds = %if_end53 - br label %cond_destruct_end62 +cond.true65: ; preds = %if_block62 + %62 = load i32, i32* %newCol + %63 = call i1 @_Int32_opGE(i32 %62, i32 1) + br label %cond.end67 -cond_destruct_end62: ; preds = %cond_destruct_alt261, %cond_destruct_alt160 - br label %if_block63 +cond.false66: ; preds = %if_block62 + br label %cond.end67 -if_block63: ; preds = %cond_destruct_end62 - %60 = load i32, i32* %newCol - %61 = load i32, i32* %oldCol - %62 = icmp slt i32 %60, %61 - br i1 %62, label %cond.true66, label %cond.false67 +cond.end67: ; preds = %cond.false66, %cond.true65 + %cond.res68 = phi i1 [ %63, %cond.true65 ], [ false, %cond.false66 ] + br i1 %cond.res68, label %if_then63, label %if_end64 + +while_block69: ; preds = %while_step71, %if_then63 + %64 = load i32, i32* %newCol + %65 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 + %66 = call i32* @back.488(%"Vector[Int]"* %65) + %67 = load i32, i32* %66 + %68 = call i1 @_Int32_opLT(i32 %64, i32 %67) + br i1 %68, label %while_body70, label %while_end72 + +while_body70: ; preds = %while_block69 + %69 = call i32 @"post_++.33"(i32* %numDedents) + %70 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 + call void @popBack.489(%"Vector[Int]"* %70) + br label %while_step71 + +while_step71: ; preds = %while_body70 + br label %while_block69 + +while_end72: ; preds = %while_block69 + %71 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 + call void @ctor.393(%TokenType* %tmp.this73, i32 32) + call void @"=.275"(%TokenType* %71, %TokenType* %tmp.this73) + %72 = load i32, i32* %numDedents + %73 = call i32 @_Int32_opPlus(i32 1, i32 %72) + %74 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 + store i32 %73, i32* %74 + br label %if_block74 -if_then64: ; preds = %cond.end68 - store i32 0, i32* %numDedents - br label %while_block71 - -if_end65: ; preds = %if_end78, %cond.end68 - br i1 %62, label %cond_destruct_alt182, label %cond_destruct_alt283 - -cond.true66: ; preds = %if_block63 - %63 = load i32, i32* %newCol - store i32 1, i32* %tmp.this69 - %64 = load i32, i32* %tmp.this69 - %65 = icmp sge i32 %63, %64 - br label %cond.end68 - -cond.false67: ; preds = %if_block63 - br label %cond.end68 - -cond.end68: ; preds = %cond.false67, %cond.true66 - %cond.res70 = phi i1 [ %65, %cond.true66 ], [ false, %cond.false67 ] - br i1 %cond.res70, label %if_then64, label %if_end65 - -while_block71: ; preds = %while_step73, %if_then64 - %66 = load i32, i32* %newCol - %67 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - %68 = call i32* @back.500(%"Vector[UInt]"* %67) - %69 = load i32, i32* %68 - %70 = icmp slt i32 %66, %69 - br i1 %70, label %while_body72, label %while_end74 - -while_body72: ; preds = %while_block71 - %71 = call i32 @"post_++.39"(i32* %numDedents) - %72 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - call void @popBack.502(%"Vector[UInt]"* %72) - br label %while_step73 - -while_step73: ; preds = %while_body72 - br label %while_block71 - -while_end74: ; preds = %while_block71 - %73 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @ctor.404(%TokenType* %tmp.this75, i32 32) - call void @"=.286"(%TokenType* %73, %TokenType* %tmp.this75) - %74 = load i32, i32* %numDedents - %75 = add i32 1, %74 - %76 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 - store i32 %75, i32* %76 - br label %if_block76 +if_block74: ; preds = %while_end72 + %75 = load i32, i32* %newCol + %76 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 + %77 = call i32* @back.488(%"Vector[Int]"* %76) + %78 = load i32, i32* %77 + %79 = call i1 @_Int32_opNE(i32 %75, i32 %78) + br i1 %79, label %if_then75, label %if_end76 -if_block76: ; preds = %while_end74 - %77 = load i32, i32* %newCol - %78 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - %79 = call i32* @back.500(%"Vector[UInt]"* %78) - %80 = load i32, i32* %79 - %81 = icmp ne i32 %77, %80 - br i1 %81, label %if_then77, label %if_end78 +if_then75: ; preds = %if_block74 + %80 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 1 + %81 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 0 + %82 = load %Location, %Location* %81 + %83 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 + %84 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %85 = bitcast %UntypedPtr* %83 to i8** + %86 = bitcast %UntypedPtr* %84 to i8** + store i8* getelementptr inbounds ([32 x i8], [32 x i8]* @str.40, i32 0, i32 0), i8** %85 + store i8* getelementptr inbounds ([32 x i8], [32 x i8]* @str.40, i32 0, i32 31), i8** %86 + %87 = load %StringRef, %StringRef* %tmp.StringRef + store %StringRef %87, %StringRef* %"$tmpForRef" + %88 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 + %89 = call i32* @back.488(%"Vector[Int]"* %88) + %90 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef79, i32 0, i32 0 + %91 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef79, i32 0, i32 1 + %92 = bitcast %UntypedPtr* %90 to i8** + %93 = bitcast %UntypedPtr* %91 to i8** + store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.41, i32 0, i32 0), i8** %92 + store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.41, i32 0, i32 6), i8** %93 + %94 = load %StringRef, %StringRef* %tmp.StringRef79 + store %StringRef %94, %StringRef* %"$tmpForRef78" + call void @toString.490(%String* %"$tmpC77", %StringRef* %"$tmpForRef", i32* %89, %StringRef* %"$tmpForRef78", i32* %newCol) + call void @reportError.426(%ErrorReporter* %80, %Location %82, %String* %"$tmpC77") + call void @dtor.239(%String* %"$tmpC77") + br label %if_end76 -if_then77: ; preds = %if_block76 - %82 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 1 - %83 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 0 - %84 = load %Location, %Location* %83 - %85 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 - %86 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 - %87 = bitcast %UntypedPtr* %85 to i8** - %88 = bitcast %UntypedPtr* %86 to i8** - store i8* getelementptr inbounds ([32 x i8], [32 x i8]* @str.40, i32 0, i32 0), i8** %87 - store i8* getelementptr inbounds ([32 x i8], [32 x i8]* @str.40, i32 0, i32 31), i8** %88 - %89 = load %StringRef, %StringRef* %tmp.StringRef - store %StringRef %89, %StringRef* %"$tmpForRef" - %90 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 2 - %91 = call i32* @back.500(%"Vector[UInt]"* %90) - %92 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef81, i32 0, i32 0 - %93 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef81, i32 0, i32 1 - %94 = bitcast %UntypedPtr* %92 to i8** - %95 = bitcast %UntypedPtr* %93 to i8** - store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.41, i32 0, i32 0), i8** %94 - store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.41, i32 0, i32 6), i8** %95 - %96 = load %StringRef, %StringRef* %tmp.StringRef81 - store %StringRef %96, %StringRef* %"$tmpForRef80" - call void @toString.503(%String* %"$tmpC79", %StringRef* %"$tmpForRef", i32* %91, %StringRef* %"$tmpForRef80", i32* %newCol) - call void @reportError.437(%ErrorReporter* %82, %Location %84, %String* %"$tmpC79") - call void @dtor.250(%String* %"$tmpC79") - br label %if_end78 +if_end76: ; preds = %if_then75, %if_block74 + br label %if_end64 -if_end78: ; preds = %if_then77, %if_block76 - br label %if_end65 +if_block80: ; preds = %if_end13 + %95 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this83, i32 29) + %96 = call i1 @"==.328"(%TokenType* %95, %TokenType* %tmp.this83) + br i1 %96, label %if_then81, label %if_else -cond_destruct_alt182: ; preds = %if_end65 - br label %cond_destruct_end84 +if_then81: ; preds = %if_block80 + %97 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + call void @"+="(%"Vector[Char]"* %97, i8 40) + br label %if_end82 -cond_destruct_alt283: ; preds = %if_end65 - br label %cond_destruct_end84 +if_else: ; preds = %if_block80 + br label %if_block84 -cond_destruct_end84: ; preds = %cond_destruct_alt283, %cond_destruct_alt182 - br label %if_end13 +if_end82: ; preds = %if_end87, %if_then81 + call void @dtor.238(%Token* %tk) + ret void -if_block85: ; preds = %if_end13 - %97 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this88, i32 29) - %98 = call i1 @"==.339"(%TokenType* %97, %TokenType* %tmp.this88) - br i1 %98, label %if_then86, label %if_else +if_block84: ; preds = %if_else + %98 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this88, i32 27) + %99 = call i1 @"==.328"(%TokenType* %98, %TokenType* %tmp.this88) + br i1 %99, label %if_then85, label %if_else86 -if_then86: ; preds = %if_block85 - %99 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @"+="(%"Vector[Char]"* %99, i8 40) +if_then85: ; preds = %if_block84 + %100 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + call void @"+="(%"Vector[Char]"* %100, i8 91) br label %if_end87 -if_else: ; preds = %if_block85 +if_else86: ; preds = %if_block84 br label %if_block89 -if_end87: ; preds = %if_end92, %if_then86 - call void @dtor.249(%Token* %tk) - ret void +if_end87: ; preds = %if_end92, %if_then85 + br label %if_end82 -if_block89: ; preds = %if_else - %100 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this93, i32 27) - %101 = call i1 @"==.339"(%TokenType* %100, %TokenType* %tmp.this93) - br i1 %101, label %if_then90, label %if_else91 +if_block89: ; preds = %if_else86 + %101 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this93, i32 25) + %102 = call i1 @"==.328"(%TokenType* %101, %TokenType* %tmp.this93) + br i1 %102, label %if_then90, label %if_else91 if_then90: ; preds = %if_block89 - %102 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @"+="(%"Vector[Char]"* %102, i8 91) + %103 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + call void @"+="(%"Vector[Char]"* %103, i8 123) br label %if_end92 if_else91: ; preds = %if_block89 @@ -17883,216 +17408,193 @@ if_end92: ; preds = %if_end97, %if_then9 br label %if_end87 if_block94: ; preds = %if_else91 - %103 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this98, i32 25) - %104 = call i1 @"==.339"(%TokenType* %103, %TokenType* %tmp.this98) - br i1 %104, label %if_then95, label %if_else96 - -if_then95: ; preds = %if_block94 - %105 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @"+="(%"Vector[Char]"* %105, i8 123) + %104 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this101, i32 30) + %105 = call i1 @"==.328"(%TokenType* %104, %TokenType* %tmp.this101) + br i1 %105, label %cond.true98, label %cond.false99 + +if_then95: ; preds = %cond.end100 + %106 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + call void @popBack.491(%"Vector[Char]"* %106) br label %if_end97 -if_else96: ; preds = %if_block94 - br label %if_block99 +if_else96: ; preds = %cond.end100 + br label %if_block103 -if_end97: ; preds = %if_end102, %if_then95 +if_end97: ; preds = %if_end106, %if_then95 br label %if_end92 -if_block99: ; preds = %if_else96 - %106 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this106, i32 30) - %107 = call i1 @"==.339"(%TokenType* %106, %TokenType* %tmp.this106) - br i1 %107, label %cond.true103, label %cond.false104 - -if_then100: ; preds = %cond.end105 - %108 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @popBack.506(%"Vector[Char]"* %108) - br label %if_end102 - -if_else101: ; preds = %cond.end105 - br label %if_block108 - -if_end102: ; preds = %if_end111, %if_then100 - br label %if_end97 - -cond.true103: ; preds = %if_block99 - %109 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - %110 = call i8* @back.499(%"Vector[Char]"* %109) - %111 = load i8, i8* %110 - %112 = icmp eq i8 %111, 40 - br label %cond.end105 - -cond.false104: ; preds = %if_block99 - br label %cond.end105 - -cond.end105: ; preds = %cond.false104, %cond.true103 - %cond.res107 = phi i1 [ %112, %cond.true103 ], [ false, %cond.false104 ] - br i1 %cond.res107, label %if_then100, label %if_else101 - -if_block108: ; preds = %if_else101 - %113 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this115, i32 28) - %114 = call i1 @"==.339"(%TokenType* %113, %TokenType* %tmp.this115) - br i1 %114, label %cond.true112, label %cond.false113 - -if_then109: ; preds = %cond.end114 - %115 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @popBack.506(%"Vector[Char]"* %115) - br label %if_end111 +cond.true98: ; preds = %if_block94 + %107 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + %108 = call i8* @back.487(%"Vector[Char]"* %107) + %109 = load i8, i8* %108 + %110 = icmp eq i8 %109, 40 + br label %cond.end100 -if_else110: ; preds = %cond.end114 - br label %if_block117 +cond.false99: ; preds = %if_block94 + br label %cond.end100 -if_end111: ; preds = %if_end119, %if_then109 - br label %if_end102 +cond.end100: ; preds = %cond.false99, %cond.true98 + %cond.res102 = phi i1 [ %110, %cond.true98 ], [ false, %cond.false99 ] + br i1 %cond.res102, label %if_then95, label %if_else96 -cond.true112: ; preds = %if_block108 - %116 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - %117 = call i8* @back.499(%"Vector[Char]"* %116) - %118 = load i8, i8* %117 - %119 = icmp eq i8 %118, 91 - br label %cond.end114 +if_block103: ; preds = %if_else96 + %111 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this110, i32 28) + %112 = call i1 @"==.328"(%TokenType* %111, %TokenType* %tmp.this110) + br i1 %112, label %cond.true107, label %cond.false108 -cond.false113: ; preds = %if_block108 - br label %cond.end114 +if_then104: ; preds = %cond.end109 + %113 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + call void @popBack.491(%"Vector[Char]"* %113) + br label %if_end106 -cond.end114: ; preds = %cond.false113, %cond.true112 - %cond.res116 = phi i1 [ %119, %cond.true112 ], [ false, %cond.false113 ] - br i1 %cond.res116, label %if_then109, label %if_else110 - -if_block117: ; preds = %if_else110 - %120 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this123, i32 26) - %121 = call i1 @"==.339"(%TokenType* %120, %TokenType* %tmp.this123) - br i1 %121, label %cond.true120, label %cond.false121 - -if_then118: ; preds = %cond.end122 - %122 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - call void @popBack.506(%"Vector[Char]"* %122) - br label %if_end119 +if_else105: ; preds = %cond.end109 + br label %if_block112 -if_end119: ; preds = %if_then118, %cond.end122 - br label %if_end111 +if_end106: ; preds = %if_end114, %if_then104 + br label %if_end97 -cond.true120: ; preds = %if_block117 - %123 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 - %124 = call i8* @back.499(%"Vector[Char]"* %123) - %125 = load i8, i8* %124 - %126 = icmp eq i8 %125, 123 - br label %cond.end122 +cond.true107: ; preds = %if_block103 + %114 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + %115 = call i8* @back.487(%"Vector[Char]"* %114) + %116 = load i8, i8* %115 + %117 = icmp eq i8 %116, 91 + br label %cond.end109 + +cond.false108: ; preds = %if_block103 + br label %cond.end109 + +cond.end109: ; preds = %cond.false108, %cond.true107 + %cond.res111 = phi i1 [ %117, %cond.true107 ], [ false, %cond.false108 ] + br i1 %cond.res111, label %if_then104, label %if_else105 + +if_block112: ; preds = %if_else105 + %118 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 + call void @ctor.393(%TokenType* %tmp.this118, i32 26) + %119 = call i1 @"==.328"(%TokenType* %118, %TokenType* %tmp.this118) + br i1 %119, label %cond.true115, label %cond.false116 + +if_then113: ; preds = %cond.end117 + %120 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + call void @popBack.491(%"Vector[Char]"* %120) + br label %if_end114 + +if_end114: ; preds = %if_then113, %cond.end117 + br label %if_end106 + +cond.true115: ; preds = %if_block112 + %121 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 3 + %122 = call i8* @back.487(%"Vector[Char]"* %121) + %123 = load i8, i8* %122 + %124 = icmp eq i8 %123, 123 + br label %cond.end117 -cond.false121: ; preds = %if_block117 - br label %cond.end122 +cond.false116: ; preds = %if_block112 + br label %cond.end117 -cond.end122: ; preds = %cond.false121, %cond.true120 - %cond.res124 = phi i1 [ %126, %cond.true120 ], [ false, %cond.false121 ] - br i1 %cond.res124, label %if_then118, label %if_end119 +cond.end117: ; preds = %cond.false116, %cond.true115 + %cond.res119 = phi i1 [ %124, %cond.true115 ], [ false, %cond.false116 ] + br i1 %cond.res119, label %if_then113, label %if_end114 } ; Function Attrs: inlinehint nounwind -define internal void @front.484(%Token* sret %_result, %"SparrowLayoutDecoder[SparrowScanner]"* %this) #4 { +define internal void @front.473(%Token* sret %_result, %"SparrowLayoutDecoder[SparrowScanner]"* %this) #4 { %tk = alloca %Token br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - call void @front.481(%Token* %tk, %"RangeWithLookahead[SparrowScanner]"* %1) + call void @front.470(%Token* %tk, %"RangeWithLookahead[SparrowScanner]"* %1) br label %if_block if_block: ; preds = %code %2 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 %3 = load i32, i32* %2 - %4 = icmp sgt i32 %3, 0 + %4 = call i1 @_Int32_opGT(i32 %3, i32 0) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block %5 = getelementptr inbounds %Token, %Token* %tk, i32 0, i32 1 %6 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 4 - call void @"=.286"(%TokenType* %5, %TokenType* %6) + call void @"=.275"(%TokenType* %5, %TokenType* %6) br label %if_end if_end: ; preds = %if_then, %if_block - call void @ctor.188(%Token* %_result, %Token* %tk) - call void @dtor.249(%Token* %tk) + call void @ctor.177(%Token* %_result, %Token* %tk) + call void @dtor.238(%Token* %tk) ret void dumy_block: ; No predecessors! - call void @dtor.249(%Token* %tk) + call void @dtor.238(%Token* %tk) ret void } ; Function Attrs: inlinehint nounwind -define internal void @popFront.485(%"RangeWithLookahead[SparrowScanner]"* %this) #4 { - %tmp.this = alloca i64 +define internal void @popFront.474(%"RangeWithLookahead[SparrowScanner]"* %this) #4 { %"$tmpC" = alloca %Token br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - store i64 0, i64* %tmp.this - %2 = load i64, i64* %tmp.this - call void @remove.486(%"Vector[Token]"* %1, i64 %2) + call void @remove.475(%"Vector[Token]"* %1, i32 0) br label %if_block if_block: ; preds = %code - %3 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - %4 = call i1 @isEmpty.480(%"Vector[Token]"* %3) - br i1 %4, label %cond.true, label %cond.false + %2 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 + %3 = call i1 @isEmpty.469(%"Vector[Token]"* %2) + br i1 %3, label %cond.true, label %cond.false if_then: ; preds = %cond.end - %5 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 - %6 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - call void @"post_++.398"(%Token* %"$tmpC", %SparrowScanner* %6) - call void @"+=.396"(%"Vector[Token]"* %5, %Token* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC") + %4 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 1 + %5 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 + call void @"post_++.387"(%Token* %"$tmpC", %SparrowScanner* %5) + call void @"+=.385"(%"Vector[Token]"* %4, %Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") br label %if_end if_end: ; preds = %if_then, %cond.end ret void cond.true: ; preds = %if_block - %7 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 - %8 = call i1 @"pre_!!.394"(%SparrowScanner* %7) + %6 = getelementptr inbounds %"RangeWithLookahead[SparrowScanner]", %"RangeWithLookahead[SparrowScanner]"* %this, i32 0, i32 0 + %7 = call i1 @"pre_!!.383"(%SparrowScanner* %6) br label %cond.end cond.false: ; preds = %if_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %8, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %7, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %if_then, label %if_end } ; Function Attrs: inlinehint nounwind -define internal void @remove.486(%"Vector[Token]"* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal void @remove.475(%"Vector[Token]"* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %r = alloca %"ContiguousMemoryRange[Token]" %"$tmpForRef" = alloca %"ContiguousMemoryRange[Token]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 - %1 = call %"ContiguousMemoryRange[Token]" @all.488(%"Vector[Token]"* %this) + %1 = call %"ContiguousMemoryRange[Token]" @all.477(%"Vector[Token]"* %this) store %"ContiguousMemoryRange[Token]" %1, %"ContiguousMemoryRange[Token]"* %"$tmpForRef" - call void @ctor.487(%"ContiguousMemoryRange[Token]"* %r, %"ContiguousMemoryRange[Token]"* %"$tmpForRef") - %2 = load i64, i64* %index.addr - call void @popFront.490(%"ContiguousMemoryRange[Token]"* %r, i64 %2) - %3 = call i64 @size.195(%"Vector[Token]"* %this) - %4 = load i64, i64* %index.addr - %5 = call i64 @_SizeType_opMinus(i64 %3, i64 %4) - store i64 1, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = call i64 @_SizeType_opMinus(i64 %5, i64 %6) - call void @popBack.492(%"ContiguousMemoryRange[Token]"* %r, i64 %7) - %8 = load %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %r - call void @remove.493(%"Vector[Token]"* %this, %"ContiguousMemoryRange[Token]" %8) + call void @ctor.476(%"ContiguousMemoryRange[Token]"* %r, %"ContiguousMemoryRange[Token]"* %"$tmpForRef") + %2 = load i32, i32* %index.addr + call void @popFront.479(%"ContiguousMemoryRange[Token]"* %r, i32 %2) + %3 = call i32 @size.184(%"Vector[Token]"* %this) + %4 = load i32, i32* %index.addr + %5 = call i32 @_Int32_opMinus(i32 %3, i32 %4) + %6 = call i32 @_Int32_opMinus(i32 %5, i32 1) + call void @popBack.480(%"ContiguousMemoryRange[Token]"* %r, i32 %6) + %7 = load %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %r + call void @remove.481(%"Vector[Token]"* %this, %"ContiguousMemoryRange[Token]" %7) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.487(%"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"* %other) #3 { +define internal void @ctor.476(%"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"* %other) #3 { %other.addr = alloca %"ContiguousMemoryRange[Token]"* store %"ContiguousMemoryRange[Token]"* %other, %"ContiguousMemoryRange[Token]"** %other.addr br label %code @@ -18101,16 +17603,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 %2 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %other.addr %3 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %2, i32 0, i32 0 - call void @ctor.204(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) + call void @ctor.193(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) %4 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 1 %5 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %other.addr %6 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %5, i32 0, i32 1 - call void @ctor.204(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) + call void @ctor.193(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) ret void } ; Function Attrs: inlinehint nounwind -define internal %"ContiguousMemoryRange[Token]" @all.488(%"Vector[Token]"* %this) #4 { +define internal %"ContiguousMemoryRange[Token]" @all.477(%"Vector[Token]"* %this) #4 { %tmp.this = alloca %"ContiguousMemoryRange[Token]" br label %code @@ -18119,13 +17621,13 @@ code: ; preds = %0 %2 = load %"RawPtr[Token]", %"RawPtr[Token]"* %1 %3 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %4 = load %"RawPtr[Token]", %"RawPtr[Token]"* %3 - call void @ctor.489(%"ContiguousMemoryRange[Token]"* %tmp.this, %"RawPtr[Token]" %2, %"RawPtr[Token]" %4) + call void @ctor.478(%"ContiguousMemoryRange[Token]"* %tmp.this, %"RawPtr[Token]" %2, %"RawPtr[Token]" %4) %5 = load %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %tmp.this ret %"ContiguousMemoryRange[Token]" %5 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.489(%"ContiguousMemoryRange[Token]"* %this, %"RawPtr[Token]" %f_begin, %"RawPtr[Token]" %f_end) #3 { +define internal void @ctor.478(%"ContiguousMemoryRange[Token]"* %this, %"RawPtr[Token]" %f_begin, %"RawPtr[Token]" %f_end) #3 { %this.addr = alloca %"ContiguousMemoryRange[Token]"* store %"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"** %this.addr %f_begin.addr = alloca %"RawPtr[Token]" @@ -18137,83 +17639,50 @@ define internal void @ctor.489(%"ContiguousMemoryRange[Token]"* %this, %"RawPtr[ code: ; preds = %0 %1 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %this.addr %2 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %1, i32 0, i32 0 - call void @ctor.204(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %f_begin.addr) + call void @ctor.193(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %f_begin.addr) %3 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %this.addr %4 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %3, i32 0, i32 1 - call void @ctor.204(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %f_end.addr) + call void @ctor.193(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %f_end.addr) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.490(%"ContiguousMemoryRange[Token]"* %this, i64 %n) #3 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @popFront.479(%"ContiguousMemoryRange[Token]"* %this, i32 %n) #3 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %"RawPtr[Token]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 %2 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 - %3 = load i64, i64* %n.addr - store i64 %3, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call %"RawPtr[Token]" @advance.491(%"RawPtr[Token]"* %2, i64 %4) - store %"RawPtr[Token]" %5, %"RawPtr[Token]"* %"$tmpForRef" - call void @"=.198"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %"$tmpForRef") + %3 = load i32, i32* %n.addr + %4 = call %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %2, i32 %3) + store %"RawPtr[Token]" %4, %"RawPtr[Token]"* %"$tmpForRef" + call void @"=.187"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %"$tmpForRef") ret void } -; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Token]" @advance.491(%"RawPtr[Token]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %tmp.this = alloca %"RawPtr[Token]" - %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 - %tmp.this3 = alloca i64 - br label %code - -code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[Token]", %"RawPtr[Token]"* %this, i32 0, i32 0 - %2 = load %Token*, %Token** %1 - call void @ctor.197(%UntypedPtr* %tmp.this1, %Token* %2) - %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = load i64, i64* %n.addr - store i64 72, i64* %tmp.this3 - %5 = load i64, i64* %tmp.this3 - %6 = mul i64 %4, %5 - store i64 %6, i64* %tmp.this2 - %7 = load i64, i64* %tmp.this2 - %8 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %7) - call void @ctor.202(%"RawPtr[Token]"* %tmp.this, %UntypedPtr %8) - %9 = load %"RawPtr[Token]", %"RawPtr[Token]"* %tmp.this - ret %"RawPtr[Token]" %9 -} - -; Function Attrs: alwaysinline nounwind -define internal void @popBack.492(%"ContiguousMemoryRange[Token]"* %this, i64 %n) #3 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +; Function Attrs: alwaysinline nounwind +define internal void @popBack.480(%"ContiguousMemoryRange[Token]"* %this, i32 %n) #3 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %"$tmpForRef" = alloca %"RawPtr[Token]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 1 - %3 = load i64, i64* %n.addr - store i64 %3, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = sub i64 0, %4 - %6 = call %"RawPtr[Token]" @advance.491(%"RawPtr[Token]"* %2, i64 %5) - store %"RawPtr[Token]" %6, %"RawPtr[Token]"* %"$tmpForRef" - call void @"=.198"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %"$tmpForRef") + %3 = load i32, i32* %n.addr + %4 = call i32 @_Int32_opMinus1(i32 %3) + %5 = call %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %2, i32 %4) + store %"RawPtr[Token]" %5, %"RawPtr[Token]"* %"$tmpForRef" + call void @"=.187"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %"$tmpForRef") ret void } ; Function Attrs: inlinehint nounwind -define internal void @remove.493(%"Vector[Token]"* %this, %"ContiguousMemoryRange[Token]" %range) #4 { +define internal void @remove.481(%"Vector[Token]"* %this, %"ContiguousMemoryRange[Token]" %range) #4 { %range.addr = alloca %"ContiguousMemoryRange[Token]" store %"ContiguousMemoryRange[Token]" %range, %"ContiguousMemoryRange[Token]"* %range.addr %rBegin = alloca %"RawPtr[Token]" @@ -18227,29 +17696,29 @@ define internal void @remove.493(%"Vector[Token]"* %this, %"ContiguousMemoryRang br label %code code: ; preds = %0 - %1 = call %"RawPtr[Token]" @frontPtr.494(%"ContiguousMemoryRange[Token]"* %range.addr) + %1 = call %"RawPtr[Token]" @frontPtr.482(%"ContiguousMemoryRange[Token]"* %range.addr) store %"RawPtr[Token]" %1, %"RawPtr[Token]"* %"$tmpForRef" - call void @ctor.204(%"RawPtr[Token]"* %rBegin, %"RawPtr[Token]"* %"$tmpForRef") - %2 = call %"RawPtr[Token]" @backPtr.495(%"ContiguousMemoryRange[Token]"* %range.addr) + call void @ctor.193(%"RawPtr[Token]"* %rBegin, %"RawPtr[Token]"* %"$tmpForRef") + %2 = call %"RawPtr[Token]" @backPtr.483(%"ContiguousMemoryRange[Token]"* %range.addr) store %"RawPtr[Token]" %2, %"RawPtr[Token]"* %"$tmpForRef1" - call void @ctor.204(%"RawPtr[Token]"* %rEnd, %"RawPtr[Token]"* %"$tmpForRef1") - call void @ctor.487(%"ContiguousMemoryRange[Token]"* %"$rangeVar", %"ContiguousMemoryRange[Token]"* %range.addr) + call void @ctor.193(%"RawPtr[Token]"* %rEnd, %"RawPtr[Token]"* %"$tmpForRef1") + call void @ctor.476(%"ContiguousMemoryRange[Token]"* %"$rangeVar", %"ContiguousMemoryRange[Token]"* %range.addr) br label %while_block while_block: ; preds = %while_step, %code - %3 = call i1 @isEmpty.496(%"ContiguousMemoryRange[Token]"* %"$rangeVar") + %3 = call i1 @isEmpty.484(%"ContiguousMemoryRange[Token]"* %"$rangeVar") %4 = xor i1 true, %3 br i1 %4, label %while_body, label %while_end while_body: ; preds = %while_block - %5 = call %Token* @front.497(%"ContiguousMemoryRange[Token]"* %"$rangeVar") + %5 = call %Token* @front.485(%"ContiguousMemoryRange[Token]"* %"$rangeVar") store %Token* %5, %Token** %el %6 = load %Token*, %Token** %el - call void @dtor.249(%Token* %6) + call void @dtor.238(%Token* %6) br label %while_step while_step: ; preds = %while_body - call void @popFront.498(%"ContiguousMemoryRange[Token]"* %"$rangeVar") + call void @popFront.486(%"ContiguousMemoryRange[Token]"* %"$rangeVar") br label %while_block while_end: ; preds = %while_block @@ -18257,22 +17726,22 @@ while_end: ; preds = %while_block while_block2: ; preds = %while_step4, %while_end %7 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - %8 = call i1 @"==.205"(%"RawPtr[Token]"* %rEnd, %"RawPtr[Token]"* %7) + %8 = call i1 @"==.194"(%"RawPtr[Token]"* %rEnd, %"RawPtr[Token]"* %7) %9 = xor i1 true, %8 br i1 %9, label %while_body3, label %while_end5 while_body3: ; preds = %while_block2 - %10 = call %Token* @value.206(%"RawPtr[Token]"* %rBegin) - %11 = call %Token* @value.206(%"RawPtr[Token]"* %rEnd) - call void @ctor.188(%Token* %10, %Token* %11) - %12 = call %Token* @value.206(%"RawPtr[Token]"* %rEnd) - call void @dtor.249(%Token* %12) - %13 = call %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %rBegin) + %10 = call %Token* @value.195(%"RawPtr[Token]"* %rBegin) + %11 = call %Token* @value.195(%"RawPtr[Token]"* %rEnd) + call void @ctor.177(%Token* %10, %Token* %11) + %12 = call %Token* @value.195(%"RawPtr[Token]"* %rEnd) + call void @dtor.238(%Token* %12) + %13 = call %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %rBegin) store %"RawPtr[Token]" %13, %"RawPtr[Token]"* %"$tmpForRef6" - call void @"=.198"(%"RawPtr[Token]"* %rBegin, %"RawPtr[Token]"* %"$tmpForRef6") - %14 = call %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %rEnd) + call void @"=.187"(%"RawPtr[Token]"* %rBegin, %"RawPtr[Token]"* %"$tmpForRef6") + %14 = call %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %rEnd) store %"RawPtr[Token]" %14, %"RawPtr[Token]"* %"$tmpForRef7" - call void @"=.198"(%"RawPtr[Token]"* %rEnd, %"RawPtr[Token]"* %"$tmpForRef7") + call void @"=.187"(%"RawPtr[Token]"* %rEnd, %"RawPtr[Token]"* %"$tmpForRef7") br label %while_step4 while_step4: ; preds = %while_body3 @@ -18280,12 +17749,12 @@ while_step4: ; preds = %while_body3 while_end5: ; preds = %while_block2 %15 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 - call void @"=.198"(%"RawPtr[Token]"* %15, %"RawPtr[Token]"* %rBegin) + call void @"=.187"(%"RawPtr[Token]"* %15, %"RawPtr[Token]"* %rBegin) ret void } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Token]" @frontPtr.494(%"ContiguousMemoryRange[Token]"* %this) #4 { +define internal %"RawPtr[Token]" @frontPtr.482(%"ContiguousMemoryRange[Token]"* %this) #4 { br label %code code: ; preds = %0 @@ -18295,7 +17764,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[Token]" @backPtr.495(%"ContiguousMemoryRange[Token]"* %this) #4 { +define internal %"RawPtr[Token]" @backPtr.483(%"ContiguousMemoryRange[Token]"* %this) #4 { br label %code code: ; preds = %0 @@ -18305,126 +17774,87 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.496(%"ContiguousMemoryRange[Token]"* %this) #4 { - %tmp.this = alloca i64 +define internal i1 @isEmpty.484(%"ContiguousMemoryRange[Token]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 %3 = load %"RawPtr[Token]", %"RawPtr[Token]"* %2 - %4 = call i64 @diff.196(%"RawPtr[Token]"* %1, %"RawPtr[Token]" %3) - store i64 0, i64* %tmp.this - %5 = load i64, i64* %tmp.this - %6 = icmp sle i64 %4, %5 - ret i1 %6 + %4 = call i32 @diff.185(%"RawPtr[Token]"* %1, %"RawPtr[Token]" %3) + %5 = call i1 @_Int32_opLE(i32 %4, i32 0) + ret i1 %5 } ; Function Attrs: inlinehint nounwind -define internal %Token* @front.497(%"ContiguousMemoryRange[Token]"* %this) #4 { +define internal %Token* @front.485(%"ContiguousMemoryRange[Token]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 - %2 = call %Token* @value.206(%"RawPtr[Token]"* %1) + %2 = call %Token* @value.195(%"RawPtr[Token]"* %1) ret %Token* %2 } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.498(%"ContiguousMemoryRange[Token]"* %this) #3 { +define internal void @popFront.486(%"ContiguousMemoryRange[Token]"* %this) #3 { %"$tmpForRef" = alloca %"RawPtr[Token]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 %2 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 - %3 = call %"RawPtr[Token]" @advance.207(%"RawPtr[Token]"* %2) + %3 = call %"RawPtr[Token]" @advance.196(%"RawPtr[Token]"* %2) store %"RawPtr[Token]" %3, %"RawPtr[Token]"* %"$tmpForRef" - call void @"=.198"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %"$tmpForRef") + call void @"=.187"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %"$tmpForRef") ret void } ; Function Attrs: inlinehint nounwind -define internal i8* @back.499(%"Vector[Char]"* %this) #4 { +define internal i8* @back.487(%"Vector[Char]"* %this) #4 { %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i64 %2) - store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" - %4 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") - ret i8* %4 -} - -; Function Attrs: inlinehint nounwind -define internal i32* @back.500(%"Vector[UInt]"* %this) #4 { - %"$tmpForRef" = alloca %"RawPtr[UInt]" - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = call %"RawPtr[UInt]" @advance.501(%"RawPtr[UInt]"* %1, i64 %2) - store %"RawPtr[UInt]" %3, %"RawPtr[UInt]"* %"$tmpForRef" - %4 = call i32* @value.261(%"RawPtr[UInt]"* %"$tmpForRef") - ret i32* %4 + %2 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i32 -1) + store %"RawPtr[Char]" %2, %"RawPtr[Char]"* %"$tmpForRef" + %3 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") + ret i8* %3 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[UInt]" @advance.501(%"RawPtr[UInt]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %tmp.this = alloca %"RawPtr[UInt]" - %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 - %tmp.this3 = alloca i64 +define internal i32* @back.488(%"Vector[Int]"* %this) #4 { + %"$tmpForRef" = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"RawPtr[UInt]", %"RawPtr[UInt]"* %this, i32 0, i32 0 - %2 = load i32*, i32** %1 - call void @ctor.211(%UntypedPtr* %tmp.this1, i32* %2) - %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = load i64, i64* %n.addr - store i64 4, i64* %tmp.this3 - %5 = load i64, i64* %tmp.this3 - %6 = mul i64 %4, %5 - store i64 %6, i64* %tmp.this2 - %7 = load i64, i64* %tmp.this2 - %8 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %7) - call void @ctor.216(%"RawPtr[UInt]"* %tmp.this, %UntypedPtr %8) - %9 = load %"RawPtr[UInt]", %"RawPtr[UInt]"* %tmp.this - ret %"RawPtr[UInt]" %9 + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %2 = call %"RawPtr[Int]" @advance.204(%"RawPtr[Int]"* %1, i32 -1) + store %"RawPtr[Int]" %2, %"RawPtr[Int]"* %"$tmpForRef" + %3 = call i32* @value.250(%"RawPtr[Int]"* %"$tmpForRef") + ret i32* %3 } ; Function Attrs: inlinehint nounwind -define internal void @popBack.502(%"Vector[UInt]"* %this) #4 { - %"$tmpForRef" = alloca %"RawPtr[UInt]" - %tmp.this = alloca i64 +define internal void @popBack.489(%"Vector[Int]"* %this) #4 { + %"$tmpForRef" = alloca %"RawPtr[Int]" br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = call %"RawPtr[UInt]" @advance.501(%"RawPtr[UInt]"* %2, i64 %3) - store %"RawPtr[UInt]" %4, %"RawPtr[UInt]"* %"$tmpForRef" - call void @"=.212"(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]"* %"$tmpForRef") - %5 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %6 = call i32* @value.261(%"RawPtr[UInt]"* %5) - %7 = load i32, i32* %6 + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %3 = call %"RawPtr[Int]" @advance.204(%"RawPtr[Int]"* %2, i32 -1) + store %"RawPtr[Int]" %3, %"RawPtr[Int]"* %"$tmpForRef" + call void @"=.201"(%"RawPtr[Int]"* %1, %"RawPtr[Int]"* %"$tmpForRef") + %4 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %5 = call i32* @value.250(%"RawPtr[Int]"* %4) + %6 = load i32, i32* %5 ret void } ; Function Attrs: inlinehint nounwind -define internal void @toString.503(%String* sret %_result, %StringRef* %a1, i32* %a2, %StringRef* %a3, i32* %a4) #4 { +define internal void @toString.490(%String* sret %_result, %StringRef* %a1, i32* %a2, %StringRef* %a3, i32* %a4) #4 { %s = alloca %StringOutputStream %"$tmpC" = alloca %StringOutputStream %"$tmpC1" = alloca %StringOutputStream @@ -18433,144 +17863,87 @@ define internal void @toString.503(%String* sret %_result, %StringRef* %a1, i32* br label %code code: ; preds = %0 - call void @ctor.439(%StringOutputStream* %s) + call void @ctor.428(%StringOutputStream* %s) call void @"<<"(%StringOutputStream* %"$tmpC3", %StringOutputStream* %s, %StringRef* %a1) - call void @"<<.504"(%StringOutputStream* %"$tmpC2", %StringOutputStream* %"$tmpC3", i32* %a2) + call void @"<<.460"(%StringOutputStream* %"$tmpC2", %StringOutputStream* %"$tmpC3", i32* %a2) call void @"<<"(%StringOutputStream* %"$tmpC1", %StringOutputStream* %"$tmpC2", %StringRef* %a3) - call void @"<<.504"(%StringOutputStream* %"$tmpC", %StringOutputStream* %"$tmpC1", i32* %a4) - call void @dtor.442(%StringOutputStream* %"$tmpC") - call void @dtor.442(%StringOutputStream* %"$tmpC1") - call void @dtor.442(%StringOutputStream* %"$tmpC2") - call void @dtor.442(%StringOutputStream* %"$tmpC3") + call void @"<<.460"(%StringOutputStream* %"$tmpC", %StringOutputStream* %"$tmpC1", i32* %a4) + call void @dtor.431(%StringOutputStream* %"$tmpC") + call void @dtor.431(%StringOutputStream* %"$tmpC1") + call void @dtor.431(%StringOutputStream* %"$tmpC2") + call void @dtor.431(%StringOutputStream* %"$tmpC3") %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %s, i32 0, i32 0 - call void @ctor.175(%String* %_result, %String* %1) - call void @dtor.442(%StringOutputStream* %s) + call void @ctor.165(%String* %_result, %String* %1) + call void @dtor.431(%StringOutputStream* %s) ret void dumy_block: ; No predecessors! - call void @dtor.442(%StringOutputStream* %s) - ret void -} - -; Function Attrs: inlinehint nounwind -define internal void @"<<.504"(%StringOutputStream* sret %_result, %StringOutputStream* %s, i32* %x) #4 { - %tmp.this = alloca i64 - br label %code - -code: ; preds = %0 - %1 = load i32, i32* %x - %2 = zext i32 %1 to i64 - store i64 %2, i64* %tmp.this - %3 = load i64, i64* %tmp.this - call void @"<<<.505"(%StringOutputStream* %s, i64 %3) - call void @ctor.441(%StringOutputStream* %_result, %StringOutputStream* %s) - ret void -} - -; Function Attrs: alwaysinline nounwind -define internal void @"<<<.505"(%StringOutputStream* %this, i64 %x) #3 { - %x.addr = alloca i64 - store i64 %x, i64* %x.addr - %"$tmpForRef" = alloca %StringRef - %"$tmpC" = alloca %String - br label %code - -code: ; preds = %0 - %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 - %2 = load i64, i64* %x.addr - call void @ulongToString(%String* %"$tmpC", i64 %2) - %3 = call %StringRef @all.473(%String* %"$tmpC") - store %StringRef %3, %StringRef* %"$tmpForRef" - call void @append(%String* %1, %StringRef* %"$tmpForRef") - call void @dtor.250(%String* %"$tmpC") - ret void -} - -; Function Attrs: inlinehint nounwind -define internal void @ulongToString(%String* sret %_result, i64 %x) #4 { - %x.addr = alloca i64 - store i64 %x, i64* %x.addr - %buf = alloca [16 x i8] - br label %code - -code: ; preds = %0 - %1 = load i64, i64* %x.addr - %2 = bitcast [16 x i8]* %buf to i8* - call void @_ULong_to_CString(i64 %1, i8* %2) - %3 = bitcast [16 x i8]* %buf to i8* - %4 = call %StringRef @_String_fromCString(i8* %3) - call void @ctor.459(%String* %_result, %StringRef %4) + call void @dtor.431(%StringOutputStream* %s) ret void } ; Function Attrs: inlinehint nounwind -define internal void @popBack.506(%"Vector[Char]"* %this) #4 { +define internal void @popBack.491(%"Vector[Char]"* %this) #4 { %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i64 %3) - store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" - call void @"=.186"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") - %5 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 - %6 = call i8* @value(%"RawPtr[Char]"* %5) - %7 = load i8, i8* %6 + %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %2, i32 -1) + store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" + call void @"=.176"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %"$tmpForRef") + %4 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 + %5 = call i8* @value(%"RawPtr[Char]"* %4) + %6 = load i8, i8* %5 ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.507(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %tokens, %AstBuilder* %astBuilder, %ErrorReporter* %errorReporter) #4 { +define internal void @ctor.492(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %tokens, %AstBuilder* %astBuilder, %ErrorReporter* %errorReporter) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - call void @ctor.130(%Token* %1) + call void @ctor.120(%Token* %1) %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @ctor.508(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2, %"SparrowLayoutDecoder[SparrowScanner]"* %tokens) + call void @ctor.493(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2, %"SparrowLayoutDecoder[SparrowScanner]"* %tokens) %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 2 store i1 false, i1* %3 %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 - call void @ctor.222(%AstBuilder* %4, %AstBuilder* %astBuilder) + call void @ctor.211(%AstBuilder* %4, %AstBuilder* %astBuilder) %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 4 - call void @ctor.190(%ErrorReporter* %5, %ErrorReporter* %errorReporter) + call void @ctor.179(%ErrorReporter* %5, %ErrorReporter* %errorReporter) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.508(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %src) #4 { - %tmp.this = alloca i64 +define internal void @ctor.493(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, %"SparrowLayoutDecoder[SparrowScanner]"* %src) #4 { %"$tmpC" = alloca %Token br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @ctor.134(%"SparrowLayoutDecoder[SparrowScanner]"* %1) + call void @ctor.124(%"SparrowLayoutDecoder[SparrowScanner]"* %1) %2 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"=.289"(%"SparrowLayoutDecoder[SparrowScanner]"* %2, %"SparrowLayoutDecoder[SparrowScanner]"* %src) + call void @"=.278"(%"SparrowLayoutDecoder[SparrowScanner]"* %2, %"SparrowLayoutDecoder[SparrowScanner]"* %src) %3 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - call void @ctor.136(%"Vector[Token]"* %3) + call void @ctor.126(%"Vector[Token]"* %3) %4 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - store i64 10, i64* %tmp.this - %5 = load i64, i64* %tmp.this - call void @reserve.391(%"Vector[Token]"* %4, i64 %5) + call void @reserve.380(%"Vector[Token]"* %4, i32 10) br label %if_block if_block: ; preds = %code - %6 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - %7 = call i1 @"pre_!!.509"(%"SparrowLayoutDecoder[SparrowScanner]"* %6) - br i1 %7, label %if_then, label %if_end + %5 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 + %6 = call i1 @"pre_!!.494"(%"SparrowLayoutDecoder[SparrowScanner]"* %5) + br i1 %6, label %if_then, label %if_end if_then: ; preds = %if_block - %8 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %9 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"post_++.511"(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %9) - call void @"+=.396"(%"Vector[Token]"* %8, %Token* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC") + %7 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %8 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 + call void @"post_++.496"(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %8) + call void @"+=.385"(%"Vector[Token]"* %7, %Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") br label %if_end if_end: ; preds = %if_then, %if_block @@ -18578,28 +17951,28 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal i1 @"pre_!!.509"(%"SparrowLayoutDecoder[SparrowScanner]"* %r) #4 { +define internal i1 @"pre_!!.494"(%"SparrowLayoutDecoder[SparrowScanner]"* %r) #4 { br label %code code: ; preds = %0 - %1 = call i1 @isEmpty.510(%"SparrowLayoutDecoder[SparrowScanner]"* %r) + %1 = call i1 @isEmpty.495(%"SparrowLayoutDecoder[SparrowScanner]"* %r) %2 = xor i1 true, %1 ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.510(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #4 { +define internal i1 @isEmpty.495(%"SparrowLayoutDecoder[SparrowScanner]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 5 %2 = load i32, i32* %1 - %3 = icmp eq i32 %2, 0 + %3 = call i1 @_Int32_opEQ(i32 %2, i32 0) br i1 %3, label %cond.true, label %cond.false cond.true: ; preds = %code %4 = getelementptr inbounds %"SparrowLayoutDecoder[SparrowScanner]", %"SparrowLayoutDecoder[SparrowScanner]"* %this, i32 0, i32 0 - %5 = call i1 @isEmpty.479(%"RangeWithLookahead[SparrowScanner]"* %4) + %5 = call i1 @isEmpty.468(%"RangeWithLookahead[SparrowScanner]"* %4) br label %cond.end cond.false: ; preds = %code @@ -18611,19 +17984,19 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: inlinehint nounwind -define internal void @"post_++.511"(%Token* sret %_result, %"SparrowLayoutDecoder[SparrowScanner]"* %r) #4 { +define internal void @"post_++.496"(%Token* sret %_result, %"SparrowLayoutDecoder[SparrowScanner]"* %r) #4 { %res = alloca %Token br label %code code: ; preds = %0 - call void @front.484(%Token* %res, %"SparrowLayoutDecoder[SparrowScanner]"* %r) - call void @popFront.483(%"SparrowLayoutDecoder[SparrowScanner]"* %r) - call void @ctor.188(%Token* %_result, %Token* %res) - call void @dtor.249(%Token* %res) + call void @front.473(%Token* %res, %"SparrowLayoutDecoder[SparrowScanner]"* %r) + call void @popFront.472(%"SparrowLayoutDecoder[SparrowScanner]"* %r) + call void @ctor.177(%Token* %_result, %Token* %res) + call void @dtor.238(%Token* %res) ret void dumy_block: ; No predecessors! - call void @dtor.249(%Token* %res) + call void @dtor.238(%Token* %res) ret void } @@ -18646,7 +18019,7 @@ define internal %ParserContext* @new(%CharSource* %arg1, %Location* %arg2, %AstB br label %code code: ; preds = %0 - %1 = call %UntypedPtr @malloc(i64 1288) + %1 = call %UntypedPtr @malloc(i32 1288) store %UntypedPtr %1, %UntypedPtr* %"$tmpForRef" %2 = getelementptr inbounds %UntypedPtr, %UntypedPtr* %"$tmpForRef", i32 0, i32 0 %3 = load i8*, i8** %2 @@ -18654,7 +18027,7 @@ code: ; preds = %0 store %ParserContext* %4, %ParserContext** %res %5 = load %ParserContext*, %ParserContext** %res %6 = load %Location, %Location* %arg2 - call void @ctor.375(%ParserContext* %5, %CharSource* %arg1, %Location %6, %AstBuilder* %arg3, %ErrorReporter* %arg4) + call void @ctor.364(%ParserContext* %5, %CharSource* %arg1, %Location %6, %AstBuilder* %arg3, %ErrorReporter* %arg4) %7 = load %ParserContext*, %ParserContext** %res ret %ParserContext* %7 } @@ -18668,7 +18041,7 @@ define %ParserContext* @spr_parserIf_createParserFile(%StringRef %filename, %Loc br label %code code: ; preds = %0 - %1 = call %FileCharSource* @new.512(%StringRef* %filename.addr) + %1 = call %FileCharSource* @new.497(%StringRef* %filename.addr) store %FileCharSource* %1, %FileCharSource** %fileCharSource %2 = load %FileCharSource*, %FileCharSource** %fileCharSource call void @mkCharSource(%CharSource* %"$tmpC", %FileCharSource* %2) @@ -18677,13 +18050,13 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %FileCharSource* @new.512(%StringRef* %arg1) #4 { +define internal %FileCharSource* @new.497(%StringRef* %arg1) #4 { %res = alloca %FileCharSource* %"$tmpForRef" = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = call %UntypedPtr @malloc(i64 8) + %1 = call %UntypedPtr @malloc(i32 8) store %UntypedPtr %1, %UntypedPtr* %"$tmpForRef" %2 = getelementptr inbounds %UntypedPtr, %UntypedPtr* %"$tmpForRef", i32 0, i32 0 %3 = load i8*, i8** %2 @@ -18691,13 +18064,13 @@ code: ; preds = %0 store %FileCharSource* %4, %FileCharSource** %res %5 = load %FileCharSource*, %FileCharSource** %res %6 = load %StringRef, %StringRef* %arg1 - call void @ctor.513(%FileCharSource* %5, %StringRef %6) + call void @ctor.498(%FileCharSource* %5, %StringRef %6) %7 = load %FileCharSource*, %FileCharSource** %res ret %FileCharSource* %7 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.513(%FileCharSource* %this, %StringRef %filename) #4 { +define internal void @ctor.498(%FileCharSource* %this, %StringRef %filename) #4 { %filename.addr = alloca %StringRef store %StringRef %filename, %StringRef* %filename.addr %tmp.StringRef = alloca %StringRef @@ -18713,12 +18086,12 @@ code: ; preds = %0 store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.42, i32 0, i32 0), i8** %5 store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.42, i32 0, i32 1), i8** %6 %7 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.514(%File* %1, %StringRef %2, %StringRef %7) + call void @ctor.499(%File* %1, %StringRef %2, %StringRef %7) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.514(%File* %this, %StringRef %filename, %StringRef %mode) #4 { +define internal void @ctor.499(%File* %this, %StringRef %filename, %StringRef %mode) #4 { %filename.addr = alloca %StringRef store %StringRef %filename, %StringRef* %filename.addr %mode.addr = alloca %StringRef @@ -18728,7 +18101,7 @@ define internal void @ctor.514(%File* %this, %StringRef %filename, %StringRef %m code: ; preds = %0 %1 = getelementptr inbounds %File, %File* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %File, %File* %this, i32 0, i32 0 %3 = load %StringRef, %StringRef* %filename.addr %4 = call i8* @cStr(%StringRef %3) @@ -18752,18 +18125,18 @@ define internal void @mkCharSource(%CharSource* sret %_result, %FileCharSource* br label %code code: ; preds = %0 - call void @ctor.122(%CharSource* %res) + call void @ctor.112(%CharSource* %res) %1 = getelementptr inbounds %CharSource, %CharSource* %res, i32 0, i32 0 %2 = call %UntypedPtr @_eraseType(%FileCharSource* %obj) store %UntypedPtr %2, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %1, %UntypedPtr* %"$tmpForRef") %3 = getelementptr inbounds %CharSource, %CharSource* %res, i32 0, i32 1 - store void (%FileCharSource*, %String*, i32)* @readChars.517, void (%FileCharSource*, %String*, i32)** %funptr + store void (%FileCharSource*, %String*, i32)* @readChars.502, void (%FileCharSource*, %String*, i32)** %funptr %4 = bitcast void (%FileCharSource*, %String*, i32)** %funptr to %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %5 = load %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]", %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %4 store %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]" %5, %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %"$tmpForRef1" call void @_reinterpretAssign(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %3, %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %"$tmpForRef1") - call void @ctor.173(%CharSource* %_result, %CharSource* %res) + call void @ctor.163(%CharSource* %_result, %CharSource* %res) ret void } @@ -18773,13 +18146,13 @@ define internal %UntypedPtr @_eraseType(%FileCharSource* %obj) #4 { br label %code code: ; preds = %0 - call void @ctor.515(%UntypedPtr* %tmp.this, %FileCharSource* %obj) + call void @ctor.500(%UntypedPtr* %tmp.this, %FileCharSource* %obj) %1 = load %UntypedPtr, %UntypedPtr* %tmp.this ret %UntypedPtr %1 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.515(%UntypedPtr* %this, %FileCharSource* %val) #4 { +define internal void @ctor.500(%UntypedPtr* %this, %FileCharSource* %val) #4 { %val.addr = alloca %FileCharSource* store %FileCharSource* %val, %FileCharSource** %val.addr br label %code @@ -18800,12 +18173,12 @@ define internal void @_reinterpretAssign(%"FunctionPtr3[Void, UntypedPtr, String code: ; preds = %0 %1 = bitcast %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %dest to %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* - call void @"=.516"(%"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %1, %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %src) + call void @"=.501"(%"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %1, %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %src) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.516"(%"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %this, %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %other) #3 { +define internal void @"=.501"(%"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %this, %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* store %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"* %other, %"FunctionPtr3[Void, FileCharSource mut, String mut, Int]"** %other.addr br label %code @@ -18819,7 +18192,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @readChars.517(%FileCharSource* %this, %String* %dest, i32 %numChars) #4 { +define internal void @readChars.502(%FileCharSource* %this, %String* %dest, i32 %numChars) #4 { %numChars.addr = alloca i32 store i32 %numChars, i32* %numChars.addr %"$rangeVar" = alloca %"NumericRangeInc[Int]" @@ -18830,40 +18203,41 @@ define internal void @readChars.517(%FileCharSource* %this, %String* %dest, i32 code: ; preds = %0 store i32 0, i32* %"$tmpForRef" - call void @..(%"NumericRangeInc[Int]"* %"$rangeVar", i32* %"$tmpForRef", i32* %numChars.addr) + %1 = load i32, i32* %numChars.addr + call void @..(%"NumericRangeInc[Int]"* %"$rangeVar", i32* %"$tmpForRef", i32 %1) br label %while_block while_block: ; preds = %while_step, %code - %1 = call i1 @isEmpty.519(%"NumericRangeInc[Int]"* %"$rangeVar") - %2 = xor i1 true, %1 - br i1 %2, label %while_body, label %while_end + %2 = call i1 @isEmpty.504(%"NumericRangeInc[Int]"* %"$rangeVar") + %3 = xor i1 true, %2 + br i1 %3, label %while_body, label %while_end while_body: ; preds = %while_block - %3 = call i32 @front.520(%"NumericRangeInc[Int]"* %"$rangeVar") - store i32 %3, i32* %i - %4 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 - %5 = call i8 @readChar(%File* %4) - store i8 %5, i8* %ch + %4 = call i32 @front.505(%"NumericRangeInc[Int]"* %"$rangeVar") + store i32 %4, i32* %i + %5 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 + %6 = call i8 @readChar(%File* %5) + store i8 %6, i8* %ch br label %if_block while_step: ; preds = %if_end - call void @popFront.521(%"NumericRangeInc[Int]"* %"$rangeVar") + call void @popFront.506(%"NumericRangeInc[Int]"* %"$rangeVar") br label %while_block while_end: ; preds = %if_then, %while_block ret void if_block: ; preds = %while_body - %6 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 - %7 = call i1 @isEof(%File* %6) - br i1 %7, label %if_then, label %if_end + %7 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 + %8 = call i1 @isEof(%File* %7) + br i1 %8, label %if_then, label %if_end if_then: ; preds = %if_block br label %while_end if_end: ; preds = %dumy_block, %if_block - %8 = load i8, i8* %ch - call void @"+=.461"(%String* %dest, i8 %8) + %9 = load i8, i8* %ch + call void @"+=.450"(%String* %dest, i8 %9) br label %while_step dumy_block: ; No predecessors! @@ -18871,18 +18245,20 @@ dumy_block: ; No predecessors! } ; Function Attrs: inlinehint nounwind -define internal void @..(%"NumericRangeInc[Int]"* sret %_result, i32* %start, i32* %end) #4 { +define internal void @..(%"NumericRangeInc[Int]"* sret %_result, i32* %start, i32 %end) #4 { + %end.addr = alloca i32 + store i32 %end, i32* %end.addr br label %code code: ; preds = %0 %1 = load i32, i32* %start - %2 = load i32, i32* %end - call void @ctor.518(%"NumericRangeInc[Int]"* %_result, i32 %1, i32 %2) + %2 = load i32, i32* %end.addr + call void @ctor.503(%"NumericRangeInc[Int]"* %_result, i32 %1, i32 %2) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.518(%"NumericRangeInc[Int]"* %this, i32 %start, i32 %end) #4 { +define internal void @ctor.503(%"NumericRangeInc[Int]"* %this, i32 %start, i32 %end) #4 { %start.addr = alloca i32 store i32 %start, i32* %start.addr %end.addr = alloca i32 @@ -18902,7 +18278,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.519(%"NumericRangeInc[Int]"* %this) #4 { +define internal i1 @isEmpty.504(%"NumericRangeInc[Int]"* %this) #4 { br label %code code: ; preds = %0 @@ -18915,7 +18291,7 @@ cond_alt1: ; preds = %code %4 = load i32, i32* %3 %5 = getelementptr inbounds %"NumericRangeInc[Int]", %"NumericRangeInc[Int]"* %this, i32 0, i32 1 %6 = load i32, i32* %5 - %7 = icmp sgt i32 %4, %6 + %7 = call i1 @_Int32_opGT(i32 %4, i32 %6) br label %cond_end cond_alt2: ; preds = %code @@ -18923,7 +18299,7 @@ cond_alt2: ; preds = %code %9 = load i32, i32* %8 %10 = getelementptr inbounds %"NumericRangeInc[Int]", %"NumericRangeInc[Int]"* %this, i32 0, i32 1 %11 = load i32, i32* %10 - %12 = icmp sge i32 %9, %11 + %12 = call i1 @_Int32_opGE(i32 %9, i32 %11) br label %cond_end cond_end: ; preds = %cond_alt2, %cond_alt1 @@ -18932,7 +18308,7 @@ cond_end: ; preds = %cond_alt2, %cond_al } ; Function Attrs: inlinehint nounwind -define internal i32 @front.520(%"NumericRangeInc[Int]"* %this) #4 { +define internal i32 @front.505(%"NumericRangeInc[Int]"* %this) #4 { br label %code code: ; preds = %0 @@ -18964,14 +18340,14 @@ define internal i1 @isEof(%File* %this) #4 { code: ; preds = %0 %1 = load %File, %File* %this %2 = call i32 @feof(%File %1) - %3 = icmp ne i32 0, %2 + %3 = call i1 @_Int32_opNE(i32 0, i32 %2) ret i1 %3 } declare i32 @feof(%File) ; Function Attrs: alwaysinline nounwind -define internal void @popFront.521(%"NumericRangeInc[Int]"* %this) #3 { +define internal void @popFront.506(%"NumericRangeInc[Int]"* %this) #3 { %tmp.this = alloca i32 br label %code @@ -18980,14 +18356,14 @@ code: ; preds = %0 %2 = load i32, i32* %1 store i32 1, i32* %tmp.this %3 = load i32, i32* %tmp.this - %4 = add i32 %2, %3 + %4 = call i32 @_Int32_opPlus(i32 %2, i32 %3) %5 = getelementptr inbounds %"NumericRangeInc[Int]", %"NumericRangeInc[Int]"* %this, i32 0, i32 0 store i32 %4, i32* %5 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.522(%"NumericRangeInc[Int]"* %this) #3 { +define internal void @dtor.507(%"NumericRangeInc[Int]"* %this) #3 { br label %code code: ; preds = %0 @@ -18995,7 +18371,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.523(%CharSource* %this) #3 { +define internal void @dtor.508(%CharSource* %this) #3 { br label %code code: ; preds = %0 @@ -19011,22 +18387,22 @@ define %ParserContext* @spr_parserIf_createParserStringRef(%StringRef %code, %Lo br label %code1 code1: ; preds = %0 - %1 = call %StringCharSource* @new.524(%StringRef* %code.addr) + %1 = call %StringCharSource* @new.509(%StringRef* %code.addr) store %StringCharSource* %1, %StringCharSource** %stringCharSource %2 = load %StringCharSource*, %StringCharSource** %stringCharSource - call void @mkCharSource.526(%CharSource* %"$tmpC", %StringCharSource* %2) + call void @mkCharSource.511(%CharSource* %"$tmpC", %StringCharSource* %2) %3 = call %ParserContext* @spr_parserIf_createParser(%CharSource* %"$tmpC", %Location* %loc, %AstBuilder* %astBuilder, %ErrorReporter* %reporter) ret %ParserContext* %3 } ; Function Attrs: inlinehint nounwind -define internal %StringCharSource* @new.524(%StringRef* %arg1) #4 { +define internal %StringCharSource* @new.509(%StringRef* %arg1) #4 { %res = alloca %StringCharSource* %"$tmpForRef" = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = call %UntypedPtr @malloc(i64 16) + %1 = call %UntypedPtr @malloc(i32 16) store %UntypedPtr %1, %UntypedPtr* %"$tmpForRef" %2 = getelementptr inbounds %UntypedPtr, %UntypedPtr* %"$tmpForRef", i32 0, i32 0 %3 = load i8*, i8** %2 @@ -19034,13 +18410,13 @@ code: ; preds = %0 store %StringCharSource* %4, %StringCharSource** %res %5 = load %StringCharSource*, %StringCharSource** %res %6 = load %StringRef, %StringRef* %arg1 - call void @ctor.525(%StringCharSource* %5, %StringRef %6) + call void @ctor.510(%StringCharSource* %5, %StringRef %6) %7 = load %StringCharSource*, %StringCharSource** %res ret %StringCharSource* %7 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.525(%StringCharSource* %this, %StringRef %f_content) #3 { +define internal void @ctor.510(%StringCharSource* %this, %StringRef %f_content) #3 { %this.addr = alloca %StringCharSource* store %StringCharSource* %this, %StringCharSource** %this.addr %f_content.addr = alloca %StringRef @@ -19051,12 +18427,12 @@ code: ; preds = %0 %1 = load %StringCharSource*, %StringCharSource** %this.addr %2 = getelementptr inbounds %StringCharSource, %StringCharSource* %1, i32 0, i32 0 %3 = load %StringRef, %StringRef* %f_content.addr - call void @ctor.59(%StringRef* %2, %StringRef %3) + call void @ctor.49(%StringRef* %2, %StringRef %3) ret void } ; Function Attrs: inlinehint nounwind -define internal void @mkCharSource.526(%CharSource* sret %_result, %StringCharSource* %obj) #4 { +define internal void @mkCharSource.511(%CharSource* sret %_result, %StringCharSource* %obj) #4 { %res = alloca %CharSource %"$tmpForRef" = alloca %UntypedPtr %"$tmpForRef1" = alloca %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]" @@ -19064,34 +18440,34 @@ define internal void @mkCharSource.526(%CharSource* sret %_result, %StringCharSo br label %code code: ; preds = %0 - call void @ctor.122(%CharSource* %res) + call void @ctor.112(%CharSource* %res) %1 = getelementptr inbounds %CharSource, %CharSource* %res, i32 0, i32 0 - %2 = call %UntypedPtr @_eraseType.527(%StringCharSource* %obj) + %2 = call %UntypedPtr @_eraseType.512(%StringCharSource* %obj) store %UntypedPtr %2, %UntypedPtr* %"$tmpForRef" call void @"="(%UntypedPtr* %1, %UntypedPtr* %"$tmpForRef") %3 = getelementptr inbounds %CharSource, %CharSource* %res, i32 0, i32 1 - store void (%StringCharSource*, %String*, i32)* @readChars.531, void (%StringCharSource*, %String*, i32)** %funptr + store void (%StringCharSource*, %String*, i32)* @readChars.516, void (%StringCharSource*, %String*, i32)** %funptr %4 = bitcast void (%StringCharSource*, %String*, i32)** %funptr to %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %5 = load %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]", %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %4 store %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]" %5, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %"$tmpForRef1" - call void @_reinterpretAssign.529(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %3, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %"$tmpForRef1") - call void @ctor.173(%CharSource* %_result, %CharSource* %res) + call void @_reinterpretAssign.514(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %3, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %"$tmpForRef1") + call void @ctor.163(%CharSource* %_result, %CharSource* %res) ret void } ; Function Attrs: inlinehint nounwind -define internal %UntypedPtr @_eraseType.527(%StringCharSource* %obj) #4 { +define internal %UntypedPtr @_eraseType.512(%StringCharSource* %obj) #4 { %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 - call void @ctor.528(%UntypedPtr* %tmp.this, %StringCharSource* %obj) + call void @ctor.513(%UntypedPtr* %tmp.this, %StringCharSource* %obj) %1 = load %UntypedPtr, %UntypedPtr* %tmp.this ret %UntypedPtr %1 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.528(%UntypedPtr* %this, %StringCharSource* %val) #4 { +define internal void @ctor.513(%UntypedPtr* %this, %StringCharSource* %val) #4 { %val.addr = alloca %StringCharSource* store %StringCharSource* %val, %StringCharSource** %val.addr br label %code @@ -19107,17 +18483,17 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @_reinterpretAssign.529(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %dest, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %src) #4 { +define internal void @_reinterpretAssign.514(%"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %dest, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %src) #4 { br label %code code: ; preds = %0 %1 = bitcast %"FunctionPtr3[Void, UntypedPtr, String mut, Int]"* %dest to %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* - call void @"=.530"(%"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %1, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %src) + call void @"=.515"(%"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %1, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %src) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.530"(%"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %this, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %other) #3 { +define internal void @"=.515"(%"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %this, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %other) #3 { %other.addr = alloca %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* store %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"* %other, %"FunctionPtr3[Void, StringCharSource mut, String mut, Int]"** %other.addr br label %code @@ -19131,7 +18507,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @readChars.531(%StringCharSource* %this, %String* %dest, i32 %numChars) #4 { +define internal void @readChars.516(%StringCharSource* %this, %String* %dest, i32 %numChars) #4 { %numChars.addr = alloca i32 store i32 %numChars, i32* %numChars.addr %sz = alloca i32 @@ -19144,47 +18520,48 @@ define internal void @readChars.531(%StringCharSource* %this, %String* %dest, i3 code: ; preds = %0 %1 = getelementptr inbounds %StringCharSource, %StringCharSource* %this, i32 0, i32 0 %2 = load %StringRef, %StringRef* %1 - %3 = call i64 @size(%StringRef %2) - %4 = trunc i64 %3 to i32 - store i32 %4, i32* %sz - %5 = load i32, i32* %numChars.addr - %6 = load i32, i32* %sz - %7 = icmp slt i32 %5, %6 - br i1 %7, label %cond_alt1, label %cond_alt2 + %3 = call i32 @size(%StringRef %2) + store i32 %3, i32* %sz + %4 = load i32, i32* %numChars.addr + %5 = load i32, i32* %sz + %6 = call i1 @_Int32_opLT(i32 %4, i32 %5) + br i1 %6, label %cond_alt1, label %cond_alt2 cond_alt1: ; preds = %code + %7 = load i32, i32* %numChars.addr br label %cond_end cond_alt2: ; preds = %code + %8 = load i32, i32* %sz br label %cond_end cond_end: ; preds = %cond_alt2, %cond_alt1 - %cond = phi i32* [ %numChars.addr, %cond_alt1 ], [ %sz, %cond_alt2 ] - %8 = load i32, i32* %cond - store i32 %8, i32* %toRead + %cond = phi i32 [ %7, %cond_alt1 ], [ %8, %cond_alt2 ] + store i32 %cond, i32* %toRead store i32 0, i32* %"$tmpForRef" - call void @..(%"NumericRangeInc[Int]"* %"$rangeVar", i32* %"$tmpForRef", i32* %sz) + %9 = load i32, i32* %sz + call void @..(%"NumericRangeInc[Int]"* %"$rangeVar", i32* %"$tmpForRef", i32 %9) br label %while_block while_block: ; preds = %while_step, %cond_end - %9 = call i1 @isEmpty.519(%"NumericRangeInc[Int]"* %"$rangeVar") - %10 = xor i1 true, %9 - br i1 %10, label %while_body, label %while_end + %10 = call i1 @isEmpty.504(%"NumericRangeInc[Int]"* %"$rangeVar") + %11 = xor i1 true, %10 + br i1 %11, label %while_body, label %while_end while_body: ; preds = %while_block - %11 = call i32 @front.520(%"NumericRangeInc[Int]"* %"$rangeVar") - store i32 %11, i32* %i - %12 = getelementptr inbounds %StringCharSource, %StringCharSource* %this, i32 0, i32 0 - %13 = load %StringRef, %StringRef* %12 - %14 = call i8* @front(%StringRef %13) - %15 = load i8, i8* %14 - call void @"+=.461"(%String* %dest, i8 %15) - %16 = getelementptr inbounds %StringCharSource, %StringCharSource* %this, i32 0, i32 0 - call void @popFront(%StringRef* %16) + %12 = call i32 @front.505(%"NumericRangeInc[Int]"* %"$rangeVar") + store i32 %12, i32* %i + %13 = getelementptr inbounds %StringCharSource, %StringCharSource* %this, i32 0, i32 0 + %14 = load %StringRef, %StringRef* %13 + %15 = call i8* @front(%StringRef %14) + %16 = load i8, i8* %15 + call void @"+=.450"(%String* %dest, i8 %16) + %17 = getelementptr inbounds %StringCharSource, %StringCharSource* %this, i32 0, i32 0 + call void @popFront(%StringRef* %17) br label %while_step while_step: ; preds = %while_body - call void @popFront.521(%"NumericRangeInc[Int]"* %"$rangeVar") + call void @popFront.506(%"NumericRangeInc[Int]"* %"$rangeVar") br label %while_block while_end: ; preds = %while_block @@ -19218,9 +18595,9 @@ if_block: ; preds = %code if_then: ; preds = %if_block %4 = load %ParserContext*, %ParserContext** %obj.addr - call void @dtor.247(%ParserContext* %4) + call void @dtor.236(%ParserContext* %4) %5 = load %ParserContext*, %ParserContext** %obj.addr - call void @ctor.532(%UntypedPtr* %tmp.this, %ParserContext* %5) + call void @ctor.517(%UntypedPtr* %tmp.this, %ParserContext* %5) %6 = load %UntypedPtr, %UntypedPtr* %tmp.this call void @free(%UntypedPtr %6) br label %if_end @@ -19230,7 +18607,7 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal void @ctor.532(%UntypedPtr* %this, %ParserContext* %val) #4 { +define internal void @ctor.517(%UntypedPtr* %this, %ParserContext* %val) #4 { %val.addr = alloca %ParserContext* store %ParserContext* %val, %ParserContext** %val.addr br label %code @@ -19252,9 +18629,9 @@ define void @spr_parserIf_nextToken(%ParserContext* %ctx, %Token* %outToken) #5 code: ; preds = %0 %1 = getelementptr inbounds %ParserContext, %ParserContext* %ctx, i32 0, i32 0 - call void @"post_++.398"(%Token* %"$tmpC", %SparrowScanner* %1) - call void @"=.285"(%Token* %outToken, %Token* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC") + call void @"post_++.387"(%Token* %"$tmpC", %SparrowScanner* %1) + call void @"=.274"(%Token* %outToken, %Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") ret void } @@ -19281,13 +18658,13 @@ define internal %Node @parseModule(%"SparrowParser[SparrowLayoutDecoder[SparrowS code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") %2 = call %Node @parseModuleName(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %2, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %moduleName, %Node* %"$tmpForRef1") - call void @ctor.546(%Node* %decls) + call void @ctor.520(%Node* %moduleName, %Node* %"$tmpForRef1") + call void @ctor.531(%Node* %decls) call void @parseStmts(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true, %Node* %decls) - call void @ctor.404(%TokenType* %tmp.this, i32 0) + call void @ctor.393(%TokenType* %tmp.this, i32 0) %3 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %5 = load %Location, %Location* %loc @@ -19306,39 +18683,39 @@ define internal %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowSc code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) + call void @"pre_*.518"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) %2 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 0 %3 = load %Location, %Location* %2 - call void @dtor.249(%Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") ret %Location %3 dumy_block: ; No predecessors! - call void @dtor.249(%Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") unreachable } ; Function Attrs: inlinehint nounwind -define internal void @"pre_*.533"(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) #4 { +define internal void @"pre_*.518"(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) #4 { br label %code code: ; preds = %0 - call void @front.534(%Token* %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) + call void @front.519(%Token* %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) ret void } ; Function Attrs: inlinehint nounwind -define internal void @front.534(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #4 { +define internal void @front.519(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %2 = call %Token* @front.482(%"Vector[Token]"* %1) - call void @ctor.188(%Token* %_result, %Token* %2) + %2 = call %Token* @front.471(%"Vector[Token]"* %1) + call void @ctor.177(%Token* %_result, %Token* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.535(%Node* %this, %Node* %other) #3 { +define internal void @ctor.520(%Node* %this, %Node* %other) #3 { %other.addr = alloca %Node* store %Node* %other, %Node** %other.addr br label %code @@ -19348,7 +18725,7 @@ code: ; preds = %0 %2 = load %Node*, %Node** %other.addr %3 = getelementptr inbounds %Node, %Node* %2, i32 0, i32 0 %4 = load %UntypedPtr, %UntypedPtr* %3 - call void @ctor.55(%UntypedPtr* %1, %UntypedPtr %4) + call void @ctor.45(%UntypedPtr* %1, %UntypedPtr %4) ret void } @@ -19366,7 +18743,7 @@ code: ; preds = %0 br label %while_block while_block: ; preds = %while_step, %code - call void @ctor.404(%TokenType* %tmp.this, i32 32) + call void @ctor.393(%TokenType* %tmp.this, i32 32) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %while_body, label %while_end @@ -19380,21 +18757,21 @@ while_end: ; preds = %while_block br label %if_block if_block: ; preds = %while_end - call void @ctor.404(%TokenType* %tmp.this1, i32 2) + call void @ctor.393(%TokenType* %tmp.this1, i32 2) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br i1 %2, label %if_then, label %if_end if_then: ; preds = %if_block %3 = call %Node @parseQualifiedName(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 false) store %Node %3, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %qid, %Node* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this2, i32 32) + call void @ctor.520(%Node* %qid, %Node* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this2, i32 32) %4 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this2) %5 = load %Node, %Node* %qid ret %Node %5 if_end: ; preds = %dumy_block, %if_block - call void @ctor.546(%Node* %tmp.this3) + call void @ctor.531(%Node* %tmp.this3) %6 = load %Node, %Node* %tmp.this3 ret %Node %6 @@ -19413,22 +18790,22 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) + call void @"pre_*.518"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) %2 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 - %3 = call i1 @"==.339"(%TokenType* %2, %TokenType* %t) + %3 = call i1 @"==.328"(%TokenType* %2, %TokenType* %t) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"post_++.536"(%Token* %"$tmpC1", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %5) - call void @"=.285"(%Token* %4, %Token* %"$tmpC1") - call void @dtor.249(%Token* %"$tmpC1") - call void @dtor.249(%Token* %"$tmpC") + call void @"post_++.521"(%Token* %"$tmpC1", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %5) + call void @"=.274"(%Token* %4, %Token* %"$tmpC1") + call void @dtor.238(%Token* %"$tmpC1") + call void @dtor.238(%Token* %"$tmpC") ret i1 true if_end: ; preds = %dumy_block, %if_block - call void @dtor.249(%Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") ret i1 false dumy_block: ; No predecessors! @@ -19436,61 +18813,58 @@ dumy_block: ; No predecessors! } ; Function Attrs: inlinehint nounwind -define internal void @"post_++.536"(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) #4 { +define internal void @"post_++.521"(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) #4 { %res = alloca %Token br label %code code: ; preds = %0 - call void @front.534(%Token* %res, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) - call void @popFront.537(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) - call void @ctor.188(%Token* %_result, %Token* %res) - call void @dtor.249(%Token* %res) + call void @front.519(%Token* %res, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) + call void @popFront.522(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %r) + call void @ctor.177(%Token* %_result, %Token* %res) + call void @dtor.238(%Token* %res) ret void dumy_block: ; No predecessors! - call void @dtor.249(%Token* %res) + call void @dtor.238(%Token* %res) ret void } ; Function Attrs: inlinehint nounwind -define internal void @popFront.537(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #4 { - %tmp.this = alloca i64 +define internal void @popFront.522(%"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this) #4 { %"$tmpC" = alloca %Token br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - store i64 0, i64* %tmp.this - %2 = load i64, i64* %tmp.this - call void @remove.486(%"Vector[Token]"* %1, i64 %2) + call void @remove.475(%"Vector[Token]"* %1, i32 0) br label %if_block if_block: ; preds = %code - %3 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %4 = call i1 @isEmpty.480(%"Vector[Token]"* %3) - br i1 %4, label %cond.true, label %cond.false + %2 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %3 = call i1 @isEmpty.469(%"Vector[Token]"* %2) + br i1 %3, label %cond.true, label %cond.false if_then: ; preds = %cond.end - %5 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %6 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"post_++.511"(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %6) - call void @"+=.396"(%"Vector[Token]"* %5, %Token* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC") + %4 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %5 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 + call void @"post_++.496"(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %5) + call void @"+=.385"(%"Vector[Token]"* %4, %Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") br label %if_end if_end: ; preds = %if_then, %cond.end ret void cond.true: ; preds = %if_block - %7 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - %8 = call i1 @"pre_!!.509"(%"SparrowLayoutDecoder[SparrowScanner]"* %7) + %6 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 + %7 = call i1 @"pre_!!.494"(%"SparrowLayoutDecoder[SparrowScanner]"* %6) br label %cond.end cond.false: ; preds = %if_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %8, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %7, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %if_then, label %if_end } @@ -19514,8 +18888,8 @@ define internal %Node @parseQualifiedName(%"SparrowParser[SparrowLayoutDecoder[S code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this, i32 37) + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this, i32 37) %2 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %4 = load %Location, %Location* %loc @@ -19524,14 +18898,14 @@ code: ; preds = %0 %7 = call %StringRef @asStringRef(%String* %6) %8 = call %Node @mkIdentifier(%AstBuilder* %3, %Location %4, %StringRef %7) store %Node %8, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %base, %Node* %"$tmpForRef1") + call void @ctor.520(%Node* %base, %Node* %"$tmpForRef1") %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %10 = getelementptr inbounds %Token, %Token* %9, i32 0, i32 2 - call void @ctor.175(%String* %lastId, %String* %10) + call void @ctor.165(%String* %lastId, %String* %10) br label %while_block while_block: ; preds = %while_step, %code - call void @ctor.404(%TokenType* %tmp.this2, i32 34) + call void @ctor.393(%TokenType* %tmp.this2, i32 34) %11 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this2) br i1 %11, label %while_body, label %while_end @@ -19543,7 +18917,7 @@ while_step: ; preds = %cond_destruct_end7 while_end: ; preds = %cond_destruct_end, %while_block %12 = load %Node, %Node* %base - call void @dtor.250(%String* %lastId) + call void @dtor.239(%String* %lastId) ret %Node %12 if_block: ; preds = %while_body @@ -19561,14 +18935,14 @@ if_then: ; preds = %cond.end %21 = call %StringRef @asStringRef(%String* %20) %22 = call %Node @mkStarExpr(%AstBuilder* %14, %Location %17, %Node %18, %StringRef %21) store %Node %22, %Node* %"$tmpForRef4" - call void @"=.544"(%Node* %base, %Node* %"$tmpForRef4") + call void @"=.529"(%Node* %base, %Node* %"$tmpForRef4") br i1 %13, label %cond_destruct_alt1, label %cond_destruct_alt2 if_end: ; preds = %dumy_block, %cond.end br i1 %13, label %cond_destruct_alt15, label %cond_destruct_alt26 cond.true: ; preds = %if_block - call void @ctor.404(%TokenType* %tmp.this3, i32 38) + call void @ctor.393(%TokenType* %tmp.this3, i32 38) %23 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this3) br label %cond.end @@ -19598,7 +18972,7 @@ cond_destruct_alt26: ; preds = %if_end br label %cond_destruct_end7 cond_destruct_end7: ; preds = %cond_destruct_alt26, %cond_destruct_alt15 - call void @ctor.404(%TokenType* %tmp.this8, i32 37) + call void @ctor.393(%TokenType* %tmp.this8, i32 37) %24 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this8) %25 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %26 = load %Location, %Location* %loc @@ -19610,11 +18984,11 @@ cond_destruct_end7: ; preds = %cond_destruct_alt26 %32 = call %StringRef @asStringRef(%String* %31) %33 = call %Node @mkCompoundExpr(%AstBuilder* %25, %Location %28, %Node %29, %StringRef %32) store %Node %33, %Node* %"$tmpForRef9" - call void @"=.544"(%Node* %base, %Node* %"$tmpForRef9") + call void @"=.529"(%Node* %base, %Node* %"$tmpForRef9") br label %while_step dumy_block10: ; No predecessors! - call void @dtor.250(%String* %lastId) + call void @dtor.239(%String* %lastId) unreachable } @@ -19662,7 +19036,7 @@ if_end3: ; preds = %dumy_block4, %if_bl %8 = load %StringRef, %StringRef* %tmp.StringRef store %StringRef %8, %StringRef* %"$tmpForRef" %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC5", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %9) + call void @"pre_*.518"(%Token* %"$tmpC5", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %9) %10 = getelementptr inbounds %Token, %Token* %"$tmpC5", i32 0, i32 1 %11 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef7, i32 0, i32 0 %12 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef7, i32 0, i32 1 @@ -19672,10 +19046,10 @@ if_end3: ; preds = %dumy_block4, %if_bl store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @str.94, i32 0, i32 12), i8** %14 %15 = load %StringRef, %StringRef* %tmp.StringRef7 store %StringRef %15, %StringRef* %"$tmpForRef6" - call void @toString.539(%String* %"$tmpC", %StringRef* %"$tmpForRef", %TokenType* %10, %StringRef* %"$tmpForRef6", %TokenType* %t) - call void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC5") + call void @toString.524(%String* %"$tmpC", %StringRef* %"$tmpForRef", %TokenType* %10, %StringRef* %"$tmpForRef6", %TokenType* %t) + call void @reportError.523(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC5") ret i1 false dumy_block4: ; No predecessors! @@ -19683,7 +19057,7 @@ dumy_block4: ; No predecessors! } ; Function Attrs: inlinehint nounwind -define internal void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %msg) #4 { +define internal void @reportError.523(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %msg) #4 { %"$tmpC" = alloca %Token %"$tmpC1" = alloca %Token %tmp.this = alloca %TokenType @@ -19693,42 +19067,42 @@ define internal void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[Sparr code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 4 %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2) + call void @"pre_*.518"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %2) %3 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 0 %4 = load %Location, %Location* %3 - call void @reportError.437(%ErrorReporter* %1, %Location %4, %String* %msg) - call void @dtor.249(%Token* %"$tmpC") + call void @reportError.426(%ErrorReporter* %1, %Location %4, %String* %msg) + call void @dtor.238(%Token* %"$tmpC") br label %while_block while_block: ; preds = %while_step, %code %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC1", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %5) + call void @"pre_*.518"(%Token* %"$tmpC1", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %5) %6 = getelementptr inbounds %Token, %Token* %"$tmpC1", i32 0, i32 1 - call void @ctor.404(%TokenType* %tmp.this, i32 0) - %7 = call i1 @"==.339"(%TokenType* %6, %TokenType* %tmp.this) + call void @ctor.393(%TokenType* %tmp.this, i32 0) + %7 = call i1 @"==.328"(%TokenType* %6, %TokenType* %tmp.this) %8 = xor i1 true, %7 br i1 %8, label %while_body, label %while_end while_body: ; preds = %while_block %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %10 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"post_++.536"(%Token* %"$tmpC2", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %10) - call void @"=.285"(%Token* %9, %Token* %"$tmpC2") - call void @dtor.249(%Token* %"$tmpC2") + call void @"post_++.521"(%Token* %"$tmpC2", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %10) + call void @"=.274"(%Token* %9, %Token* %"$tmpC2") + call void @dtor.238(%Token* %"$tmpC2") br label %while_step while_step: ; preds = %while_body br label %while_block while_end: ; preds = %while_block - call void @dtor.249(%Token* %"$tmpC1") + call void @dtor.238(%Token* %"$tmpC1") %11 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 2 store i1 true, i1* %11 ret void } ; Function Attrs: inlinehint nounwind -define internal void @toString.539(%String* sret %_result, %StringRef* %a1, %TokenType* %a2, %StringRef* %a3, %TokenType* %a4) #4 { +define internal void @toString.524(%String* sret %_result, %StringRef* %a1, %TokenType* %a2, %StringRef* %a3, %TokenType* %a4) #4 { %s = alloca %StringOutputStream %"$tmpC" = alloca %StringOutputStream %"$tmpC1" = alloca %StringOutputStream @@ -19737,32 +19111,32 @@ define internal void @toString.539(%String* sret %_result, %StringRef* %a1, %Tok br label %code code: ; preds = %0 - call void @ctor.439(%StringOutputStream* %s) + call void @ctor.428(%StringOutputStream* %s) call void @"<<"(%StringOutputStream* %"$tmpC3", %StringOutputStream* %s, %StringRef* %a1) - call void @"<<.540"(%StringOutputStream* %"$tmpC2", %StringOutputStream* %"$tmpC3", %TokenType* %a2) + call void @"<<.525"(%StringOutputStream* %"$tmpC2", %StringOutputStream* %"$tmpC3", %TokenType* %a2) call void @"<<"(%StringOutputStream* %"$tmpC1", %StringOutputStream* %"$tmpC2", %StringRef* %a3) - call void @"<<.540"(%StringOutputStream* %"$tmpC", %StringOutputStream* %"$tmpC1", %TokenType* %a4) - call void @dtor.442(%StringOutputStream* %"$tmpC") - call void @dtor.442(%StringOutputStream* %"$tmpC1") - call void @dtor.442(%StringOutputStream* %"$tmpC2") - call void @dtor.442(%StringOutputStream* %"$tmpC3") + call void @"<<.525"(%StringOutputStream* %"$tmpC", %StringOutputStream* %"$tmpC1", %TokenType* %a4) + call void @dtor.431(%StringOutputStream* %"$tmpC") + call void @dtor.431(%StringOutputStream* %"$tmpC1") + call void @dtor.431(%StringOutputStream* %"$tmpC2") + call void @dtor.431(%StringOutputStream* %"$tmpC3") %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %s, i32 0, i32 0 - call void @ctor.175(%String* %_result, %String* %1) - call void @dtor.442(%StringOutputStream* %s) + call void @ctor.165(%String* %_result, %String* %1) + call void @dtor.431(%StringOutputStream* %s) ret void dumy_block: ; No predecessors! - call void @dtor.442(%StringOutputStream* %s) + call void @dtor.431(%StringOutputStream* %s) ret void } ; Function Attrs: inlinehint nounwind -define internal void @"<<.540"(%StringOutputStream* sret %_result, %StringOutputStream* %s, %TokenType* %x) #4 { +define internal void @"<<.525"(%StringOutputStream* sret %_result, %StringOutputStream* %s, %TokenType* %x) #4 { br label %code code: ; preds = %0 call void @">>"(%TokenType* %x, %StringOutputStream* %s) - call void @ctor.441(%StringOutputStream* %_result, %StringOutputStream* %s) + call void @ctor.430(%StringOutputStream* %_result, %StringOutputStream* %s) ret void } @@ -19774,24 +19148,24 @@ define internal void @">>"(%TokenType* %t, %StringOutputStream* %os) #4 { code: ; preds = %0 call void @_asString(%String* %"$tmpC1", %TokenType* %t) - call void @"<<.541"(%StringOutputStream* %"$tmpC", %StringOutputStream* %os, %String* %"$tmpC1") - call void @dtor.442(%StringOutputStream* %"$tmpC") - call void @dtor.250(%String* %"$tmpC1") + call void @"<<.526"(%StringOutputStream* %"$tmpC", %StringOutputStream* %os, %String* %"$tmpC1") + call void @dtor.431(%StringOutputStream* %"$tmpC") + call void @dtor.239(%String* %"$tmpC1") ret void } ; Function Attrs: inlinehint nounwind -define internal void @"<<.541"(%StringOutputStream* sret %_result, %StringOutputStream* %s, %String* %x) #4 { +define internal void @"<<.526"(%StringOutputStream* sret %_result, %StringOutputStream* %s, %String* %x) #4 { br label %code code: ; preds = %0 - call void @">>.542"(%String* %x, %StringOutputStream* %s) - call void @ctor.441(%StringOutputStream* %_result, %StringOutputStream* %s) + call void @">>.527"(%String* %x, %StringOutputStream* %s) + call void @ctor.430(%StringOutputStream* %_result, %StringOutputStream* %s) ret void } ; Function Attrs: inlinehint nounwind -define internal void @">>.542"(%String* %this, %StringOutputStream* %os) #4 { +define internal void @">>.527"(%String* %this, %StringOutputStream* %os) #4 { %"$tmpC" = alloca %StringOutputStream %"$tmpForRef" = alloca %StringRef br label %code @@ -19800,7 +19174,7 @@ code: ; preds = %0 %1 = call %StringRef @asStringRef(%String* %this) store %StringRef %1, %StringRef* %"$tmpForRef" call void @"<<"(%StringOutputStream* %"$tmpC", %StringOutputStream* %os, %StringRef* %"$tmpForRef") - call void @dtor.442(%StringOutputStream* %"$tmpC") + call void @dtor.431(%StringOutputStream* %"$tmpC") ret void } @@ -19912,8 +19286,8 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 0) - %1 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this) + call void @ctor.393(%TokenType* %tmp.this, i32 0) + %1 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_else if_then: ; preds = %if_block @@ -19924,7 +19298,7 @@ if_then: ; preds = %if_block store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @str.43, i32 0, i32 0), i8** %4 store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @str.43, i32 0, i32 11), i8** %5 %6 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %_result, %StringRef %6) + call void @ctor.448(%String* %_result, %StringRef %6) ret void if_else: ; preds = %if_block @@ -19937,8 +19311,8 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_else - call void @ctor.404(%TokenType* %tmp.this5, i32 1) - %7 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this5) + call void @ctor.393(%TokenType* %tmp.this5, i32 1) + %7 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this5) br i1 %7, label %if_then2, label %if_else3 if_then2: ; preds = %if_block1 @@ -19949,7 +19323,7 @@ if_then2: ; preds = %if_block1 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.44, i32 0, i32 0), i8** %10 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.44, i32 0, i32 8), i8** %11 %12 = load %StringRef, %StringRef* %tmp.StringRef6 - call void @ctor.459(%String* %_result, %StringRef %12) + call void @ctor.448(%String* %_result, %StringRef %12) ret void if_else3: ; preds = %if_block1 @@ -19962,8 +19336,8 @@ dumy_block7: ; No predecessors! br label %if_end4 if_block8: ; preds = %if_else3 - call void @ctor.404(%TokenType* %tmp.this12, i32 2) - %13 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this12) + call void @ctor.393(%TokenType* %tmp.this12, i32 2) + %13 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this12) br i1 %13, label %if_then9, label %if_else10 if_then9: ; preds = %if_block8 @@ -19974,7 +19348,7 @@ if_then9: ; preds = %if_block8 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.45, i32 0, i32 0), i8** %16 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.45, i32 0, i32 8), i8** %17 %18 = load %StringRef, %StringRef* %tmp.StringRef13 - call void @ctor.459(%String* %_result, %StringRef %18) + call void @ctor.448(%String* %_result, %StringRef %18) ret void if_else10: ; preds = %if_block8 @@ -19987,8 +19361,8 @@ dumy_block14: ; No predecessors! br label %if_end11 if_block15: ; preds = %if_else10 - call void @ctor.404(%TokenType* %tmp.this19, i32 3) - %19 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this19) + call void @ctor.393(%TokenType* %tmp.this19, i32 3) + %19 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this19) br i1 %19, label %if_then16, label %if_else17 if_then16: ; preds = %if_block15 @@ -19999,7 +19373,7 @@ if_then16: ; preds = %if_block15 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.46, i32 0, i32 0), i8** %22 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.46, i32 0, i32 8), i8** %23 %24 = load %StringRef, %StringRef* %tmp.StringRef20 - call void @ctor.459(%String* %_result, %StringRef %24) + call void @ctor.448(%String* %_result, %StringRef %24) ret void if_else17: ; preds = %if_block15 @@ -20012,8 +19386,8 @@ dumy_block21: ; No predecessors! br label %if_end18 if_block22: ; preds = %if_else17 - call void @ctor.404(%TokenType* %tmp.this26, i32 4) - %25 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this26) + call void @ctor.393(%TokenType* %tmp.this26, i32 4) + %25 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this26) br i1 %25, label %if_then23, label %if_else24 if_then23: ; preds = %if_block22 @@ -20024,7 +19398,7 @@ if_then23: ; preds = %if_block22 store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str.47, i32 0, i32 0), i8** %28 store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str.47, i32 0, i32 9), i8** %29 %30 = load %StringRef, %StringRef* %tmp.StringRef27 - call void @ctor.459(%String* %_result, %StringRef %30) + call void @ctor.448(%String* %_result, %StringRef %30) ret void if_else24: ; preds = %if_block22 @@ -20037,8 +19411,8 @@ dumy_block28: ; No predecessors! br label %if_end25 if_block29: ; preds = %if_else24 - call void @ctor.404(%TokenType* %tmp.this33, i32 5) - %31 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this33) + call void @ctor.393(%TokenType* %tmp.this33, i32 5) + %31 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this33) br i1 %31, label %if_then30, label %if_else31 if_then30: ; preds = %if_block29 @@ -20049,7 +19423,7 @@ if_then30: ; preds = %if_block29 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.48, i32 0, i32 0), i8** %34 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.48, i32 0, i32 10), i8** %35 %36 = load %StringRef, %StringRef* %tmp.StringRef34 - call void @ctor.459(%String* %_result, %StringRef %36) + call void @ctor.448(%String* %_result, %StringRef %36) ret void if_else31: ; preds = %if_block29 @@ -20062,8 +19436,8 @@ dumy_block35: ; No predecessors! br label %if_end32 if_block36: ; preds = %if_else31 - call void @ctor.404(%TokenType* %tmp.this40, i32 6) - %37 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this40) + call void @ctor.393(%TokenType* %tmp.this40, i32 6) + %37 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this40) br i1 %37, label %if_then37, label %if_else38 if_then37: ; preds = %if_block36 @@ -20074,7 +19448,7 @@ if_then37: ; preds = %if_block36 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.49, i32 0, i32 0), i8** %40 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.49, i32 0, i32 5), i8** %41 %42 = load %StringRef, %StringRef* %tmp.StringRef41 - call void @ctor.459(%String* %_result, %StringRef %42) + call void @ctor.448(%String* %_result, %StringRef %42) ret void if_else38: ; preds = %if_block36 @@ -20087,8 +19461,8 @@ dumy_block42: ; No predecessors! br label %if_end39 if_block43: ; preds = %if_else38 - call void @ctor.404(%TokenType* %tmp.this47, i32 8) - %43 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this47) + call void @ctor.393(%TokenType* %tmp.this47, i32 8) + %43 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this47) br i1 %43, label %if_then44, label %if_else45 if_then44: ; preds = %if_block43 @@ -20099,7 +19473,7 @@ if_then44: ; preds = %if_block43 store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str.50, i32 0, i32 0), i8** %46 store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str.50, i32 0, i32 9), i8** %47 %48 = load %StringRef, %StringRef* %tmp.StringRef48 - call void @ctor.459(%String* %_result, %StringRef %48) + call void @ctor.448(%String* %_result, %StringRef %48) ret void if_else45: ; preds = %if_block43 @@ -20112,8 +19486,8 @@ dumy_block49: ; No predecessors! br label %if_end46 if_block50: ; preds = %if_else45 - call void @ctor.404(%TokenType* %tmp.this54, i32 9) - %49 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this54) + call void @ctor.393(%TokenType* %tmp.this54, i32 9) + %49 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this54) br i1 %49, label %if_then51, label %if_else52 if_then51: ; preds = %if_block50 @@ -20124,7 +19498,7 @@ if_then51: ; preds = %if_block50 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.51, i32 0, i32 0), i8** %52 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.51, i32 0, i32 7), i8** %53 %54 = load %StringRef, %StringRef* %tmp.StringRef55 - call void @ctor.459(%String* %_result, %StringRef %54) + call void @ctor.448(%String* %_result, %StringRef %54) ret void if_else52: ; preds = %if_block50 @@ -20137,8 +19511,8 @@ dumy_block56: ; No predecessors! br label %if_end53 if_block57: ; preds = %if_else52 - call void @ctor.404(%TokenType* %tmp.this61, i32 7) - %55 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this61) + call void @ctor.393(%TokenType* %tmp.this61, i32 7) + %55 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this61) br i1 %55, label %if_then58, label %if_else59 if_then58: ; preds = %if_block57 @@ -20149,7 +19523,7 @@ if_then58: ; preds = %if_block57 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.52, i32 0, i32 0), i8** %58 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.52, i32 0, i32 5), i8** %59 %60 = load %StringRef, %StringRef* %tmp.StringRef62 - call void @ctor.459(%String* %_result, %StringRef %60) + call void @ctor.448(%String* %_result, %StringRef %60) ret void if_else59: ; preds = %if_block57 @@ -20162,8 +19536,8 @@ dumy_block63: ; No predecessors! br label %if_end60 if_block64: ; preds = %if_else59 - call void @ctor.404(%TokenType* %tmp.this68, i32 10) - %61 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this68) + call void @ctor.393(%TokenType* %tmp.this68, i32 10) + %61 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this68) br i1 %61, label %if_then65, label %if_else66 if_then65: ; preds = %if_block64 @@ -20174,7 +19548,7 @@ if_then65: ; preds = %if_block64 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.53, i32 0, i32 0), i8** %64 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.53, i32 0, i32 5), i8** %65 %66 = load %StringRef, %StringRef* %tmp.StringRef69 - call void @ctor.459(%String* %_result, %StringRef %66) + call void @ctor.448(%String* %_result, %StringRef %66) ret void if_else66: ; preds = %if_block64 @@ -20187,8 +19561,8 @@ dumy_block70: ; No predecessors! br label %if_end67 if_block71: ; preds = %if_else66 - call void @ctor.404(%TokenType* %tmp.this75, i32 11) - %67 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this75) + call void @ctor.393(%TokenType* %tmp.this75, i32 11) + %67 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this75) br i1 %67, label %if_then72, label %if_else73 if_then72: ; preds = %if_block71 @@ -20199,7 +19573,7 @@ if_then72: ; preds = %if_block71 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.54, i32 0, i32 0), i8** %70 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.54, i32 0, i32 7), i8** %71 %72 = load %StringRef, %StringRef* %tmp.StringRef76 - call void @ctor.459(%String* %_result, %StringRef %72) + call void @ctor.448(%String* %_result, %StringRef %72) ret void if_else73: ; preds = %if_block71 @@ -20212,8 +19586,8 @@ dumy_block77: ; No predecessors! br label %if_end74 if_block78: ; preds = %if_else73 - call void @ctor.404(%TokenType* %tmp.this82, i32 12) - %73 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this82) + call void @ctor.393(%TokenType* %tmp.this82, i32 12) + %73 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this82) br i1 %73, label %if_then79, label %if_else80 if_then79: ; preds = %if_block78 @@ -20224,7 +19598,7 @@ if_then79: ; preds = %if_block78 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.55, i32 0, i32 0), i8** %76 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.55, i32 0, i32 7), i8** %77 %78 = load %StringRef, %StringRef* %tmp.StringRef83 - call void @ctor.459(%String* %_result, %StringRef %78) + call void @ctor.448(%String* %_result, %StringRef %78) ret void if_else80: ; preds = %if_block78 @@ -20237,8 +19611,8 @@ dumy_block84: ; No predecessors! br label %if_end81 if_block85: ; preds = %if_else80 - call void @ctor.404(%TokenType* %tmp.this89, i32 13) - %79 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this89) + call void @ctor.393(%TokenType* %tmp.this89, i32 13) + %79 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this89) br i1 %79, label %if_then86, label %if_else87 if_then86: ; preds = %if_block85 @@ -20249,7 +19623,7 @@ if_then86: ; preds = %if_block85 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.56, i32 0, i32 0), i8** %82 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.56, i32 0, i32 10), i8** %83 %84 = load %StringRef, %StringRef* %tmp.StringRef90 - call void @ctor.459(%String* %_result, %StringRef %84) + call void @ctor.448(%String* %_result, %StringRef %84) ret void if_else87: ; preds = %if_block85 @@ -20262,8 +19636,8 @@ dumy_block91: ; No predecessors! br label %if_end88 if_block92: ; preds = %if_else87 - call void @ctor.404(%TokenType* %tmp.this96, i32 14) - %85 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this96) + call void @ctor.393(%TokenType* %tmp.this96, i32 14) + %85 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this96) br i1 %85, label %if_then93, label %if_else94 if_then93: ; preds = %if_block92 @@ -20274,7 +19648,7 @@ if_then93: ; preds = %if_block92 store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str.57, i32 0, i32 0), i8** %88 store i8* getelementptr inbounds ([10 x i8], [10 x i8]* @str.57, i32 0, i32 9), i8** %89 %90 = load %StringRef, %StringRef* %tmp.StringRef97 - call void @ctor.459(%String* %_result, %StringRef %90) + call void @ctor.448(%String* %_result, %StringRef %90) ret void if_else94: ; preds = %if_block92 @@ -20287,8 +19661,8 @@ dumy_block98: ; No predecessors! br label %if_end95 if_block99: ; preds = %if_else94 - call void @ctor.404(%TokenType* %tmp.this103, i32 15) - %91 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this103) + call void @ctor.393(%TokenType* %tmp.this103, i32 15) + %91 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this103) br i1 %91, label %if_then100, label %if_else101 if_then100: ; preds = %if_block99 @@ -20299,7 +19673,7 @@ if_then100: ; preds = %if_block99 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.58, i32 0, i32 0), i8** %94 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.58, i32 0, i32 5), i8** %95 %96 = load %StringRef, %StringRef* %tmp.StringRef104 - call void @ctor.459(%String* %_result, %StringRef %96) + call void @ctor.448(%String* %_result, %StringRef %96) ret void if_else101: ; preds = %if_block99 @@ -20312,8 +19686,8 @@ dumy_block105: ; No predecessors! br label %if_end102 if_block106: ; preds = %if_else101 - call void @ctor.404(%TokenType* %tmp.this110, i32 16) - %97 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this110) + call void @ctor.393(%TokenType* %tmp.this110, i32 16) + %97 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this110) br i1 %97, label %if_then107, label %if_else108 if_then107: ; preds = %if_block106 @@ -20324,7 +19698,7 @@ if_then107: ; preds = %if_block106 store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @str.59, i32 0, i32 0), i8** %100 store i8* getelementptr inbounds ([5 x i8], [5 x i8]* @str.59, i32 0, i32 4), i8** %101 %102 = load %StringRef, %StringRef* %tmp.StringRef111 - call void @ctor.459(%String* %_result, %StringRef %102) + call void @ctor.448(%String* %_result, %StringRef %102) ret void if_else108: ; preds = %if_block106 @@ -20337,8 +19711,8 @@ dumy_block112: ; No predecessors! br label %if_end109 if_block113: ; preds = %if_else108 - call void @ctor.404(%TokenType* %tmp.this117, i32 17) - %103 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this117) + call void @ctor.393(%TokenType* %tmp.this117, i32 17) + %103 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this117) br i1 %103, label %if_then114, label %if_else115 if_then114: ; preds = %if_block113 @@ -20349,7 +19723,7 @@ if_then114: ; preds = %if_block113 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.60, i32 0, i32 0), i8** %106 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.60, i32 0, i32 8), i8** %107 %108 = load %StringRef, %StringRef* %tmp.StringRef118 - call void @ctor.459(%String* %_result, %StringRef %108) + call void @ctor.448(%String* %_result, %StringRef %108) ret void if_else115: ; preds = %if_block113 @@ -20362,8 +19736,8 @@ dumy_block119: ; No predecessors! br label %if_end116 if_block120: ; preds = %if_else115 - call void @ctor.404(%TokenType* %tmp.this124, i32 18) - %109 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this124) + call void @ctor.393(%TokenType* %tmp.this124, i32 18) + %109 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this124) br i1 %109, label %if_then121, label %if_else122 if_then121: ; preds = %if_block120 @@ -20374,7 +19748,7 @@ if_then121: ; preds = %if_block120 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.61, i32 0, i32 0), i8** %112 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.61, i32 0, i32 7), i8** %113 %114 = load %StringRef, %StringRef* %tmp.StringRef125 - call void @ctor.459(%String* %_result, %StringRef %114) + call void @ctor.448(%String* %_result, %StringRef %114) ret void if_else122: ; preds = %if_block120 @@ -20387,8 +19761,8 @@ dumy_block126: ; No predecessors! br label %if_end123 if_block127: ; preds = %if_else122 - call void @ctor.404(%TokenType* %tmp.this131, i32 19) - %115 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this131) + call void @ctor.393(%TokenType* %tmp.this131, i32 19) + %115 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this131) br i1 %115, label %if_then128, label %if_else129 if_then128: ; preds = %if_block127 @@ -20399,7 +19773,7 @@ if_then128: ; preds = %if_block127 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.62, i32 0, i32 0), i8** %118 store i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.62, i32 0, i32 5), i8** %119 %120 = load %StringRef, %StringRef* %tmp.StringRef132 - call void @ctor.459(%String* %_result, %StringRef %120) + call void @ctor.448(%String* %_result, %StringRef %120) ret void if_else129: ; preds = %if_block127 @@ -20412,8 +19786,8 @@ dumy_block133: ; No predecessors! br label %if_end130 if_block134: ; preds = %if_else129 - call void @ctor.404(%TokenType* %tmp.this138, i32 20) - %121 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this138) + call void @ctor.393(%TokenType* %tmp.this138, i32 20) + %121 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this138) br i1 %121, label %if_then135, label %if_else136 if_then135: ; preds = %if_block134 @@ -20424,7 +19798,7 @@ if_then135: ; preds = %if_block134 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.63, i32 0, i32 0), i8** %124 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.63, i32 0, i32 7), i8** %125 %126 = load %StringRef, %StringRef* %tmp.StringRef139 - call void @ctor.459(%String* %_result, %StringRef %126) + call void @ctor.448(%String* %_result, %StringRef %126) ret void if_else136: ; preds = %if_block134 @@ -20437,8 +19811,8 @@ dumy_block140: ; No predecessors! br label %if_end137 if_block141: ; preds = %if_else136 - call void @ctor.404(%TokenType* %tmp.this145, i32 21) - %127 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this145) + call void @ctor.393(%TokenType* %tmp.this145, i32 21) + %127 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this145) br i1 %127, label %if_then142, label %if_else143 if_then142: ; preds = %if_block141 @@ -20449,7 +19823,7 @@ if_then142: ; preds = %if_block141 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.64, i32 0, i32 0), i8** %130 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.64, i32 0, i32 7), i8** %131 %132 = load %StringRef, %StringRef* %tmp.StringRef146 - call void @ctor.459(%String* %_result, %StringRef %132) + call void @ctor.448(%String* %_result, %StringRef %132) ret void if_else143: ; preds = %if_block141 @@ -20462,8 +19836,8 @@ dumy_block147: ; No predecessors! br label %if_end144 if_block148: ; preds = %if_else143 - call void @ctor.404(%TokenType* %tmp.this152, i32 22) - %133 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this152) + call void @ctor.393(%TokenType* %tmp.this152, i32 22) + %133 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this152) br i1 %133, label %if_then149, label %if_else150 if_then149: ; preds = %if_block148 @@ -20474,7 +19848,7 @@ if_then149: ; preds = %if_block148 store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.65, i32 0, i32 0), i8** %136 store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.65, i32 0, i32 6), i8** %137 %138 = load %StringRef, %StringRef* %tmp.StringRef153 - call void @ctor.459(%String* %_result, %StringRef %138) + call void @ctor.448(%String* %_result, %StringRef %138) ret void if_else150: ; preds = %if_block148 @@ -20487,8 +19861,8 @@ dumy_block154: ; No predecessors! br label %if_end151 if_block155: ; preds = %if_else150 - call void @ctor.404(%TokenType* %tmp.this159, i32 23) - %139 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this159) + call void @ctor.393(%TokenType* %tmp.this159, i32 23) + %139 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this159) br i1 %139, label %if_then156, label %if_else157 if_then156: ; preds = %if_block155 @@ -20499,7 +19873,7 @@ if_then156: ; preds = %if_block155 store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.66, i32 0, i32 0), i8** %142 store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.66, i32 0, i32 6), i8** %143 %144 = load %StringRef, %StringRef* %tmp.StringRef160 - call void @ctor.459(%String* %_result, %StringRef %144) + call void @ctor.448(%String* %_result, %StringRef %144) ret void if_else157: ; preds = %if_block155 @@ -20512,8 +19886,8 @@ dumy_block161: ; No predecessors! br label %if_end158 if_block162: ; preds = %if_else157 - call void @ctor.404(%TokenType* %tmp.this166, i32 24) - %145 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this166) + call void @ctor.393(%TokenType* %tmp.this166, i32 24) + %145 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this166) br i1 %145, label %if_then163, label %if_else164 if_then163: ; preds = %if_block162 @@ -20524,7 +19898,7 @@ if_then163: ; preds = %if_block162 store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.67, i32 0, i32 0), i8** %148 store i8* getelementptr inbounds ([7 x i8], [7 x i8]* @str.67, i32 0, i32 6), i8** %149 %150 = load %StringRef, %StringRef* %tmp.StringRef167 - call void @ctor.459(%String* %_result, %StringRef %150) + call void @ctor.448(%String* %_result, %StringRef %150) ret void if_else164: ; preds = %if_block162 @@ -20537,8 +19911,8 @@ dumy_block168: ; No predecessors! br label %if_end165 if_block169: ; preds = %if_else164 - call void @ctor.404(%TokenType* %tmp.this173, i32 25) - %151 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this173) + call void @ctor.393(%TokenType* %tmp.this173, i32 25) + %151 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this173) br i1 %151, label %if_then170, label %if_else171 if_then170: ; preds = %if_block169 @@ -20549,7 +19923,7 @@ if_then170: ; preds = %if_block169 store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str.68, i32 0, i32 0), i8** %154 store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str.68, i32 0, i32 15), i8** %155 %156 = load %StringRef, %StringRef* %tmp.StringRef174 - call void @ctor.459(%String* %_result, %StringRef %156) + call void @ctor.448(%String* %_result, %StringRef %156) ret void if_else171: ; preds = %if_block169 @@ -20562,8 +19936,8 @@ dumy_block175: ; No predecessors! br label %if_end172 if_block176: ; preds = %if_else171 - call void @ctor.404(%TokenType* %tmp.this180, i32 26) - %157 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this180) + call void @ctor.393(%TokenType* %tmp.this180, i32 26) + %157 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this180) br i1 %157, label %if_then177, label %if_else178 if_then177: ; preds = %if_block176 @@ -20574,7 +19948,7 @@ if_then177: ; preds = %if_block176 store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str.69, i32 0, i32 0), i8** %160 store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @str.69, i32 0, i32 15), i8** %161 %162 = load %StringRef, %StringRef* %tmp.StringRef181 - call void @ctor.459(%String* %_result, %StringRef %162) + call void @ctor.448(%String* %_result, %StringRef %162) ret void if_else178: ; preds = %if_block176 @@ -20587,8 +19961,8 @@ dumy_block182: ; No predecessors! br label %if_end179 if_block183: ; preds = %if_else178 - call void @ctor.404(%TokenType* %tmp.this187, i32 27) - %163 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this187) + call void @ctor.393(%TokenType* %tmp.this187, i32 27) + %163 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this187) br i1 %163, label %if_then184, label %if_else185 if_then184: ; preds = %if_block183 @@ -20599,7 +19973,7 @@ if_then184: ; preds = %if_block183 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.70, i32 0, i32 0), i8** %166 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.70, i32 0, i32 3), i8** %167 %168 = load %StringRef, %StringRef* %tmp.StringRef188 - call void @ctor.459(%String* %_result, %StringRef %168) + call void @ctor.448(%String* %_result, %StringRef %168) ret void if_else185: ; preds = %if_block183 @@ -20612,8 +19986,8 @@ dumy_block189: ; No predecessors! br label %if_end186 if_block190: ; preds = %if_else185 - call void @ctor.404(%TokenType* %tmp.this194, i32 28) - %169 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this194) + call void @ctor.393(%TokenType* %tmp.this194, i32 28) + %169 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this194) br i1 %169, label %if_then191, label %if_else192 if_then191: ; preds = %if_block190 @@ -20624,7 +19998,7 @@ if_then191: ; preds = %if_block190 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.71, i32 0, i32 0), i8** %172 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.71, i32 0, i32 3), i8** %173 %174 = load %StringRef, %StringRef* %tmp.StringRef195 - call void @ctor.459(%String* %_result, %StringRef %174) + call void @ctor.448(%String* %_result, %StringRef %174) ret void if_else192: ; preds = %if_block190 @@ -20637,8 +20011,8 @@ dumy_block196: ; No predecessors! br label %if_end193 if_block197: ; preds = %if_else192 - call void @ctor.404(%TokenType* %tmp.this201, i32 29) - %175 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this201) + call void @ctor.393(%TokenType* %tmp.this201, i32 29) + %175 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this201) br i1 %175, label %if_then198, label %if_else199 if_then198: ; preds = %if_block197 @@ -20649,7 +20023,7 @@ if_then198: ; preds = %if_block197 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.72, i32 0, i32 0), i8** %178 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.72, i32 0, i32 3), i8** %179 %180 = load %StringRef, %StringRef* %tmp.StringRef202 - call void @ctor.459(%String* %_result, %StringRef %180) + call void @ctor.448(%String* %_result, %StringRef %180) ret void if_else199: ; preds = %if_block197 @@ -20662,8 +20036,8 @@ dumy_block203: ; No predecessors! br label %if_end200 if_block204: ; preds = %if_else199 - call void @ctor.404(%TokenType* %tmp.this208, i32 30) - %181 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this208) + call void @ctor.393(%TokenType* %tmp.this208, i32 30) + %181 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this208) br i1 %181, label %if_then205, label %if_else206 if_then205: ; preds = %if_block204 @@ -20674,7 +20048,7 @@ if_then205: ; preds = %if_block204 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.73, i32 0, i32 0), i8** %184 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.73, i32 0, i32 3), i8** %185 %186 = load %StringRef, %StringRef* %tmp.StringRef209 - call void @ctor.459(%String* %_result, %StringRef %186) + call void @ctor.448(%String* %_result, %StringRef %186) ret void if_else206: ; preds = %if_block204 @@ -20687,8 +20061,8 @@ dumy_block210: ; No predecessors! br label %if_end207 if_block211: ; preds = %if_else206 - call void @ctor.404(%TokenType* %tmp.this215, i32 31) - %187 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this215) + call void @ctor.393(%TokenType* %tmp.this215, i32 31) + %187 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this215) br i1 %187, label %if_then212, label %if_else213 if_then212: ; preds = %if_block211 @@ -20699,7 +20073,7 @@ if_then212: ; preds = %if_block211 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.74, i32 0, i32 0), i8** %190 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.74, i32 0, i32 3), i8** %191 %192 = load %StringRef, %StringRef* %tmp.StringRef216 - call void @ctor.459(%String* %_result, %StringRef %192) + call void @ctor.448(%String* %_result, %StringRef %192) ret void if_else213: ; preds = %if_block211 @@ -20712,8 +20086,8 @@ dumy_block217: ; No predecessors! br label %if_end214 if_block218: ; preds = %if_else213 - call void @ctor.404(%TokenType* %tmp.this222, i32 32) - %193 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this222) + call void @ctor.393(%TokenType* %tmp.this222, i32 32) + %193 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this222) br i1 %193, label %if_then219, label %if_else220 if_then219: ; preds = %if_block218 @@ -20724,7 +20098,7 @@ if_then219: ; preds = %if_block218 store i8* getelementptr inbounds ([17 x i8], [17 x i8]* @str.75, i32 0, i32 0), i8** %196 store i8* getelementptr inbounds ([17 x i8], [17 x i8]* @str.75, i32 0, i32 16), i8** %197 %198 = load %StringRef, %StringRef* %tmp.StringRef223 - call void @ctor.459(%String* %_result, %StringRef %198) + call void @ctor.448(%String* %_result, %StringRef %198) ret void if_else220: ; preds = %if_block218 @@ -20737,8 +20111,8 @@ dumy_block224: ; No predecessors! br label %if_end221 if_block225: ; preds = %if_else220 - call void @ctor.404(%TokenType* %tmp.this229, i32 33) - %199 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this229) + call void @ctor.393(%TokenType* %tmp.this229, i32 33) + %199 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this229) br i1 %199, label %if_then226, label %if_else227 if_then226: ; preds = %if_block225 @@ -20749,7 +20123,7 @@ if_then226: ; preds = %if_block225 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.76, i32 0, i32 0), i8** %202 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.76, i32 0, i32 3), i8** %203 %204 = load %StringRef, %StringRef* %tmp.StringRef230 - call void @ctor.459(%String* %_result, %StringRef %204) + call void @ctor.448(%String* %_result, %StringRef %204) ret void if_else227: ; preds = %if_block225 @@ -20762,8 +20136,8 @@ dumy_block231: ; No predecessors! br label %if_end228 if_block232: ; preds = %if_else227 - call void @ctor.404(%TokenType* %tmp.this236, i32 34) - %205 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this236) + call void @ctor.393(%TokenType* %tmp.this236, i32 34) + %205 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this236) br i1 %205, label %if_then233, label %if_else234 if_then233: ; preds = %if_block232 @@ -20774,7 +20148,7 @@ if_then233: ; preds = %if_block232 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.77, i32 0, i32 0), i8** %208 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.77, i32 0, i32 3), i8** %209 %210 = load %StringRef, %StringRef* %tmp.StringRef237 - call void @ctor.459(%String* %_result, %StringRef %210) + call void @ctor.448(%String* %_result, %StringRef %210) ret void if_else234: ; preds = %if_block232 @@ -20787,8 +20161,8 @@ dumy_block238: ; No predecessors! br label %if_end235 if_block239: ; preds = %if_else234 - call void @ctor.404(%TokenType* %tmp.this243, i32 35) - %211 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this243) + call void @ctor.393(%TokenType* %tmp.this243, i32 35) + %211 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this243) br i1 %211, label %if_then240, label %if_else241 if_then240: ; preds = %if_block239 @@ -20799,7 +20173,7 @@ if_then240: ; preds = %if_block239 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.78, i32 0, i32 0), i8** %214 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.78, i32 0, i32 3), i8** %215 %216 = load %StringRef, %StringRef* %tmp.StringRef244 - call void @ctor.459(%String* %_result, %StringRef %216) + call void @ctor.448(%String* %_result, %StringRef %216) ret void if_else241: ; preds = %if_block239 @@ -20812,8 +20186,8 @@ dumy_block245: ; No predecessors! br label %if_end242 if_block246: ; preds = %if_else241 - call void @ctor.404(%TokenType* %tmp.this250, i32 36) - %217 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this250) + call void @ctor.393(%TokenType* %tmp.this250, i32 36) + %217 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this250) br i1 %217, label %if_then247, label %if_else248 if_then247: ; preds = %if_block246 @@ -20824,7 +20198,7 @@ if_then247: ; preds = %if_block246 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.79, i32 0, i32 0), i8** %220 store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @str.79, i32 0, i32 3), i8** %221 %222 = load %StringRef, %StringRef* %tmp.StringRef251 - call void @ctor.459(%String* %_result, %StringRef %222) + call void @ctor.448(%String* %_result, %StringRef %222) ret void if_else248: ; preds = %if_block246 @@ -20837,8 +20211,8 @@ dumy_block252: ; No predecessors! br label %if_end249 if_block253: ; preds = %if_else248 - call void @ctor.404(%TokenType* %tmp.this257, i32 37) - %223 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this257) + call void @ctor.393(%TokenType* %tmp.this257, i32 37) + %223 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this257) br i1 %223, label %if_then254, label %if_else255 if_then254: ; preds = %if_block253 @@ -20849,7 +20223,7 @@ if_then254: ; preds = %if_block253 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.80, i32 0, i32 0), i8** %226 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.80, i32 0, i32 10), i8** %227 %228 = load %StringRef, %StringRef* %tmp.StringRef258 - call void @ctor.459(%String* %_result, %StringRef %228) + call void @ctor.448(%String* %_result, %StringRef %228) ret void if_else255: ; preds = %if_block253 @@ -20862,8 +20236,8 @@ dumy_block259: ; No predecessors! br label %if_end256 if_block260: ; preds = %if_else255 - call void @ctor.404(%TokenType* %tmp.this264, i32 38) - %229 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this264) + call void @ctor.393(%TokenType* %tmp.this264, i32 38) + %229 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this264) br i1 %229, label %if_then261, label %if_else262 if_then261: ; preds = %if_block260 @@ -20874,7 +20248,7 @@ if_then261: ; preds = %if_block260 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.81, i32 0, i32 0), i8** %232 store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str.81, i32 0, i32 8), i8** %233 %234 = load %StringRef, %StringRef* %tmp.StringRef265 - call void @ctor.459(%String* %_result, %StringRef %234) + call void @ctor.448(%String* %_result, %StringRef %234) ret void if_else262: ; preds = %if_block260 @@ -20887,8 +20261,8 @@ dumy_block266: ; No predecessors! br label %if_end263 if_block267: ; preds = %if_else262 - call void @ctor.404(%TokenType* %tmp.this271, i32 39) - %235 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this271) + call void @ctor.393(%TokenType* %tmp.this271, i32 39) + %235 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this271) br i1 %235, label %if_then268, label %if_else269 if_then268: ; preds = %if_block267 @@ -20899,7 +20273,7 @@ if_then268: ; preds = %if_block267 store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @str.82, i32 0, i32 0), i8** %238 store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @str.82, i32 0, i32 12), i8** %239 %240 = load %StringRef, %StringRef* %tmp.StringRef272 - call void @ctor.459(%String* %_result, %StringRef %240) + call void @ctor.448(%String* %_result, %StringRef %240) ret void if_else269: ; preds = %if_block267 @@ -20912,8 +20286,8 @@ dumy_block273: ; No predecessors! br label %if_end270 if_block274: ; preds = %if_else269 - call void @ctor.404(%TokenType* %tmp.this278, i32 40) - %241 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this278) + call void @ctor.393(%TokenType* %tmp.this278, i32 40) + %241 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this278) br i1 %241, label %if_then275, label %if_else276 if_then275: ; preds = %if_block274 @@ -20924,7 +20298,7 @@ if_then275: ; preds = %if_block274 store i8* getelementptr inbounds ([15 x i8], [15 x i8]* @str.83, i32 0, i32 0), i8** %244 store i8* getelementptr inbounds ([15 x i8], [15 x i8]* @str.83, i32 0, i32 14), i8** %245 %246 = load %StringRef, %StringRef* %tmp.StringRef279 - call void @ctor.459(%String* %_result, %StringRef %246) + call void @ctor.448(%String* %_result, %StringRef %246) ret void if_else276: ; preds = %if_block274 @@ -20937,8 +20311,8 @@ dumy_block280: ; No predecessors! br label %if_end277 if_block281: ; preds = %if_else276 - call void @ctor.404(%TokenType* %tmp.this285, i32 41) - %247 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this285) + call void @ctor.393(%TokenType* %tmp.this285, i32 41) + %247 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this285) br i1 %247, label %if_then282, label %if_else283 if_then282: ; preds = %if_block281 @@ -20949,7 +20323,7 @@ if_then282: ; preds = %if_block281 store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @str.84, i32 0, i32 0), i8** %250 store i8* getelementptr inbounds ([12 x i8], [12 x i8]* @str.84, i32 0, i32 11), i8** %251 %252 = load %StringRef, %StringRef* %tmp.StringRef286 - call void @ctor.459(%String* %_result, %StringRef %252) + call void @ctor.448(%String* %_result, %StringRef %252) ret void if_else283: ; preds = %if_block281 @@ -20962,8 +20336,8 @@ dumy_block287: ; No predecessors! br label %if_end284 if_block288: ; preds = %if_else283 - call void @ctor.404(%TokenType* %tmp.this292, i32 42) - %253 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this292) + call void @ctor.393(%TokenType* %tmp.this292, i32 42) + %253 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this292) br i1 %253, label %if_then289, label %if_else290 if_then289: ; preds = %if_block288 @@ -20974,7 +20348,7 @@ if_then289: ; preds = %if_block288 store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @str.85, i32 0, i32 0), i8** %256 store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @str.85, i32 0, i32 12), i8** %257 %258 = load %StringRef, %StringRef* %tmp.StringRef293 - call void @ctor.459(%String* %_result, %StringRef %258) + call void @ctor.448(%String* %_result, %StringRef %258) ret void if_else290: ; preds = %if_block288 @@ -20987,8 +20361,8 @@ dumy_block294: ; No predecessors! br label %if_end291 if_block295: ; preds = %if_else290 - call void @ctor.404(%TokenType* %tmp.this299, i32 43) - %259 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this299) + call void @ctor.393(%TokenType* %tmp.this299, i32 43) + %259 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this299) br i1 %259, label %if_then296, label %if_else297 if_then296: ; preds = %if_block295 @@ -20999,7 +20373,7 @@ if_then296: ; preds = %if_block295 store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @str.86, i32 0, i32 0), i8** %262 store i8* getelementptr inbounds ([13 x i8], [13 x i8]* @str.86, i32 0, i32 12), i8** %263 %264 = load %StringRef, %StringRef* %tmp.StringRef300 - call void @ctor.459(%String* %_result, %StringRef %264) + call void @ctor.448(%String* %_result, %StringRef %264) ret void if_else297: ; preds = %if_block295 @@ -21012,8 +20386,8 @@ dumy_block301: ; No predecessors! br label %if_end298 if_block302: ; preds = %if_else297 - call void @ctor.404(%TokenType* %tmp.this306, i32 44) - %265 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this306) + call void @ctor.393(%TokenType* %tmp.this306, i32 44) + %265 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this306) br i1 %265, label %if_then303, label %if_else304 if_then303: ; preds = %if_block302 @@ -21024,7 +20398,7 @@ if_then303: ; preds = %if_block302 store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @str.87, i32 0, i32 0), i8** %268 store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @str.87, i32 0, i32 13), i8** %269 %270 = load %StringRef, %StringRef* %tmp.StringRef307 - call void @ctor.459(%String* %_result, %StringRef %270) + call void @ctor.448(%String* %_result, %StringRef %270) ret void if_else304: ; preds = %if_block302 @@ -21037,8 +20411,8 @@ dumy_block308: ; No predecessors! br label %if_end305 if_block309: ; preds = %if_else304 - call void @ctor.404(%TokenType* %tmp.this313, i32 45) - %271 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this313) + call void @ctor.393(%TokenType* %tmp.this313, i32 45) + %271 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this313) br i1 %271, label %if_then310, label %if_else311 if_then310: ; preds = %if_block309 @@ -21049,7 +20423,7 @@ if_then310: ; preds = %if_block309 store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @str.88, i32 0, i32 0), i8** %274 store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @str.88, i32 0, i32 13), i8** %275 %276 = load %StringRef, %StringRef* %tmp.StringRef314 - call void @ctor.459(%String* %_result, %StringRef %276) + call void @ctor.448(%String* %_result, %StringRef %276) ret void if_else311: ; preds = %if_block309 @@ -21062,8 +20436,8 @@ dumy_block315: ; No predecessors! br label %if_end312 if_block316: ; preds = %if_else311 - call void @ctor.404(%TokenType* %tmp.this320, i32 46) - %277 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this320) + call void @ctor.393(%TokenType* %tmp.this320, i32 46) + %277 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this320) br i1 %277, label %if_then317, label %if_else318 if_then317: ; preds = %if_block316 @@ -21074,7 +20448,7 @@ if_then317: ; preds = %if_block316 store i8* getelementptr inbounds ([15 x i8], [15 x i8]* @str.89, i32 0, i32 0), i8** %280 store i8* getelementptr inbounds ([15 x i8], [15 x i8]* @str.89, i32 0, i32 14), i8** %281 %282 = load %StringRef, %StringRef* %tmp.StringRef321 - call void @ctor.459(%String* %_result, %StringRef %282) + call void @ctor.448(%String* %_result, %StringRef %282) ret void if_else318: ; preds = %if_block316 @@ -21087,8 +20461,8 @@ dumy_block322: ; No predecessors! br label %if_end319 if_block323: ; preds = %if_else318 - call void @ctor.404(%TokenType* %tmp.this327, i32 253) - %283 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this327) + call void @ctor.393(%TokenType* %tmp.this327, i32 253) + %283 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this327) br i1 %283, label %if_then324, label %if_else325 if_then324: ; preds = %if_block323 @@ -21099,7 +20473,7 @@ if_then324: ; preds = %if_block323 store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @str.90, i32 0, i32 0), i8** %286 store i8* getelementptr inbounds ([14 x i8], [14 x i8]* @str.90, i32 0, i32 13), i8** %287 %288 = load %StringRef, %StringRef* %tmp.StringRef328 - call void @ctor.459(%String* %_result, %StringRef %288) + call void @ctor.448(%String* %_result, %StringRef %288) ret void if_else325: ; preds = %if_block323 @@ -21112,8 +20486,8 @@ dumy_block329: ; No predecessors! br label %if_end326 if_block330: ; preds = %if_else325 - call void @ctor.404(%TokenType* %tmp.this334, i32 254) - %289 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this334) + call void @ctor.393(%TokenType* %tmp.this334, i32 254) + %289 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this334) br i1 %289, label %if_then331, label %if_else332 if_then331: ; preds = %if_block330 @@ -21124,7 +20498,7 @@ if_then331: ; preds = %if_block330 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.91, i32 0, i32 0), i8** %292 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.91, i32 0, i32 7), i8** %293 %294 = load %StringRef, %StringRef* %tmp.StringRef335 - call void @ctor.459(%String* %_result, %StringRef %294) + call void @ctor.448(%String* %_result, %StringRef %294) ret void if_else332: ; preds = %if_block330 @@ -21137,8 +20511,8 @@ dumy_block336: ; No predecessors! br label %if_end333 if_block337: ; preds = %if_else332 - call void @ctor.404(%TokenType* %tmp.this340, i32 255) - %295 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this340) + call void @ctor.393(%TokenType* %tmp.this340, i32 255) + %295 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this340) br i1 %295, label %if_then338, label %if_end339 if_then338: ; preds = %if_block337 @@ -21149,7 +20523,7 @@ if_then338: ; preds = %if_block337 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.92, i32 0, i32 0), i8** %298 store i8* getelementptr inbounds ([11 x i8], [11 x i8]* @str.92, i32 0, i32 10), i8** %299 %300 = load %StringRef, %StringRef* %tmp.StringRef341 - call void @ctor.459(%String* %_result, %StringRef %300) + call void @ctor.448(%String* %_result, %StringRef %300) ret void if_end339: ; preds = %dumy_block342, %if_block337 @@ -21172,12 +20546,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %StringRef, %StringRef* %id.addr - %5 = call %Node @"().543"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) + %5 = call %Node @"().528"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().543"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3) #4 { +define internal %Node @"().528"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -21194,7 +20568,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.544"(%Node* %this, %Node* %other) #3 { +define internal void @"=.529"(%Node* %this, %Node* %other) #3 { %other.addr = alloca %Node* store %Node* %other, %Node** %other.addr br label %code @@ -21223,12 +20597,12 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %base.addr %5 = load %StringRef, %StringRef* %id.addr - %6 = call %Node @"().545"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) + %6 = call %Node @"().530"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) ret %Node %6 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().545"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %StringRef %p4) #4 { +define internal %Node @"().530"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %StringRef %p4) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %Node @@ -21257,7 +20631,7 @@ define internal %Location @span(%Location %start, %Location %end) #4 { br label %code code: ; preds = %0 - call void @ctor.169(%Location* %res, %Location* %start.addr) + call void @ctor.159(%Location* %res, %Location* %start.addr) %1 = load %Location, %Location* %end.addr call void @copyEnd(%Location* %res, %Location %1) %2 = load %Location, %Location* %res @@ -21273,7 +20647,7 @@ define internal void @copyEnd(%Location* %l, %Location %other) #4 { code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 %2 = getelementptr inbounds %Location, %Location* %other.addr, i32 0, i32 2 - call void @"=.274"(%LineCol* %1, %LineCol* %2) + call void @"=.263"(%LineCol* %1, %LineCol* %2) ret void } @@ -21304,17 +20678,17 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %base.addr %5 = load %StringRef, %StringRef* %id.addr - %6 = call %Node @"().545"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) + %6 = call %Node @"().530"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) ret %Node %6 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.546(%Node* %this) #3 { +define internal void @ctor.531(%Node* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %Node, %Node* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } @@ -21337,7 +20711,7 @@ while_body: ; preds = %while_block %1 = load i1, i1* %topLevel.addr %2 = call %Node @parseStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %1) store %Node %2, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %child, %Node* %"$tmpForRef") + call void @ctor.520(%Node* %child, %Node* %"$tmpForRef") br label %if_block while_step: ; preds = %dumy_block2, %if_then @@ -21348,7 +20722,7 @@ while_end: ; preds = %if_end, %while_bloc if_block: ; preds = %while_body %3 = load %Node, %Node* %child - %4 = call i1 @isSet.587(%Node %3) + %4 = call i1 @isSet.572(%Node %3) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block @@ -21357,7 +20731,7 @@ if_then: ; preds = %if_block %7 = load %Node, %Node* %child %8 = call %Node @addToNodeList(%AstBuilder* %5, %Node %6, %Node %7) store %Node %8, %Node* %"$tmpForRef1" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef1") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef1") br label %while_step if_end: ; preds = %dumy_block, %if_block @@ -21390,14 +20764,14 @@ define %Node @parseStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) call void @consumeSemis(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") %2 = call %Node @parseModifiers(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %2, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %mods, %Node* %"$tmpForRef1") + call void @ctor.520(%Node* %mods, %Node* %"$tmpForRef1") %3 = call i1 @parseImportLineOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %Node* %res) br i1 %3, label %cond.true38, label %cond.false39 @@ -21562,7 +20936,7 @@ cond.end40: ; preds = %cond.false39, %cond if_block: ; preds = %cond.end %22 = load %Node, %Node* %mods - %23 = call i1 @isSet.587(%Node %22) + %23 = call i1 @isSet.572(%Node %22) br i1 %23, label %if_then, label %if_end if_then: ; preds = %if_block @@ -21585,7 +20959,7 @@ if_then55: ; preds = %if_block54 %31 = load %Node, %Node* %mods %32 = call %Node @mkModifiers(%AstBuilder* %26, %Location %29, %Node %30, %Node %31) store %Node %32, %Node* %"$tmpForRef57" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef57") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef57") br label %if_end56 if_else: ; preds = %if_block54 @@ -21598,7 +20972,7 @@ if_else: ; preds = %if_block54 %37 = load %StringRef, %StringRef* %tmp.StringRef store %StringRef %37, %StringRef* %"$tmpForRef58" %38 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC59", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %38) + call void @"pre_*.518"(%Token* %"$tmpC59", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %38) %39 = getelementptr inbounds %Token, %Token* %"$tmpC59", i32 0, i32 1 %40 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef61, i32 0, i32 0 %41 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef61, i32 0, i32 1 @@ -21608,10 +20982,10 @@ if_else: ; preds = %if_block54 store i8* getelementptr inbounds ([22 x i8], [22 x i8]* @str.110, i32 0, i32 21), i8** %43 %44 = load %StringRef, %StringRef* %tmp.StringRef61 store %StringRef %44, %StringRef* %"$tmpForRef60" - call void @toString.589(%String* %"$tmpC", %StringRef* %"$tmpForRef58", %TokenType* %39, %StringRef* %"$tmpForRef60") - call void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC59") + call void @toString.574(%String* %"$tmpC", %StringRef* %"$tmpForRef58", %TokenType* %39, %StringRef* %"$tmpForRef60") + call void @reportError.523(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC59") br label %if_end56 if_end56: ; preds = %if_else, %if_then55 @@ -21627,7 +21001,7 @@ code: ; preds = %0 br label %while_block while_block: ; preds = %while_step, %code - call void @ctor.404(%TokenType* %tmp.this, i32 32) + call void @ctor.393(%TokenType* %tmp.this, i32 32) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %while_body, label %while_end @@ -21655,25 +21029,25 @@ define internal %Node @parseModifiers(%"SparrowParser[SparrowLayoutDecoder[Sparr br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 27) + call void @ctor.393(%TokenType* %tmp.this, i32 27) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block - call void @ctor.546(%Node* %e) + call void @ctor.531(%Node* %e) %2 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %2, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %e, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %e, %Node* %"$tmpForRef") %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %4 = load %Node, %Node* %res %5 = load %Node, %Node* %e %6 = call %Node @addToNodeList(%AstBuilder* %3, %Node %4, %Node %5) store %Node %6, %Node* %"$tmpForRef1" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef1") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef1") br label %while_block if_end: ; preds = %while_end, %if_block @@ -21681,27 +21055,27 @@ if_end: ; preds = %while_end, %if_bloc ret %Node %7 while_block: ; preds = %while_step, %if_then - call void @ctor.404(%TokenType* %tmp.this2, i32 33) + call void @ctor.393(%TokenType* %tmp.this2, i32 33) %8 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this2) br i1 %8, label %while_body, label %while_end while_body: ; preds = %while_block %9 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %9, %Node* %"$tmpForRef3" - call void @"=.544"(%Node* %e, %Node* %"$tmpForRef3") + call void @"=.529"(%Node* %e, %Node* %"$tmpForRef3") %10 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %11 = load %Node, %Node* %res %12 = load %Node, %Node* %e %13 = call %Node @addToNodeList(%AstBuilder* %10, %Node %11, %Node %12) store %Node %13, %Node* %"$tmpForRef4" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef4") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef4") br label %while_step while_step: ; preds = %while_body br label %while_block while_end: ; preds = %while_block - call void @ctor.404(%TokenType* %tmp.this5, i32 28) + call void @ctor.393(%TokenType* %tmp.this5, i32 28) %14 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) call void @consumeSemis(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) br label %if_end @@ -21726,12 +21100,12 @@ define internal %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowSca code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") %2 = load i1, i1* %withEqual.addr %3 = call %Node @parsePrefixExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %2) store %Node %3, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %baseExpr, %Node* %"$tmpForRef1") - call void @ctor.124(%String* %op) + call void @ctor.520(%Node* %baseExpr, %Node* %"$tmpForRef1") + call void @ctor.114(%String* %op) br label %while_block while_block: ; preds = %while_step, %code @@ -21740,8 +21114,8 @@ while_block: ; preds = %while_step, %code while_body: ; preds = %while_block %4 = load i1, i1* %withEqual.addr call void @parseIdOrOperOpt(%String* %"$tmpC", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %4) - %5 = call %String* @"=.278"(%String* %op, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") + %5 = call %String* @"=.267"(%String* %op, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") br label %if_block while_step: ; preds = %if_end4 @@ -21749,11 +21123,11 @@ while_step: ; preds = %if_end4 while_end: ; preds = %if_else, %if_then, %while_block %6 = load %Node, %Node* %baseExpr - call void @dtor.250(%String* %op) + call void @dtor.239(%String* %op) ret %Node %6 if_block: ; preds = %while_body - %7 = call i1 @isEmpty.384(%String* %op) + %7 = call i1 @isEmpty.373(%String* %op) br i1 %7, label %if_then, label %if_end if_then: ; preds = %if_block @@ -21774,7 +21148,7 @@ if_then3: ; preds = %if_block2 %10 = load i1, i1* %withEqual.addr %11 = call %Node @parsePrefixExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %10) store %Node %11, %Node* %"$tmpForRef5" - call void @ctor.535(%Node* %rhs, %Node* %"$tmpForRef5") + call void @ctor.520(%Node* %rhs, %Node* %"$tmpForRef5") %12 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %13 = load %Location, %Location* %loc %14 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) @@ -21784,7 +21158,7 @@ if_then3: ; preds = %if_block2 %18 = load %Node, %Node* %rhs %19 = call %Node @mkInfixOp(%AstBuilder* %12, %Location %15, %Node %16, %StringRef %17, %Node %18) store %Node %19, %Node* %"$tmpForRef6" - call void @"=.544"(%Node* %baseExpr, %Node* %"$tmpForRef6") + call void @"=.529"(%Node* %baseExpr, %Node* %"$tmpForRef6") br label %if_end4 if_else: ; preds = %if_block2 @@ -21796,7 +21170,7 @@ if_else: ; preds = %if_block2 %25 = call %StringRef @asStringRef(%String* %op) %26 = call %Node @mkPostfixOp(%AstBuilder* %20, %Location %23, %Node %24, %StringRef %25) store %Node %26, %Node* %"$tmpForRef7" - call void @"=.544"(%Node* %baseExpr, %Node* %"$tmpForRef7") + call void @"=.529"(%Node* %baseExpr, %Node* %"$tmpForRef7") br label %while_end if_end4: ; preds = %dumy_block8, %if_then3 @@ -21806,7 +21180,7 @@ dumy_block8: ; No predecessors! br label %if_end4 dumy_block9: ; No predecessors! - call void @dtor.250(%String* %op) + call void @dtor.239(%String* %op) unreachable } @@ -21828,45 +21202,45 @@ define internal %Node @parsePrefixExpr(%"SparrowParser[SparrowLayoutDecoder[Spar code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") - call void @ctor.124(%String* %op) + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.114(%String* %op) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 35) + call void @ctor.393(%TokenType* %tmp.this, i32 35) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %2, label %if_then, label %if_else if_then: ; preds = %if_block call void @parseId(%String* %"$tmpC", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - %3 = call %String* @"=.278"(%String* %op, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - call void @ctor.404(%TokenType* %tmp.this1, i32 35) + %3 = call %String* @"=.267"(%String* %op, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") + call void @ctor.393(%TokenType* %tmp.this1, i32 35) %4 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br label %if_end if_else: ; preds = %if_block call void @parseOperOpt(%String* %"$tmpC2", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) - %5 = call %String* @"=.278"(%String* %op, %String* %"$tmpC2") - call void @dtor.250(%String* %"$tmpC2") + %5 = call %String* @"=.267"(%String* %op, %String* %"$tmpC2") + call void @dtor.239(%String* %"$tmpC2") br label %if_end if_end: ; preds = %if_else, %if_then br label %if_block3 if_block3: ; preds = %if_end - %6 = call i1 @isEmpty.384(%String* %op) + %6 = call i1 @isEmpty.373(%String* %op) br i1 %6, label %if_then4, label %if_else5 if_then4: ; preds = %if_block3 %7 = call %Node @parseSimpleExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) - call void @dtor.250(%String* %op) + call void @dtor.239(%String* %op) ret %Node %7 if_else5: ; preds = %if_block3 %8 = call %Node @parsePrefixExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %8, %Node* %"$tmpForRef7" - call void @ctor.535(%Node* %baseExpr, %Node* %"$tmpForRef7") + call void @ctor.520(%Node* %baseExpr, %Node* %"$tmpForRef7") %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %10 = load %Location, %Location* %loc %11 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) @@ -21874,11 +21248,11 @@ if_else5: ; preds = %if_block3 %13 = call %StringRef @asStringRef(%String* %op) %14 = load %Node, %Node* %baseExpr %15 = call %Node @mkPrefixOp(%AstBuilder* %9, %Location %12, %StringRef %13, %Node %14) - call void @dtor.250(%String* %op) + call void @dtor.239(%String* %op) ret %Node %15 if_end6: ; preds = %dumy_block8, %dumy_block - call void @dtor.250(%String* %op) + call void @dtor.239(%String* %op) unreachable dumy_block: ; No predecessors! @@ -21894,11 +21268,11 @@ define internal void @parseId(%String* sret %_result, %"SparrowParser[SparrowLay br label %code code: ; preds = %0 - call void @ctor.404(%TokenType* %tmp.this, i32 37) + call void @ctor.393(%TokenType* %tmp.this, i32 37) %1 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 2 - call void @ctor.175(%String* %_result, %String* %3) + call void @ctor.165(%String* %_result, %String* %3) ret void } @@ -21914,14 +21288,14 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 38) + call void @ctor.393(%TokenType* %tmp.this, i32 38) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_else if_then: ; preds = %if_block %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 2 - call void @ctor.175(%String* %_result, %String* %3) + call void @ctor.165(%String* %_result, %String* %3) ret void if_else: ; preds = %if_block @@ -21940,18 +21314,18 @@ if_block1: ; preds = %if_else if_then2: ; preds = %cond.end %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %6 = getelementptr inbounds %Token, %Token* %5, i32 0, i32 2 - call void @ctor.175(%String* %_result, %String* %6) + call void @ctor.165(%String* %_result, %String* %6) br i1 %4, label %cond_destruct_alt1, label %cond_destruct_alt2 if_else3: ; preds = %cond.end - call void @ctor.124(%String* %_result) + call void @ctor.114(%String* %_result) br i1 %4, label %cond_destruct_alt17, label %cond_destruct_alt28 if_end4: ; preds = %dumy_block10, %dumy_block6 br i1 %4, label %cond_destruct_alt111, label %cond_destruct_alt212 cond.true: ; preds = %if_block1 - call void @ctor.404(%TokenType* %tmp.this5, i32 36) + call void @ctor.393(%TokenType* %tmp.this5, i32 36) %7 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br label %cond.end @@ -22037,46 +21411,45 @@ define %Node @parseSimpleExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanne %tmp.this75 = alloca double %tmp.this80 = alloca %TokenType %"$tmpForRef81" = alloca %Node - %tmp.this82 = alloca i64 - %tmp.this86 = alloca %TokenType - %"$tmpForRef87" = alloca %Node + %tmp.this85 = alloca %TokenType + %"$tmpForRef86" = alloca %Node %"$tmpC" = alloca %String - %"$tmpForRef91" = alloca %StringRef + %"$tmpForRef90" = alloca %StringRef %tmp.StringRef = alloca %StringRef - %"$tmpC92" = alloca %Token - %"$tmpForRef93" = alloca %StringRef - %tmp.StringRef94 = alloca %StringRef - %tmp.this95 = alloca %Node - %tmp.this100 = alloca %TokenType + %"$tmpC91" = alloca %Token + %"$tmpForRef92" = alloca %StringRef + %tmp.StringRef93 = alloca %StringRef + %tmp.this94 = alloca %Node + %tmp.this99 = alloca %TokenType %args = alloca %Node - %"$tmpForRef101" = alloca %Node - %tmp.this102 = alloca %TokenType - %"$tmpForRef103" = alloca %Node - %tmp.this108 = alloca %TokenType + %"$tmpForRef100" = alloca %Node + %tmp.this101 = alloca %TokenType + %"$tmpForRef102" = alloca %Node + %tmp.this107 = alloca %TokenType + %tmp.this112 = alloca %TokenType %tmp.this113 = alloca %TokenType - %tmp.this114 = alloca %TokenType - %"$tmpForRef115" = alloca %Node - %tmp.StringRef116 = alloca %StringRef + %"$tmpForRef114" = alloca %Node + %tmp.StringRef115 = alloca %StringRef %id = alloca %String - %"$tmpForRef117" = alloca %Node + %"$tmpForRef116" = alloca %Node br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 29) + call void @ctor.393(%TokenType* %tmp.this, i32 29) %2 = call i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %2, label %cond.true, label %cond.false if_then: ; preds = %cond.end %3 = call %Node @parseLambdaExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %3, %Node* %"$tmpForRef2" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef2") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef2") br label %if_end if_else: ; preds = %cond.end @@ -22086,7 +21459,7 @@ if_end: ; preds = %if_end6, %if_then br i1 %2, label %cond_destruct_alt1, label %cond_destruct_alt2 cond.true: ; preds = %if_block - call void @ctor.404(%TokenType* %tmp.this1, i32 6) + call void @ctor.393(%TokenType* %tmp.this1, i32 6) %4 = call i1 @next2Is(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br label %cond.end @@ -22098,7 +21471,7 @@ cond.end: ; preds = %cond.false, %cond.t br i1 %cond.res, label %if_then, label %if_else if_block3: ; preds = %if_else - call void @ctor.404(%TokenType* %tmp.this7, i32 29) + call void @ctor.393(%TokenType* %tmp.this7, i32 29) %5 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this7) br i1 %5, label %if_then4, label %if_else5 @@ -22107,8 +21480,8 @@ if_then4: ; preds = %if_block3 %7 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) %8 = call %Node @mkParenthesisExpr(%AstBuilder* %6, %Node %7) store %Node %8, %Node* %"$tmpForRef8" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef8") - call void @ctor.404(%TokenType* %tmp.this9, i32 30) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef8") + call void @ctor.393(%TokenType* %tmp.this9, i32 30) %9 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this9) br label %if_end6 @@ -22119,7 +21492,7 @@ if_end6: ; preds = %if_end13, %if_then4 br label %if_end if_block10: ; preds = %if_else5 - call void @ctor.404(%TokenType* %tmp.this14, i32 37) + call void @ctor.393(%TokenType* %tmp.this14, i32 37) %10 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this14) br i1 %10, label %if_then11, label %if_else12 @@ -22133,7 +21506,7 @@ if_then11: ; preds = %if_block10 %17 = call %StringRef @asStringRef(%String* %16) %18 = call %Node @mkIdentifier(%AstBuilder* %11, %Location %14, %StringRef %17) store %Node %18, %Node* %"$tmpForRef15" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef15") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef15") br label %if_end13 if_else12: ; preds = %if_block10 @@ -22143,7 +21516,7 @@ if_end13: ; preds = %if_end19, %if_then1 br label %if_end6 if_block16: ; preds = %if_else12 - call void @ctor.404(%TokenType* %tmp.this20, i32 22) + call void @ctor.393(%TokenType* %tmp.this20, i32 22) %19 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this20) br i1 %19, label %if_then17, label %if_else18 @@ -22154,7 +21527,7 @@ if_then17: ; preds = %if_block16 %23 = load %Location, %Location* %22 %24 = call %Node @mkNullLiteral(%AstBuilder* %20, %Location %23) store %Node %24, %Node* %"$tmpForRef21" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef21") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef21") br label %if_end19 if_else18: ; preds = %if_block16 @@ -22164,7 +21537,7 @@ if_end19: ; preds = %if_end25, %if_then1 br label %if_end13 if_block22: ; preds = %if_else18 - call void @ctor.404(%TokenType* %tmp.this26, i32 23) + call void @ctor.393(%TokenType* %tmp.this26, i32 23) %25 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this26) br i1 %25, label %if_then23, label %if_else24 @@ -22175,7 +21548,7 @@ if_then23: ; preds = %if_block22 %29 = load %Location, %Location* %28 %30 = call %Node @mkBoolLiteral(%AstBuilder* %26, %Location %29, i1 true) store %Node %30, %Node* %"$tmpForRef27" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef27") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef27") br label %if_end25 if_else24: ; preds = %if_block22 @@ -22185,7 +21558,7 @@ if_end25: ; preds = %if_end31, %if_then2 br label %if_end19 if_block28: ; preds = %if_else24 - call void @ctor.404(%TokenType* %tmp.this32, i32 21) + call void @ctor.393(%TokenType* %tmp.this32, i32 21) %31 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this32) br i1 %31, label %if_then29, label %if_else30 @@ -22196,7 +21569,7 @@ if_then29: ; preds = %if_block28 %35 = load %Location, %Location* %34 %36 = call %Node @mkBoolLiteral(%AstBuilder* %32, %Location %35, i1 false) store %Node %36, %Node* %"$tmpForRef33" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef33") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef33") br label %if_end31 if_else30: ; preds = %if_block28 @@ -22206,7 +21579,7 @@ if_end31: ; preds = %if_end37, %if_then2 br label %if_end25 if_block34: ; preds = %if_else30 - call void @ctor.404(%TokenType* %tmp.this38, i32 41) + call void @ctor.393(%TokenType* %tmp.this38, i32 41) %37 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this38) br i1 %37, label %if_then35, label %if_else36 @@ -22223,7 +21596,7 @@ if_then35: ; preds = %if_block34 %46 = load i32, i32* %tmp.this40 %47 = call %Node @mkIntLiteral(%AstBuilder* %38, %Location %41, i32 %46) store %Node %47, %Node* %"$tmpForRef39" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef39") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef39") br label %if_end37 if_else36: ; preds = %if_block34 @@ -22233,7 +21606,7 @@ if_end37: ; preds = %if_end44, %if_then3 br label %if_end31 if_block41: ; preds = %if_else36 - call void @ctor.404(%TokenType* %tmp.this45, i32 43) + call void @ctor.393(%TokenType* %tmp.this45, i32 43) %48 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this45) br i1 %48, label %if_then42, label %if_else43 @@ -22250,7 +21623,7 @@ if_then42: ; preds = %if_block41 %57 = load i32, i32* %tmp.this47 %58 = call %Node @mkUIntLiteral(%AstBuilder* %49, %Location %52, i32 %57) store %Node %58, %Node* %"$tmpForRef46" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef46") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef46") br label %if_end44 if_else43: ; preds = %if_block41 @@ -22260,7 +21633,7 @@ if_end44: ; preds = %if_end51, %if_then4 br label %if_end37 if_block48: ; preds = %if_else43 - call void @ctor.404(%TokenType* %tmp.this52, i32 42) + call void @ctor.393(%TokenType* %tmp.this52, i32 42) %59 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this52) br i1 %59, label %if_then49, label %if_else50 @@ -22276,7 +21649,7 @@ if_then49: ; preds = %if_block48 %67 = load i64, i64* %tmp.this54 %68 = call %Node @mkLongLiteral(%AstBuilder* %60, %Location %63, i64 %67) store %Node %68, %Node* %"$tmpForRef53" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef53") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef53") br label %if_end51 if_else50: ; preds = %if_block48 @@ -22286,7 +21659,7 @@ if_end51: ; preds = %if_end58, %if_then4 br label %if_end44 if_block55: ; preds = %if_else50 - call void @ctor.404(%TokenType* %tmp.this59, i32 44) + call void @ctor.393(%TokenType* %tmp.this59, i32 44) %69 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this59) br i1 %69, label %if_then56, label %if_else57 @@ -22302,7 +21675,7 @@ if_then56: ; preds = %if_block55 %77 = load i64, i64* %tmp.this61 %78 = call %Node @mkULongLiteral(%AstBuilder* %70, %Location %73, i64 %77) store %Node %78, %Node* %"$tmpForRef60" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef60") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef60") br label %if_end58 if_else57: ; preds = %if_block55 @@ -22312,7 +21685,7 @@ if_end58: ; preds = %if_end65, %if_then5 br label %if_end51 if_block62: ; preds = %if_else57 - call void @ctor.404(%TokenType* %tmp.this66, i32 45) + call void @ctor.393(%TokenType* %tmp.this66, i32 45) %79 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this66) br i1 %79, label %if_then63, label %if_else64 @@ -22329,7 +21702,7 @@ if_then63: ; preds = %if_block62 %88 = load float, float* %tmp.this68 %89 = call %Node @mkFloatLiteral(%AstBuilder* %80, %Location %83, float %88) store %Node %89, %Node* %"$tmpForRef67" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef67") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef67") br label %if_end65 if_else64: ; preds = %if_block62 @@ -22339,7 +21712,7 @@ if_end65: ; preds = %if_end72, %if_then6 br label %if_end58 if_block69: ; preds = %if_else64 - call void @ctor.404(%TokenType* %tmp.this73, i32 46) + call void @ctor.393(%TokenType* %tmp.this73, i32 46) %90 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this73) br i1 %90, label %if_then70, label %if_else71 @@ -22355,7 +21728,7 @@ if_then70: ; preds = %if_block69 %98 = load double, double* %tmp.this75 %99 = call %Node @mkDoubleLiteral(%AstBuilder* %91, %Location %94, double %98) store %Node %99, %Node* %"$tmpForRef74" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef74") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef74") br label %if_end72 if_else71: ; preds = %if_block69 @@ -22365,7 +21738,7 @@ if_end72: ; preds = %if_end79, %if_then7 br label %if_end65 if_block76: ; preds = %if_else71 - call void @ctor.404(%TokenType* %tmp.this80, i32 39) + call void @ctor.393(%TokenType* %tmp.this80, i32 39) %100 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this80) br i1 %100, label %if_then77, label %if_else78 @@ -22376,40 +21749,38 @@ if_then77: ; preds = %if_block76 %104 = load %Location, %Location* %103 %105 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %106 = getelementptr inbounds %Token, %Token* %105, i32 0, i32 2 - store i64 0, i64* %tmp.this82 - %107 = load i64, i64* %tmp.this82 - %108 = call i8* @"().332"(%String* %106, i64 %107) - %109 = load i8, i8* %108 - %110 = call %Node @mkCharLiteral(%AstBuilder* %101, %Location %104, i8 %109) - store %Node %110, %Node* %"$tmpForRef81" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef81") + %107 = call i8* @"().321"(%String* %106, i32 0) + %108 = load i8, i8* %107 + %109 = call %Node @mkCharLiteral(%AstBuilder* %101, %Location %104, i8 %108) + store %Node %109, %Node* %"$tmpForRef81" + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef81") br label %if_end79 if_else78: ; preds = %if_block76 - br label %if_block83 + br label %if_block82 -if_end79: ; preds = %if_end85, %if_then77 +if_end79: ; preds = %if_end84, %if_then77 br label %if_end72 -if_block83: ; preds = %if_else78 - call void @ctor.404(%TokenType* %tmp.this86, i32 40) - %111 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this86) - br i1 %111, label %if_then84, label %if_end85 - -if_then84: ; preds = %if_block83 - %112 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 - %113 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %114 = getelementptr inbounds %Token, %Token* %113, i32 0, i32 0 - %115 = load %Location, %Location* %114 - %116 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %117 = getelementptr inbounds %Token, %Token* %116, i32 0, i32 2 - %118 = call %StringRef @asStringRef(%String* %117) - %119 = call %Node @mkStringLiteral(%AstBuilder* %112, %Location %115, %StringRef %118) - store %Node %119, %Node* %"$tmpForRef87" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef87") - br label %if_end85 - -if_end85: ; preds = %if_then84, %if_block83 +if_block82: ; preds = %if_else78 + call void @ctor.393(%TokenType* %tmp.this85, i32 40) + %110 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this85) + br i1 %110, label %if_then83, label %if_end84 + +if_then83: ; preds = %if_block82 + %111 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 + %112 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %113 = getelementptr inbounds %Token, %Token* %112, i32 0, i32 0 + %114 = load %Location, %Location* %113 + %115 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %116 = getelementptr inbounds %Token, %Token* %115, i32 0, i32 2 + %117 = call %StringRef @asStringRef(%String* %116) + %118 = call %Node @mkStringLiteral(%AstBuilder* %111, %Location %114, %StringRef %117) + store %Node %118, %Node* %"$tmpForRef86" + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef86") + br label %if_end84 + +if_end84: ; preds = %if_then83, %if_block82 br label %if_end79 cond_destruct_alt1: ; preds = %if_end @@ -22419,147 +21790,147 @@ cond_destruct_alt2: ; preds = %if_end br label %cond_destruct_end cond_destruct_end: ; preds = %cond_destruct_alt2, %cond_destruct_alt1 - br label %if_block88 + br label %if_block87 -if_block88: ; preds = %cond_destruct_end - %120 = load %Node, %Node* %res - %121 = call i1 @isNull(%Node %120) - br i1 %121, label %if_then89, label %if_end90 +if_block87: ; preds = %cond_destruct_end + %119 = load %Node, %Node* %res + %120 = call i1 @isNull(%Node %119) + br i1 %120, label %if_then88, label %if_end89 -if_then89: ; preds = %if_block88 - %122 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 - %123 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 +if_then88: ; preds = %if_block87 + %121 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 0 + %122 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef, i32 0, i32 1 + %123 = bitcast %UntypedPtr* %121 to i8** %124 = bitcast %UntypedPtr* %122 to i8** - %125 = bitcast %UntypedPtr* %123 to i8** - store i8* getelementptr inbounds ([26 x i8], [26 x i8]* @str.98, i32 0, i32 0), i8** %124 - store i8* getelementptr inbounds ([26 x i8], [26 x i8]* @str.98, i32 0, i32 25), i8** %125 - %126 = load %StringRef, %StringRef* %tmp.StringRef - store %StringRef %126, %StringRef* %"$tmpForRef91" - %127 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC92", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %127) - %128 = getelementptr inbounds %Token, %Token* %"$tmpC92", i32 0, i32 1 - %129 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef94, i32 0, i32 0 - %130 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef94, i32 0, i32 1 + store i8* getelementptr inbounds ([26 x i8], [26 x i8]* @str.98, i32 0, i32 0), i8** %123 + store i8* getelementptr inbounds ([26 x i8], [26 x i8]* @str.98, i32 0, i32 25), i8** %124 + %125 = load %StringRef, %StringRef* %tmp.StringRef + store %StringRef %125, %StringRef* %"$tmpForRef90" + %126 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 + call void @"pre_*.518"(%Token* %"$tmpC91", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %126) + %127 = getelementptr inbounds %Token, %Token* %"$tmpC91", i32 0, i32 1 + %128 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef93, i32 0, i32 0 + %129 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef93, i32 0, i32 1 + %130 = bitcast %UntypedPtr* %128 to i8** %131 = bitcast %UntypedPtr* %129 to i8** - %132 = bitcast %UntypedPtr* %130 to i8** - store i8* getelementptr inbounds ([23 x i8], [23 x i8]* @str.99, i32 0, i32 0), i8** %131 - store i8* getelementptr inbounds ([23 x i8], [23 x i8]* @str.99, i32 0, i32 22), i8** %132 - %133 = load %StringRef, %StringRef* %tmp.StringRef94 - store %StringRef %133, %StringRef* %"$tmpForRef93" - call void @toString.589(%String* %"$tmpC", %StringRef* %"$tmpForRef91", %TokenType* %128, %StringRef* %"$tmpForRef93") - call void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC92") - call void @ctor.546(%Node* %tmp.this95) - %134 = load %Node, %Node* %tmp.this95 - ret %Node %134 - -if_end90: ; preds = %dumy_block, %if_block88 + store i8* getelementptr inbounds ([23 x i8], [23 x i8]* @str.99, i32 0, i32 0), i8** %130 + store i8* getelementptr inbounds ([23 x i8], [23 x i8]* @str.99, i32 0, i32 22), i8** %131 + %132 = load %StringRef, %StringRef* %tmp.StringRef93 + store %StringRef %132, %StringRef* %"$tmpForRef92" + call void @toString.574(%String* %"$tmpC", %StringRef* %"$tmpForRef90", %TokenType* %127, %StringRef* %"$tmpForRef92") + call void @reportError.523(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC91") + call void @ctor.531(%Node* %tmp.this94) + %133 = load %Node, %Node* %tmp.this94 + ret %Node %133 + +if_end89: ; preds = %dumy_block, %if_block87 br label %while_block dumy_block: ; No predecessors! - br label %if_end90 + br label %if_end89 -while_block: ; preds = %while_step, %if_end90 +while_block: ; preds = %while_step, %if_end89 br i1 true, label %while_body, label %while_end while_body: ; preds = %while_block - br label %if_block96 - -while_step: ; preds = %if_end99 - br label %while_block + br label %if_block95 -while_end: ; preds = %if_else106, %while_block - %135 = load %Node, %Node* %res - ret %Node %135 - -if_block96: ; preds = %while_body - call void @ctor.404(%TokenType* %tmp.this100, i32 29) - %136 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this100) - br i1 %136, label %if_then97, label %if_else98 - -if_then97: ; preds = %if_block96 - %137 = call %Node @parseExprListOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - store %Node %137, %Node* %"$tmpForRef101" - call void @ctor.535(%Node* %args, %Node* %"$tmpForRef101") - call void @ctor.404(%TokenType* %tmp.this102, i32 30) - %138 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this102) - %139 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 - %140 = load %Location, %Location* %loc - %141 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - %142 = call %Location @span(%Location %140, %Location %141) - %143 = load %Node, %Node* %res - %144 = load %Node, %Node* %args - %145 = call %Node @mkFunAppExpr(%AstBuilder* %139, %Location %142, %Node %143, %Node %144) - store %Node %145, %Node* %"$tmpForRef103" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef103") - br label %if_end99 +while_step: ; preds = %if_end98 + br label %while_block -if_else98: ; preds = %if_block96 - br label %if_block104 +while_end: ; preds = %if_else105, %while_block + %134 = load %Node, %Node* %res + ret %Node %134 -if_end99: ; preds = %if_end107, %if_then97 +if_block95: ; preds = %while_body + call void @ctor.393(%TokenType* %tmp.this99, i32 29) + %135 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this99) + br i1 %135, label %if_then96, label %if_else97 + +if_then96: ; preds = %if_block95 + %136 = call %Node @parseExprListOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) + store %Node %136, %Node* %"$tmpForRef100" + call void @ctor.520(%Node* %args, %Node* %"$tmpForRef100") + call void @ctor.393(%TokenType* %tmp.this101, i32 30) + %137 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this101) + %138 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 + %139 = load %Location, %Location* %loc + %140 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) + %141 = call %Location @span(%Location %139, %Location %140) + %142 = load %Node, %Node* %res + %143 = load %Node, %Node* %args + %144 = call %Node @mkFunAppExpr(%AstBuilder* %138, %Location %141, %Node %142, %Node %143) + store %Node %144, %Node* %"$tmpForRef102" + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef102") + br label %if_end98 + +if_else97: ; preds = %if_block95 + br label %if_block103 + +if_end98: ; preds = %if_end106, %if_then96 br label %while_step -if_block104: ; preds = %if_else98 - call void @ctor.404(%TokenType* %tmp.this108, i32 34) - %146 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this108) - br i1 %146, label %if_then105, label %if_else106 +if_block103: ; preds = %if_else97 + call void @ctor.393(%TokenType* %tmp.this107, i32 34) + %145 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this107) + br i1 %145, label %if_then104, label %if_else105 -if_then105: ; preds = %if_block104 - br label %if_block109 +if_then104: ; preds = %if_block103 + br label %if_block108 -if_else106: ; preds = %if_block104 +if_else105: ; preds = %if_block103 br label %while_end -if_end107: ; preds = %dumy_block118, %if_end112 - br label %if_end99 +if_end106: ; preds = %dumy_block117, %if_end111 + br label %if_end98 + +if_block108: ; preds = %if_then104 + call void @ctor.393(%TokenType* %tmp.this112, i32 29) + %146 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this112) + br i1 %146, label %if_then109, label %if_else110 + +if_then109: ; preds = %if_block108 + call void @ctor.393(%TokenType* %tmp.this113, i32 30) + %147 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this113) + %148 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 + %149 = load %Location, %Location* %loc + %150 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) + %151 = call %Location @span(%Location %149, %Location %150) + %152 = load %Node, %Node* %res + %153 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef115, i32 0, i32 0 + %154 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef115, i32 0, i32 1 + %155 = bitcast %UntypedPtr* %153 to i8** + %156 = bitcast %UntypedPtr* %154 to i8** + store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str.100, i32 0, i32 0), i8** %155 + store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str.100, i32 0, i32 2), i8** %156 + %157 = load %StringRef, %StringRef* %tmp.StringRef115 + %158 = call %Node @mkDotExpr(%AstBuilder* %148, %Location %151, %Node %152, %StringRef %157) + store %Node %158, %Node* %"$tmpForRef114" + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef114") + br label %if_end111 -if_block109: ; preds = %if_then105 - call void @ctor.404(%TokenType* %tmp.this113, i32 29) - %147 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this113) - br i1 %147, label %if_then110, label %if_else111 +if_else110: ; preds = %if_block108 + %159 = load i1, i1* %withEqual.addr + call void @parseIdOrOper(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %159) + %160 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 + %161 = load %Location, %Location* %loc + %162 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) + %163 = call %Location @span(%Location %161, %Location %162) + %164 = load %Node, %Node* %res + %165 = call %StringRef @asStringRef(%String* %id) + %166 = call %Node @mkDotExpr(%AstBuilder* %160, %Location %163, %Node %164, %StringRef %165) + store %Node %166, %Node* %"$tmpForRef116" + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef116") + call void @dtor.239(%String* %id) + br label %if_end111 -if_then110: ; preds = %if_block109 - call void @ctor.404(%TokenType* %tmp.this114, i32 30) - %148 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this114) - %149 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 - %150 = load %Location, %Location* %loc - %151 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - %152 = call %Location @span(%Location %150, %Location %151) - %153 = load %Node, %Node* %res - %154 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef116, i32 0, i32 0 - %155 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef116, i32 0, i32 1 - %156 = bitcast %UntypedPtr* %154 to i8** - %157 = bitcast %UntypedPtr* %155 to i8** - store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str.100, i32 0, i32 0), i8** %156 - store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str.100, i32 0, i32 2), i8** %157 - %158 = load %StringRef, %StringRef* %tmp.StringRef116 - %159 = call %Node @mkDotExpr(%AstBuilder* %149, %Location %152, %Node %153, %StringRef %158) - store %Node %159, %Node* %"$tmpForRef115" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef115") - br label %if_end112 - -if_else111: ; preds = %if_block109 - %160 = load i1, i1* %withEqual.addr - call void @parseIdOrOper(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %160) - %161 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 - %162 = load %Location, %Location* %loc - %163 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - %164 = call %Location @span(%Location %162, %Location %163) - %165 = load %Node, %Node* %res - %166 = call %StringRef @asStringRef(%String* %id) - %167 = call %Node @mkDotExpr(%AstBuilder* %161, %Location %164, %Node %165, %StringRef %166) - store %Node %167, %Node* %"$tmpForRef117" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef117") - call void @dtor.250(%String* %id) - br label %if_end112 - -if_end112: ; preds = %if_else111, %if_then110 - br label %if_end107 +if_end111: ; preds = %if_else110, %if_then109 + br label %if_end106 -dumy_block118: ; No predecessors! - br label %if_end107 +dumy_block117: ; No predecessors! + br label %if_end106 } ; Function Attrs: inlinehint nounwind @@ -22569,46 +21940,40 @@ define internal i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]] code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) + call void @"pre_*.518"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) %2 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 - %3 = call i1 @"==.339"(%TokenType* %2, %TokenType* %t) - call void @dtor.249(%Token* %"$tmpC") + %3 = call i1 @"==.328"(%TokenType* %2, %TokenType* %t) + call void @dtor.238(%Token* %"$tmpC") ret i1 %3 dumy_block: ; No predecessors! - call void @dtor.249(%Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") unreachable } ; Function Attrs: inlinehint nounwind define internal i1 @next2Is(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %t) #4 { %"$tmpC" = alloca %Token - %tmp.this = alloca i32 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - store i32 1, i32* %tmp.this - %2 = load i32, i32* %tmp.this - call void @peek.547(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1, i32 %2) - %3 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 - %4 = call i1 @"==.339"(%TokenType* %3, %TokenType* %t) - call void @dtor.249(%Token* %"$tmpC") - ret i1 %4 + call void @peek.532(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1, i32 1) + %2 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 + %3 = call i1 @"==.328"(%TokenType* %2, %TokenType* %t) + call void @dtor.238(%Token* %"$tmpC") + ret i1 %3 dumy_block: ; No predecessors! - call void @dtor.249(%Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") unreachable } ; Function Attrs: inlinehint nounwind -define internal void @peek.547(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 %n) #4 { +define internal void @peek.532(%Token* sret %_result, %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 %n) #4 { %n.addr = alloca i32 store i32 %n, i32* %n.addr - %tmp.this = alloca i64 %"$tmpC" = alloca %Token - %tmp.this1 = alloca i64 - %tmp.this2 = alloca i64 br label %code code: ; preds = %0 @@ -22616,20 +21981,17 @@ code: ; preds = %0 while_block: ; preds = %while_step, %code %1 = load i32, i32* %n.addr - %2 = zext i32 %1 to i64 - store i64 %2, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %5 = call i64 @size.195(%"Vector[Token]"* %4) - %6 = icmp sge i64 %3, %5 - br i1 %6, label %cond.true, label %cond.false + %2 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %3 = call i32 @size.184(%"Vector[Token]"* %2) + %4 = call i1 @_Int32_opGE(i32 %1, i32 %3) + br i1 %4, label %cond.true, label %cond.false while_body: ; preds = %cond.end - %7 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %8 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"post_++.511"(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %8) - call void @"+=.396"(%"Vector[Token]"* %7, %Token* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC") + %5 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %6 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 + call void @"post_++.496"(%Token* %"$tmpC", %"SparrowLayoutDecoder[SparrowScanner]"* %6) + call void @"+=.385"(%"Vector[Token]"* %5, %Token* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC") br label %while_step while_step: ; preds = %while_body @@ -22639,64 +22001,58 @@ while_end: ; preds = %cond.end br label %if_block cond.true: ; preds = %while_block - %9 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - %10 = call i1 @"pre_!!.509"(%"SparrowLayoutDecoder[SparrowScanner]"* %9) + %7 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 + %8 = call i1 @"pre_!!.494"(%"SparrowLayoutDecoder[SparrowScanner]"* %7) br label %cond.end cond.false: ; preds = %while_block br label %cond.end cond.end: ; preds = %cond.false, %cond.true - %cond.res = phi i1 [ %10, %cond.true ], [ false, %cond.false ] + %cond.res = phi i1 [ %8, %cond.true ], [ false, %cond.false ] br i1 %cond.res, label %while_body, label %while_end if_block: ; preds = %while_end - %11 = load i32, i32* %n.addr - %12 = zext i32 %11 to i64 - store i64 %12, i64* %tmp.this1 - %13 = load i64, i64* %tmp.this1 - %14 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %15 = call i64 @size.195(%"Vector[Token]"* %14) - %16 = icmp slt i64 %13, %15 - br i1 %16, label %if_then, label %if_else + %9 = load i32, i32* %n.addr + %10 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %11 = call i32 @size.184(%"Vector[Token]"* %10) + %12 = call i1 @_Int32_opLT(i32 %9, i32 %11) + br i1 %12, label %if_then, label %if_else if_then: ; preds = %if_block - %17 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 - %18 = load i32, i32* %n.addr - %19 = zext i32 %18 to i64 - store i64 %19, i64* %tmp.this2 - %20 = load i64, i64* %tmp.this2 - %21 = call %Token* @"().548"(%"Vector[Token]"* %17, i64 %20) - call void @ctor.188(%Token* %_result, %Token* %21) + %13 = getelementptr inbounds %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 + %14 = load i32, i32* %n.addr + %15 = call %Token* @"().533"(%"Vector[Token]"* %13, i32 %14) + call void @ctor.177(%Token* %_result, %Token* %15) ret void if_else: ; preds = %if_block - call void @ctor.130(%Token* %_result) + call void @ctor.120(%Token* %_result) ret void -if_end: ; preds = %dumy_block3, %dumy_block +if_end: ; preds = %dumy_block1, %dumy_block ret void dumy_block: ; No predecessors! br label %if_end -dumy_block3: ; No predecessors! +dumy_block1: ; No predecessors! br label %if_end } ; Function Attrs: inlinehint nounwind -define internal %Token* @"().548"(%"Vector[Token]"* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal %Token* @"().533"(%"Vector[Token]"* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %"$tmpForRef" = alloca %"RawPtr[Token]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - %3 = call %"RawPtr[Token]" @advance.201(%"RawPtr[Token]"* %1, i64 %2) + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Token]" @advance.190(%"RawPtr[Token]"* %1, i32 %2) store %"RawPtr[Token]" %3, %"RawPtr[Token]"* %"$tmpForRef" - %4 = call %Token* @value.206(%"RawPtr[Token]"* %"$tmpForRef") + %4 = call %Token* @value.195(%"RawPtr[Token]"* %"$tmpForRef") ret %Token* %4 } @@ -22723,43 +22079,43 @@ define internal %Node @parseLambdaExpr(%"SparrowParser[SparrowLayoutDecoder[Spar code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this, i32 29) + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this, i32 29) %2 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) - call void @ctor.404(%TokenType* %tmp.this1, i32 6) + call void @ctor.393(%TokenType* %tmp.this1, i32 6) %3 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) %4 = call %Node @parseClosureParams(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %4, %Node* %"$tmpForRef2" - call void @ctor.535(%Node* %closureParams, %Node* %"$tmpForRef2") + call void @ctor.520(%Node* %closureParams, %Node* %"$tmpForRef2") %5 = call %Node @parseFormalsOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %5, %Node* %"$tmpForRef3" - call void @ctor.535(%Node* %formals, %Node* %"$tmpForRef3") + call void @ctor.520(%Node* %formals, %Node* %"$tmpForRef3") %6 = call %Node @parseTypeNode(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %6, %Node* %"$tmpForRef4" - call void @ctor.535(%Node* %retType, %Node* %"$tmpForRef4") - call void @ctor.546(%Node* %body) - call void @ctor.546(%Node* %bodyExp) + call void @ctor.520(%Node* %retType, %Node* %"$tmpForRef4") + call void @ctor.531(%Node* %body) + call void @ctor.531(%Node* %bodyExp) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this5, i32 36) + call void @ctor.393(%TokenType* %tmp.this5, i32 36) %7 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %7, label %if_then, label %if_else if_then: ; preds = %if_block %8 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %8, %Node* %"$tmpForRef6" - call void @"=.544"(%Node* %bodyExp, %Node* %"$tmpForRef6") + call void @"=.529"(%Node* %bodyExp, %Node* %"$tmpForRef6") br label %if_end if_else: ; preds = %if_block %9 = call %Node @parseFunBody(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %9, %Node* %"$tmpForRef7" - call void @"=.544"(%Node* %body, %Node* %"$tmpForRef7") + call void @"=.529"(%Node* %body, %Node* %"$tmpForRef7") br label %if_end if_end: ; preds = %if_else, %if_then - call void @ctor.404(%TokenType* %tmp.this8, i32 30) + call void @ctor.393(%TokenType* %tmp.this8, i32 30) %10 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this8) %11 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %12 = load %Location, %Location* %loc @@ -22785,16 +22141,16 @@ define internal %Node @parseClosureParams(%"SparrowParser[SparrowLayoutDecoder[S br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 34) + call void @ctor.393(%TokenType* %tmp.this, i32 34) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block - call void @ctor.404(%TokenType* %tmp.this1, i32 25) + call void @ctor.393(%TokenType* %tmp.this1, i32 25) %2 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br label %if_block2 @@ -22803,18 +22159,18 @@ if_end: ; preds = %if_end4, %if_block ret %Node %3 if_block2: ; preds = %if_then - call void @ctor.404(%TokenType* %tmp.this5, i32 37) + call void @ctor.393(%TokenType* %tmp.this5, i32 37) %4 = call i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %4, label %if_then3, label %if_end4 if_then3: ; preds = %if_block2 %5 = call %Node @parseIdListNode(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %5, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") br label %if_end4 if_end4: ; preds = %if_then3, %if_block2 - call void @ctor.404(%TokenType* %tmp.this6, i32 26) + call void @ctor.393(%TokenType* %tmp.this6, i32 26) %6 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this6) br label %if_end } @@ -22830,7 +22186,7 @@ define internal %Node @parseIdListNode(%"SparrowParser[SparrowLayoutDecoder[Spar br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) call void @parseId(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %2 = load %Node, %Node* %res @@ -22842,18 +22198,18 @@ code: ; preds = %0 %8 = call %Node @mkIdentifier(%AstBuilder* %3, %Location %6, %StringRef %7) %9 = call %Node @addToNodeList(%AstBuilder* %1, %Node %2, %Node %8) store %Node %9, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") br label %while_block while_block: ; preds = %while_step, %code - call void @ctor.404(%TokenType* %tmp.this, i32 33) + call void @ctor.393(%TokenType* %tmp.this, i32 33) %10 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %10, label %while_body, label %while_end while_body: ; preds = %while_block call void @parseId(%String* %"$tmpC", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - %11 = call %String* @"=.278"(%String* %id, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") + %11 = call %String* @"=.267"(%String* %id, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") %12 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %13 = load %Node, %Node* %res %14 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 @@ -22864,7 +22220,7 @@ while_body: ; preds = %while_block %19 = call %Node @mkIdentifier(%AstBuilder* %14, %Location %17, %StringRef %18) %20 = call %Node @addToNodeList(%AstBuilder* %12, %Node %13, %Node %19) store %Node %20, %Node* %"$tmpForRef1" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef1") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef1") br label %while_step while_step: ; preds = %while_body @@ -22872,11 +22228,11 @@ while_step: ; preds = %while_body while_end: ; preds = %while_block %21 = load %Node, %Node* %res - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) ret %Node %21 dumy_block: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) unreachable } @@ -22894,12 +22250,12 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %nl.addr %5 = load %Node, %Node* %newNode.addr - %6 = call %Node @"().549"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %1, %UntypedPtr %3, %Node %4, %Node %5) + %6 = call %Node @"().534"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %1, %UntypedPtr %3, %Node %4, %Node %5) ret %Node %6 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().549"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %UntypedPtr %p1, %Node %p2, %Node %p3) #4 { +define internal %Node @"().534"(%"FunctionPtr3[Node, UntypedPtr, Node, Node]"* %this, %UntypedPtr %p1, %Node %p2, %Node %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p2.addr = alloca %Node @@ -22934,11 +22290,11 @@ define internal %Node @parseFormalsOpt(%"SparrowParser[SparrowLayoutDecoder[Spar br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 29) + call void @ctor.393(%TokenType* %tmp.this, i32 29) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_else @@ -22953,7 +22309,7 @@ if_end: ; preds = %if_end9, %while_end ret %Node %2 if_block1: ; preds = %if_then - call void @ctor.404(%TokenType* %tmp.this4, i32 30) + call void @ctor.393(%TokenType* %tmp.this4, i32 30) %3 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this4) br i1 %3, label %if_then2, label %if_end3 @@ -22969,7 +22325,7 @@ dumy_block: ; No predecessors! br label %if_end3 while_block: ; preds = %while_step, %if_end3 - call void @ctor.404(%TokenType* %tmp.this5, i32 33) + call void @ctor.393(%TokenType* %tmp.this5, i32 33) %5 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %5, label %while_body, label %while_end @@ -22981,19 +22337,19 @@ while_step: ; preds = %while_body br label %while_block while_end: ; preds = %while_block - call void @ctor.404(%TokenType* %tmp.this6, i32 30) + call void @ctor.393(%TokenType* %tmp.this6, i32 30) %6 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this6) br label %if_end if_block7: ; preds = %if_else - call void @ctor.404(%TokenType* %tmp.this10, i32 37) + call void @ctor.393(%TokenType* %tmp.this10, i32 37) %7 = call i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this10) br i1 %7, label %if_then8, label %if_end9 if_then8: ; preds = %if_block7 %8 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %8, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") call void @parseIdList(%"Vector[LocString]"* %ids, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %10 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 @@ -23008,10 +22364,10 @@ if_then8: ; preds = %if_block7 store i8* getelementptr inbounds ([8 x i8], [8 x i8]* @str.95, i32 0, i32 7), i8** %17 %18 = load %StringRef, %StringRef* %tmp.StringRef %19 = call %Node @mkIdentifier(%AstBuilder* %10, %Location %13, %StringRef %18) - call void @ctor.546(%Node* %tmp.this11) + call void @ctor.531(%Node* %tmp.this11) %20 = load %Node, %Node* %tmp.this11 call void @createFormals(%AstBuilder* %9, %"Vector[LocString]"* %ids, %Node %19, %Node %20, i32 2, %Node* %res) - call void @dtor.577(%"Vector[LocString]"* %ids) + call void @dtor.562(%"Vector[LocString]"* %ids) br label %if_end9 if_end9: ; preds = %if_then8, %if_block7 @@ -23031,23 +22387,23 @@ define internal void @parseFormal(%"SparrowParser[SparrowLayoutDecoder[SparrowSc code: ; preds = %0 call void @parseIdList(%"Vector[LocString]"* %ids, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - call void @ctor.404(%TokenType* %tmp.this, i32 31) + call void @ctor.393(%TokenType* %tmp.this, i32 31) %1 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 false) store %Node %2, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %typeNode, %Node* %"$tmpForRef") - call void @ctor.546(%Node* %init) + call void @ctor.520(%Node* %typeNode, %Node* %"$tmpForRef") + call void @ctor.531(%Node* %init) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this1, i32 36) + call void @ctor.393(%TokenType* %tmp.this1, i32 36) %3 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block %4 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %4, %Node* %"$tmpForRef2" - call void @"=.544"(%Node* %init, %Node* %"$tmpForRef2") + call void @"=.529"(%Node* %init, %Node* %"$tmpForRef2") br label %if_end if_end: ; preds = %if_then, %if_block @@ -23055,7 +22411,7 @@ if_end: ; preds = %if_then, %if_block %6 = load %Node, %Node* %typeNode %7 = load %Node, %Node* %init call void @createFormals(%AstBuilder* %5, %"Vector[LocString]"* %ids, %Node %6, %Node %7, i32 2, %Node* %res) - call void @dtor.577(%"Vector[LocString]"* %ids) + call void @dtor.562(%"Vector[LocString]"* %ids) ret void } @@ -23072,66 +22428,66 @@ define internal void @parseIdList(%"Vector[LocString]"* sret %_result, %"Sparrow br label %code code: ; preds = %0 - call void @ctor.550(%"Vector[LocString]"* %res) + call void @ctor.535(%"Vector[LocString]"* %res) call void @parseId(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %Token, %Token* %1, i32 0, i32 0 call void @"~"(%"Tuple[Location, String]"* %"$tmpC", %Location* %2, %String* %id) - call void @ctor.569(%LocString* %tmp.this, %"Tuple[Location, String]"* %"$tmpC") - call void @"+=.552"(%"Vector[LocString]"* %res, %LocString* %tmp.this) - call void @dtor.571(%LocString* %tmp.this) - call void @dtor.572(%"Tuple[Location, String]"* %"$tmpC") + call void @ctor.554(%LocString* %tmp.this, %"Tuple[Location, String]"* %"$tmpC") + call void @"+=.537"(%"Vector[LocString]"* %res, %LocString* %tmp.this) + call void @dtor.556(%LocString* %tmp.this) + call void @dtor.557(%"Tuple[Location, String]"* %"$tmpC") br label %while_block while_block: ; preds = %while_step, %code - call void @ctor.404(%TokenType* %tmp.this1, i32 33) + call void @ctor.393(%TokenType* %tmp.this1, i32 33) %3 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br i1 %3, label %while_body, label %while_end while_body: ; preds = %while_block call void @parseId(%String* %"$tmpC2", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - %4 = call %String* @"=.278"(%String* %id, %String* %"$tmpC2") - call void @dtor.250(%String* %"$tmpC2") + %4 = call %String* @"=.267"(%String* %id, %String* %"$tmpC2") + call void @dtor.239(%String* %"$tmpC2") %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %6 = getelementptr inbounds %Token, %Token* %5, i32 0, i32 0 call void @"~"(%"Tuple[Location, String]"* %"$tmpC4", %Location* %6, %String* %id) - call void @ctor.569(%LocString* %tmp.this3, %"Tuple[Location, String]"* %"$tmpC4") - call void @"+=.552"(%"Vector[LocString]"* %res, %LocString* %tmp.this3) - call void @dtor.571(%LocString* %tmp.this3) - call void @dtor.572(%"Tuple[Location, String]"* %"$tmpC4") + call void @ctor.554(%LocString* %tmp.this3, %"Tuple[Location, String]"* %"$tmpC4") + call void @"+=.537"(%"Vector[LocString]"* %res, %LocString* %tmp.this3) + call void @dtor.556(%LocString* %tmp.this3) + call void @dtor.557(%"Tuple[Location, String]"* %"$tmpC4") br label %while_step while_step: ; preds = %while_body br label %while_block while_end: ; preds = %while_block - call void @ctor.573(%"Vector[LocString]"* %_result, %"Vector[LocString]"* %res) - call void @dtor.250(%String* %id) - call void @dtor.577(%"Vector[LocString]"* %res) + call void @ctor.558(%"Vector[LocString]"* %_result, %"Vector[LocString]"* %res) + call void @dtor.239(%String* %id) + call void @dtor.562(%"Vector[LocString]"* %res) ret void dumy_block: ; No predecessors! - call void @dtor.250(%String* %id) - call void @dtor.577(%"Vector[LocString]"* %res) + call void @dtor.239(%String* %id) + call void @dtor.562(%"Vector[LocString]"* %res) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.550(%"Vector[LocString]"* %this) #3 { +define internal void @ctor.535(%"Vector[LocString]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - call void @ctor.551(%"RawPtr[LocString]"* %1) + call void @ctor.536(%"RawPtr[LocString]"* %1) %2 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - call void @ctor.551(%"RawPtr[LocString]"* %2) + call void @ctor.536(%"RawPtr[LocString]"* %2) %3 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 - call void @ctor.551(%"RawPtr[LocString]"* %3) + call void @ctor.536(%"RawPtr[LocString]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.551(%"RawPtr[LocString]"* %this) #3 { +define internal void @ctor.536(%"RawPtr[LocString]"* %this) #3 { br label %code code: ; preds = %0 @@ -23141,20 +22497,17 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @"+=.552"(%"Vector[LocString]"* %this, %LocString* %value) #4 { +define internal void @"+=.537"(%"Vector[LocString]"* %this, %LocString* %value) #4 { br label %code code: ; preds = %0 - call void @pushBack.553(%"Vector[LocString]"* %this, %LocString* %value) + call void @pushBack.538(%"Vector[LocString]"* %this, %LocString* %value) ret void } ; Function Attrs: inlinehint nounwind -define internal void @pushBack.553(%"Vector[LocString]"* %this, %LocString* %value) #4 { - %t = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this5 = alloca i64 +define internal void @pushBack.538(%"Vector[LocString]"* %this, %LocString* %value) #4 { + %t = alloca i32 %"$tmpForRef" = alloca %"RawPtr[LocString]" br label %code @@ -23164,49 +22517,43 @@ code: ; preds = %0 if_block: ; preds = %code %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 - %3 = call i1 @"==.554"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %2) + %3 = call i1 @"==.539"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %2) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block - store i64 2, i64* %tmp.this - %4 = load i64, i64* %tmp.this - %5 = call i64 @capacity.555(%"Vector[LocString]"* %this) - %6 = mul i64 %4, %5 - store i64 %6, i64* %t + %4 = call i32 @capacity.540(%"Vector[LocString]"* %this) + %5 = call i32 @_Int32_opMul(i32 2, i32 %4) + store i32 %5, i32* %t br label %if_block1 if_end: ; preds = %if_end3, %if_block - %7 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - %8 = call %LocString* @value.567(%"RawPtr[LocString]"* %7) - call void @ctor.565(%LocString* %8, %LocString* %value) + %6 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 + %7 = call %LocString* @value.552(%"RawPtr[LocString]"* %6) + call void @ctor.550(%LocString* %7, %LocString* %value) + %8 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 %9 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - %10 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - %11 = call %"RawPtr[LocString]" @advance.568(%"RawPtr[LocString]"* %10) - store %"RawPtr[LocString]" %11, %"RawPtr[LocString]"* %"$tmpForRef" - call void @"=.562"(%"RawPtr[LocString]"* %9, %"RawPtr[LocString]"* %"$tmpForRef") + %10 = call %"RawPtr[LocString]" @advance.553(%"RawPtr[LocString]"* %9) + store %"RawPtr[LocString]" %10, %"RawPtr[LocString]"* %"$tmpForRef" + call void @"=.547"(%"RawPtr[LocString]"* %8, %"RawPtr[LocString]"* %"$tmpForRef") ret void if_block1: ; preds = %if_then - %12 = load i64, i64* %t - store i64 2, i64* %tmp.this4 - %13 = load i64, i64* %tmp.this4 - %14 = icmp slt i64 %12, %13 - br i1 %14, label %if_then2, label %if_end3 + %11 = load i32, i32* %t + %12 = call i1 @_Int32_opLT(i32 %11, i32 2) + br i1 %12, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 2, i64* %tmp.this5 - %15 = load i64, i64* %tmp.this5 - store i64 %15, i64* %t + store i32 2, i32* %t br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - %16 = load i64, i64* %t - call void @reserve.558(%"Vector[LocString]"* %this, i64 %16) + %13 = load i32, i32* %t + call void @reserve.543(%"Vector[LocString]"* %this, i32 %13) br label %if_end } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.554"(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]"* %other) #3 { +define internal i1 @"==.539"(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]"* %other) #3 { %this.addr = alloca %"RawPtr[LocString]"* store %"RawPtr[LocString]"* %this, %"RawPtr[LocString]"** %this.addr %other.addr = alloca %"RawPtr[LocString]"* @@ -23227,47 +22574,41 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i64 @capacity.555(%"Vector[LocString]"* %this) #4 { - %tmp.this = alloca i64 +define internal i32 @capacity.540(%"Vector[LocString]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 %2 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 %3 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %2 - %4 = call i64 @diff.556(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff.541(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal i64 @diff.556(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]" %other) #4 { +define internal i32 @diff.541(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]" %other) #4 { %other.addr = alloca %"RawPtr[LocString]" store %"RawPtr[LocString]" %other, %"RawPtr[LocString]"* %other.addr %tmp.this = alloca %UntypedPtr %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 %2 = load %LocString*, %LocString** %1 - call void @ctor.557(%UntypedPtr* %tmp.this, %LocString* %2) + call void @ctor.542(%UntypedPtr* %tmp.this, %LocString* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this %4 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %other.addr, i32 0, i32 0 %5 = load %LocString*, %LocString** %4 - call void @ctor.557(%UntypedPtr* %tmp.this1, %LocString* %5) + call void @ctor.542(%UntypedPtr* %tmp.this1, %LocString* %5) %6 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %7 = call i64 bitcast (i64 (i8*, i8*)* @ptrDiff to i64 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) - store i64 48, i64* %tmp.this2 - %8 = load i64, i64* %tmp.this2 - %9 = sdiv i64 %7, %8 - ret i64 %9 + %7 = call i32 bitcast (i32 (i8*, i8*)* @ptrDiff to i32 (%UntypedPtr, %UntypedPtr)*)(%UntypedPtr %3, %UntypedPtr %6) + %8 = call i32 @_Int32_opDiv(i32 %7, i32 48) + ret i32 %8 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.557(%UntypedPtr* %this, %LocString* %val) #4 { +define internal void @ctor.542(%UntypedPtr* %this, %LocString* %val) #4 { %val.addr = alloca %LocString* store %LocString* %val, %LocString** %val.addr br label %code @@ -23283,30 +22624,28 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @reserve.558(%"Vector[LocString]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %curCapacity = alloca i64 - %tmp.this = alloca i64 - %tmp.this4 = alloca i64 - %tmp.this8 = alloca double +define internal void @reserve.543(%"Vector[LocString]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %curCapacity = alloca i32 + %tmp.this = alloca i32 + %tmp.this7 = alloca double + %tmp.this8 = alloca i32 %tmp.this9 = alloca double - %tmp.this10 = alloca i64 - %tmp.this11 = alloca double - %curSize = alloca i64 + %curSize = alloca i32 %"$tmpForRef" = alloca %"RawPtr[LocString]" - %"$tmpForRef12" = alloca %"RawPtr[LocString]" + %"$tmpForRef10" = alloca %"RawPtr[LocString]" br label %code code: ; preds = %0 - %1 = call i64 @capacity.555(%"Vector[LocString]"* %this) - store i64 %1, i64* %curCapacity + %1 = call i32 @capacity.540(%"Vector[LocString]"* %this) + store i32 %1, i32* %curCapacity br label %if_block if_block: ; preds = %code - %2 = load i64, i64* %n.addr - %3 = load i64, i64* %curCapacity - %4 = icmp sle i64 %2, %3 + %2 = load i32, i32* %n.addr + %3 = load i32, i32* %curCapacity + %4 = call i1 @_Int32_opLE(i32 %2, i32 %3) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block @@ -23319,105 +22658,98 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - %5 = load i64, i64* %n.addr - store i64 8, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = icmp slt i64 %5, %6 - br i1 %7, label %if_then2, label %if_end3 + %5 = load i32, i32* %n.addr + %6 = call i1 @_Int32_opLT(i32 %5, i32 8) + br i1 %6, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - store i64 8, i64* %tmp.this4 - %8 = load i64, i64* %tmp.this4 - store i64 %8, i64* %n.addr + store i32 8, i32* %n.addr br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - br label %if_block5 + br label %if_block4 -if_block5: ; preds = %if_end3 - %9 = load i64, i64* %n.addr - %10 = sitofp i64 %9 to double - store double %10, double* %tmp.this8 - %11 = load double, double* %tmp.this8 - %12 = load i64, i64* %curCapacity - %13 = sitofp i64 %12 to double - store double %13, double* %tmp.this9 - %14 = load double, double* %tmp.this9 - %15 = call double @_Double_opMul(double 2.000000e+00, double %14) - %16 = call i1 @_Double_opLT(double %11, double %15) - br i1 %16, label %if_then6, label %if_end7 +if_block4: ; preds = %if_end3 + %7 = load i32, i32* %n.addr + %8 = load i32, i32* %curCapacity + %9 = sitofp i32 %8 to double + store double %9, double* %tmp.this7 + %10 = load double, double* %tmp.this7 + %11 = call double @_Float64_opMul(double 2.000000e+00, double %10) + %12 = fptosi double %11 to i32 + store i32 %12, i32* %tmp.this + %13 = load i32, i32* %tmp.this + %14 = call i1 @_Int32_opLT(i32 %7, i32 %13) + br i1 %14, label %if_then5, label %if_end6 -if_then6: ; preds = %if_block5 - %17 = load i64, i64* %curCapacity - %18 = sitofp i64 %17 to double - store double %18, double* %tmp.this11 - %19 = load double, double* %tmp.this11 - %20 = call double @_Double_opMul(double 2.000000e+00, double %19) - %21 = fptoui double %20 to i64 - store i64 %21, i64* %tmp.this10 - %22 = load i64, i64* %tmp.this10 - store i64 %22, i64* %n.addr - br label %if_end7 +if_then5: ; preds = %if_block4 + %15 = load i32, i32* %curCapacity + %16 = sitofp i32 %15 to double + store double %16, double* %tmp.this9 + %17 = load double, double* %tmp.this9 + %18 = call double @_Float64_opMul(double 2.000000e+00, double %17) + %19 = fptosi double %18 to i32 + store i32 %19, i32* %tmp.this8 + %20 = load i32, i32* %tmp.this8 + store i32 %20, i32* %n.addr + br label %if_end6 -if_end7: ; preds = %if_then6, %if_block5 - %23 = call i64 @size.559(%"Vector[LocString]"* %this) - store i64 %23, i64* %curSize - %24 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - %25 = load i64, i64* %n.addr - call void @reallocPtr.560(%"RawPtr[LocString]"* %24, i64 %25) - %26 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - %27 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - %28 = load i64, i64* %curSize - %29 = call %"RawPtr[LocString]" @advance.563(%"RawPtr[LocString]"* %27, i64 %28) - store %"RawPtr[LocString]" %29, %"RawPtr[LocString]"* %"$tmpForRef" - call void @"=.562"(%"RawPtr[LocString]"* %26, %"RawPtr[LocString]"* %"$tmpForRef") - %30 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 - %31 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - %32 = load i64, i64* %n.addr - %33 = call %"RawPtr[LocString]" @advance.563(%"RawPtr[LocString]"* %31, i64 %32) - store %"RawPtr[LocString]" %33, %"RawPtr[LocString]"* %"$tmpForRef12" - call void @"=.562"(%"RawPtr[LocString]"* %30, %"RawPtr[LocString]"* %"$tmpForRef12") - ret void -} - -; Function Attrs: inlinehint nounwind -define internal i64 @size.559(%"Vector[LocString]"* %this) #4 { - %tmp.this = alloca i64 +if_end6: ; preds = %if_then5, %if_block4 + %21 = call i32 @size.544(%"Vector[LocString]"* %this) + store i32 %21, i32* %curSize + %22 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 + %23 = load i32, i32* %n.addr + call void @reallocPtr.545(%"RawPtr[LocString]"* %22, i32 %23) + %24 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 + %25 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 + %26 = load i32, i32* %curSize + %27 = call %"RawPtr[LocString]" @advance.548(%"RawPtr[LocString]"* %25, i32 %26) + store %"RawPtr[LocString]" %27, %"RawPtr[LocString]"* %"$tmpForRef" + call void @"=.547"(%"RawPtr[LocString]"* %24, %"RawPtr[LocString]"* %"$tmpForRef") + %28 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 + %29 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 + %30 = load i32, i32* %n.addr + %31 = call %"RawPtr[LocString]" @advance.548(%"RawPtr[LocString]"* %29, i32 %30) + store %"RawPtr[LocString]" %31, %"RawPtr[LocString]"* %"$tmpForRef10" + call void @"=.547"(%"RawPtr[LocString]"* %28, %"RawPtr[LocString]"* %"$tmpForRef10") + ret void +} + +; Function Attrs: inlinehint nounwind +define internal i32 @size.544(%"Vector[LocString]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 %3 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %2 - %4 = call i64 @diff.556(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]" %3) - store i64 %4, i64* %tmp.this - %5 = load i64, i64* %tmp.this - ret i64 %5 + %4 = call i32 @diff.541(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]" %3) + ret i32 %4 } ; Function Attrs: inlinehint nounwind -define internal void @reallocPtr.560(%"RawPtr[LocString]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal void @reallocPtr.545(%"RawPtr[LocString]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 %2 = load %LocString*, %LocString** %1 - call void @ctor.557(%UntypedPtr* %tmp.this, %LocString* %2) + call void @ctor.542(%UntypedPtr* %tmp.this, %LocString* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 48 - %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i64 %5) - %7 = call %LocString* @asRefOf.561(%UntypedPtr %6) + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 48) + %6 = call %UntypedPtr @realloc(%UntypedPtr %3, i32 %5) + %7 = call %LocString* @asRefOf.546(%UntypedPtr %6) %8 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 store %LocString* %7, %LocString** %8 ret void } ; Function Attrs: inlinehint nounwind -define internal %LocString* @asRefOf.561(%UntypedPtr %this) #4 { +define internal %LocString* @asRefOf.546(%UntypedPtr %this) #4 { %this.addr = alloca %UntypedPtr store %UntypedPtr %this, %UntypedPtr* %this.addr br label %code @@ -23430,7 +22762,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.562"(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]"* %other) #3 { +define internal void @"=.547"(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]"* %other) #3 { %other.addr = alloca %"RawPtr[LocString]"* store %"RawPtr[LocString]"* %other, %"RawPtr[LocString]"** %other.addr br label %code @@ -23445,9 +22777,9 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[LocString]" @advance.563(%"RawPtr[LocString]"* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr +define internal %"RawPtr[LocString]" @advance.548(%"RawPtr[LocString]"* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr %tmp.this = alloca %"RawPtr[LocString]" %tmp.this1 = alloca %UntypedPtr br label %code @@ -23455,18 +22787,18 @@ define internal %"RawPtr[LocString]" @advance.563(%"RawPtr[LocString]"* %this, i code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 %2 = load %LocString*, %LocString** %1 - call void @ctor.557(%UntypedPtr* %tmp.this1, %LocString* %2) + call void @ctor.542(%UntypedPtr* %tmp.this1, %LocString* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = load i64, i64* %n.addr - %5 = mul i64 %4, 48 - %6 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 %5) - call void @ctor.564(%"RawPtr[LocString]"* %tmp.this, %UntypedPtr %6) + %4 = load i32, i32* %n.addr + %5 = call i32 @_Int32_opMul(i32 %4, i32 48) + %6 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 %5) + call void @ctor.549(%"RawPtr[LocString]"* %tmp.this, %UntypedPtr %6) %7 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %tmp.this ret %"RawPtr[LocString]" %7 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.564(%"RawPtr[LocString]"* %this, %UntypedPtr %p) #4 { +define internal void @ctor.549(%"RawPtr[LocString]"* %this, %UntypedPtr %p) #4 { %p.addr = alloca %UntypedPtr store %UntypedPtr %p, %UntypedPtr* %p.addr br label %code @@ -23475,14 +22807,14 @@ code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 store %LocString* null, %LocString** %1 %2 = load %UntypedPtr, %UntypedPtr* %p.addr - %3 = call %LocString* @asRefOf.561(%UntypedPtr %2) + %3 = call %LocString* @asRefOf.546(%UntypedPtr %2) %4 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 store %LocString* %3, %LocString** %4 ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.565(%LocString* %this, %LocString* %other) #3 { +define internal void @ctor.550(%LocString* %this, %LocString* %other) #3 { %other.addr = alloca %LocString* store %LocString* %other, %LocString** %other.addr br label %code @@ -23491,12 +22823,12 @@ code: ; preds = %0 %1 = getelementptr inbounds %LocString, %LocString* %this, i32 0, i32 0 %2 = load %LocString*, %LocString** %other.addr %3 = getelementptr inbounds %LocString, %LocString* %2, i32 0, i32 0 - call void @ctor.566(%"Tuple[Location, String]"* %1, %"Tuple[Location, String]"* %3) + call void @ctor.551(%"Tuple[Location, String]"* %1, %"Tuple[Location, String]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.566(%"Tuple[Location, String]"* %this, %"Tuple[Location, String]"* %other) #3 { +define internal void @ctor.551(%"Tuple[Location, String]"* %this, %"Tuple[Location, String]"* %other) #3 { %other.addr = alloca %"Tuple[Location, String]"* store %"Tuple[Location, String]"* %other, %"Tuple[Location, String]"** %other.addr br label %code @@ -23505,16 +22837,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %this, i32 0, i32 0 %2 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %other.addr %3 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %2, i32 0, i32 0 - call void @ctor.169(%Location* %1, %Location* %3) + call void @ctor.159(%Location* %1, %Location* %3) %4 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %this, i32 0, i32 1 %5 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %other.addr %6 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %5, i32 0, i32 1 - call void @ctor.175(%String* %4, %String* %6) + call void @ctor.165(%String* %4, %String* %6) ret void } ; Function Attrs: inlinehint nounwind -define internal %LocString* @value.567(%"RawPtr[LocString]"* %this) #4 { +define internal %LocString* @value.552(%"RawPtr[LocString]"* %this) #4 { br label %code code: ; preds = %0 @@ -23524,7 +22856,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[LocString]" @advance.568(%"RawPtr[LocString]"* %this) #4 { +define internal %"RawPtr[LocString]" @advance.553(%"RawPtr[LocString]"* %this) #4 { %tmp.this = alloca %"RawPtr[LocString]" %tmp.this1 = alloca %UntypedPtr br label %code @@ -23532,16 +22864,16 @@ define internal %"RawPtr[LocString]" @advance.568(%"RawPtr[LocString]"* %this) # code: ; preds = %0 %1 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 %2 = load %LocString*, %LocString** %1 - call void @ctor.557(%UntypedPtr* %tmp.this1, %LocString* %2) + call void @ctor.542(%UntypedPtr* %tmp.this1, %LocString* %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %4 = call %UntypedPtr bitcast (i8* (i8*, i64)* @ptrAdd to %UntypedPtr (%UntypedPtr, i64)*)(%UntypedPtr %3, i64 48) - call void @ctor.564(%"RawPtr[LocString]"* %tmp.this, %UntypedPtr %4) + %4 = call %UntypedPtr bitcast (i8* (i8*, i32)* @ptrAdd to %UntypedPtr (%UntypedPtr, i32)*)(%UntypedPtr %3, i32 48) + call void @ctor.549(%"RawPtr[LocString]"* %tmp.this, %UntypedPtr %4) %5 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %tmp.this ret %"RawPtr[LocString]" %5 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.569(%LocString* %this, %"Tuple[Location, String]"* %fdata) #3 { +define internal void @ctor.554(%LocString* %this, %"Tuple[Location, String]"* %fdata) #3 { %this.addr = alloca %LocString* store %LocString* %this, %LocString** %this.addr br label %code @@ -23549,7 +22881,7 @@ define internal void @ctor.569(%LocString* %this, %"Tuple[Location, String]"* %f code: ; preds = %0 %1 = load %LocString*, %LocString** %this.addr %2 = getelementptr inbounds %LocString, %LocString* %1, i32 0, i32 0 - call void @ctor.566(%"Tuple[Location, String]"* %2, %"Tuple[Location, String]"* %fdata) + call void @ctor.551(%"Tuple[Location, String]"* %2, %"Tuple[Location, String]"* %fdata) ret void } @@ -23568,12 +22900,12 @@ define internal void @mkTuple(%"Tuple[Location, String]"* sret %_result, %Locati code: ; preds = %0 %1 = load %Location, %Location* %v1 - call void @ctor.570(%"Tuple[Location, String]"* %_result, %Location %1, %String* %v2) + call void @ctor.555(%"Tuple[Location, String]"* %_result, %Location %1, %String* %v2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.570(%"Tuple[Location, String]"* %this, %Location %fv1, %String* %fv2) #3 { +define internal void @ctor.555(%"Tuple[Location, String]"* %this, %Location %fv1, %String* %fv2) #3 { %this.addr = alloca %"Tuple[Location, String]"* store %"Tuple[Location, String]"* %this, %"Tuple[Location, String]"** %this.addr %fv1.addr = alloca %Location @@ -23583,36 +22915,36 @@ define internal void @ctor.570(%"Tuple[Location, String]"* %this, %Location %fv1 code: ; preds = %0 %1 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %this.addr %2 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %1, i32 0, i32 0 - call void @ctor.169(%Location* %2, %Location* %fv1.addr) + call void @ctor.159(%Location* %2, %Location* %fv1.addr) %3 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %this.addr %4 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %3, i32 0, i32 1 - call void @ctor.175(%String* %4, %String* %fv2) + call void @ctor.165(%String* %4, %String* %fv2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.571(%LocString* %this) #3 { +define internal void @dtor.556(%LocString* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %LocString, %LocString* %this, i32 0, i32 0 - call void @dtor.572(%"Tuple[Location, String]"* %1) + call void @dtor.557(%"Tuple[Location, String]"* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.572(%"Tuple[Location, String]"* %this) #3 { +define internal void @dtor.557(%"Tuple[Location, String]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %this, i32 0, i32 1 - call void @dtor.250(%String* %1) + call void @dtor.239(%String* %1) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.573(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #4 { - %size = alloca i64 +define internal void @ctor.558(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #4 { + %size = alloca i32 %"$tmpForRef" = alloca %"RawPtr[LocString]" %"$tmpForRef1" = alloca %"RawPtr[LocString]" %dst = alloca %"RawPtr[LocString]" @@ -23623,49 +22955,49 @@ define internal void @ctor.573(%"Vector[LocString]"* %this, %"Vector[LocString]" code: ; preds = %0 %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - call void @ctor.551(%"RawPtr[LocString]"* %1) + call void @ctor.536(%"RawPtr[LocString]"* %1) %2 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - call void @ctor.551(%"RawPtr[LocString]"* %2) + call void @ctor.536(%"RawPtr[LocString]"* %2) %3 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 - call void @ctor.551(%"RawPtr[LocString]"* %3) - %4 = call i64 @size.559(%"Vector[LocString]"* %other) - store i64 %4, i64* %size + call void @ctor.536(%"RawPtr[LocString]"* %3) + %4 = call i32 @size.544(%"Vector[LocString]"* %other) + store i32 %4, i32* %size %5 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - %6 = load i64, i64* %size - %7 = call %"RawPtr[LocString]" @allocRawPtr.574(i64 %6) + %6 = load i32, i32* %size + %7 = call %"RawPtr[LocString]" @allocRawPtr.559(i32 %6) store %"RawPtr[LocString]" %7, %"RawPtr[LocString]"* %"$tmpForRef" - call void @"=.562"(%"RawPtr[LocString]"* %5, %"RawPtr[LocString]"* %"$tmpForRef") + call void @"=.547"(%"RawPtr[LocString]"* %5, %"RawPtr[LocString]"* %"$tmpForRef") %8 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 %9 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - %10 = load i64, i64* %size - %11 = call %"RawPtr[LocString]" @advance.563(%"RawPtr[LocString]"* %9, i64 %10) + %10 = load i32, i32* %size + %11 = call %"RawPtr[LocString]" @advance.548(%"RawPtr[LocString]"* %9, i32 %10) store %"RawPtr[LocString]" %11, %"RawPtr[LocString]"* %"$tmpForRef1" - call void @"=.562"(%"RawPtr[LocString]"* %8, %"RawPtr[LocString]"* %"$tmpForRef1") + call void @"=.547"(%"RawPtr[LocString]"* %8, %"RawPtr[LocString]"* %"$tmpForRef1") %12 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 %13 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - call void @"=.562"(%"RawPtr[LocString]"* %12, %"RawPtr[LocString]"* %13) + call void @"=.547"(%"RawPtr[LocString]"* %12, %"RawPtr[LocString]"* %13) %14 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - call void @ctor.576(%"RawPtr[LocString]"* %dst, %"RawPtr[LocString]"* %14) + call void @ctor.561(%"RawPtr[LocString]"* %dst, %"RawPtr[LocString]"* %14) %15 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %other, i32 0, i32 0 - call void @ctor.576(%"RawPtr[LocString]"* %src, %"RawPtr[LocString]"* %15) + call void @ctor.561(%"RawPtr[LocString]"* %src, %"RawPtr[LocString]"* %15) br label %while_block while_block: ; preds = %while_step, %code %16 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - %17 = call i1 @"==.554"(%"RawPtr[LocString]"* %dst, %"RawPtr[LocString]"* %16) + %17 = call i1 @"==.539"(%"RawPtr[LocString]"* %dst, %"RawPtr[LocString]"* %16) %18 = xor i1 true, %17 br i1 %18, label %while_body, label %while_end while_body: ; preds = %while_block - %19 = call %LocString* @value.567(%"RawPtr[LocString]"* %dst) - %20 = call %LocString* @value.567(%"RawPtr[LocString]"* %src) - call void @ctor.565(%LocString* %19, %LocString* %20) - %21 = call %"RawPtr[LocString]" @advance.568(%"RawPtr[LocString]"* %dst) + %19 = call %LocString* @value.552(%"RawPtr[LocString]"* %dst) + %20 = call %LocString* @value.552(%"RawPtr[LocString]"* %src) + call void @ctor.550(%LocString* %19, %LocString* %20) + %21 = call %"RawPtr[LocString]" @advance.553(%"RawPtr[LocString]"* %dst) store %"RawPtr[LocString]" %21, %"RawPtr[LocString]"* %"$tmpForRef2" - call void @"=.562"(%"RawPtr[LocString]"* %dst, %"RawPtr[LocString]"* %"$tmpForRef2") - %22 = call %"RawPtr[LocString]" @advance.568(%"RawPtr[LocString]"* %src) + call void @"=.547"(%"RawPtr[LocString]"* %dst, %"RawPtr[LocString]"* %"$tmpForRef2") + %22 = call %"RawPtr[LocString]" @advance.553(%"RawPtr[LocString]"* %src) store %"RawPtr[LocString]" %22, %"RawPtr[LocString]"* %"$tmpForRef3" - call void @"=.562"(%"RawPtr[LocString]"* %src, %"RawPtr[LocString]"* %"$tmpForRef3") + call void @"=.547"(%"RawPtr[LocString]"* %src, %"RawPtr[LocString]"* %"$tmpForRef3") br label %while_step while_step: ; preds = %while_body @@ -23676,28 +23008,28 @@ while_end: ; preds = %while_block } ; Function Attrs: inlinehint nounwind -define internal %"RawPtr[LocString]" @allocRawPtr.574(i64 %num) #4 { - %num.addr = alloca i64 - store i64 %num, i64* %num.addr +define internal %"RawPtr[LocString]" @allocRawPtr.559(i32 %num) #4 { + %num.addr = alloca i32 + store i32 %num, i32* %num.addr %tmp.this = alloca %"RawPtr[LocString]" %"$tmpForRef" = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = load i64, i64* %num.addr - %2 = mul i64 %1, 48 - %3 = call %UntypedPtr @malloc(i64 %2) + %1 = load i32, i32* %num.addr + %2 = call i32 @_Int32_opMul(i32 %1, i32 48) + %3 = call %UntypedPtr @malloc(i32 %2) store %UntypedPtr %3, %UntypedPtr* %"$tmpForRef" %4 = getelementptr inbounds %UntypedPtr, %UntypedPtr* %"$tmpForRef", i32 0, i32 0 %5 = load i8*, i8** %4 %6 = bitcast i8* %5 to %LocString* - call void @ctor.575(%"RawPtr[LocString]"* %tmp.this, %LocString* %6) + call void @ctor.560(%"RawPtr[LocString]"* %tmp.this, %LocString* %6) %7 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %tmp.this ret %"RawPtr[LocString]" %7 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.575(%"RawPtr[LocString]"* %this, %LocString* %f_ptr) #3 { +define internal void @ctor.560(%"RawPtr[LocString]"* %this, %LocString* %f_ptr) #3 { %this.addr = alloca %"RawPtr[LocString]"* store %"RawPtr[LocString]"* %this, %"RawPtr[LocString]"** %this.addr %f_ptr.addr = alloca %LocString* @@ -23713,7 +23045,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.576(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]"* %other) #3 { +define internal void @ctor.561(%"RawPtr[LocString]"* %this, %"RawPtr[LocString]"* %other) #3 { %other.addr = alloca %"RawPtr[LocString]"* store %"RawPtr[LocString]"* %other, %"RawPtr[LocString]"** %other.addr br label %code @@ -23728,41 +23060,41 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @dtor.577(%"Vector[LocString]"* %this) #4 { +define internal void @dtor.562(%"Vector[LocString]"* %this) #4 { %p = alloca %"RawPtr[LocString]" %"$tmpForRef" = alloca %"RawPtr[LocString]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - call void @ctor.576(%"RawPtr[LocString]"* %p, %"RawPtr[LocString]"* %1) + call void @ctor.561(%"RawPtr[LocString]"* %p, %"RawPtr[LocString]"* %1) br label %while_block while_block: ; preds = %while_step, %code %2 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 - %3 = call i1 @"==.554"(%"RawPtr[LocString]"* %p, %"RawPtr[LocString]"* %2) + %3 = call i1 @"==.539"(%"RawPtr[LocString]"* %p, %"RawPtr[LocString]"* %2) %4 = xor i1 true, %3 br i1 %4, label %while_body, label %while_end while_body: ; preds = %while_block - %5 = call %LocString* @value.567(%"RawPtr[LocString]"* %p) - call void @dtor.571(%LocString* %5) + %5 = call %LocString* @value.552(%"RawPtr[LocString]"* %p) + call void @dtor.556(%LocString* %5) br label %while_step while_step: ; preds = %while_body - %6 = call %"RawPtr[LocString]" @advance.568(%"RawPtr[LocString]"* %p) + %6 = call %"RawPtr[LocString]" @advance.553(%"RawPtr[LocString]"* %p) store %"RawPtr[LocString]" %6, %"RawPtr[LocString]"* %"$tmpForRef" - call void @"=.562"(%"RawPtr[LocString]"* %p, %"RawPtr[LocString]"* %"$tmpForRef") + call void @"=.547"(%"RawPtr[LocString]"* %p, %"RawPtr[LocString]"* %"$tmpForRef") br label %while_block while_end: ; preds = %while_block %7 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 - call void @freePtr.578(%"RawPtr[LocString]"* %7) + call void @freePtr.563(%"RawPtr[LocString]"* %7) ret void } ; Function Attrs: inlinehint nounwind -define internal void @freePtr.578(%"RawPtr[LocString]"* %this) #4 { +define internal void @freePtr.563(%"RawPtr[LocString]"* %this) #4 { %tmp.this = alloca %UntypedPtr br label %code @@ -23770,13 +23102,13 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - %1 = call i1 @isSet.579(%"RawPtr[LocString]"* %this) + %1 = call i1 @isSet.564(%"RawPtr[LocString]"* %this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block %2 = getelementptr inbounds %"RawPtr[LocString]", %"RawPtr[LocString]"* %this, i32 0, i32 0 %3 = load %LocString*, %LocString** %2 - call void @ctor.557(%UntypedPtr* %tmp.this, %LocString* %3) + call void @ctor.542(%UntypedPtr* %tmp.this, %LocString* %3) %4 = load %UntypedPtr, %UntypedPtr* %tmp.this call void @free(%UntypedPtr %4) br label %if_end @@ -23786,7 +23118,7 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: inlinehint nounwind -define internal i1 @isSet.579(%"RawPtr[LocString]"* %this) #4 { +define internal i1 @isSet.564(%"RawPtr[LocString]"* %this) #4 { br label %code code: ; preds = %0 @@ -23830,13 +23162,13 @@ code: ; preds = %0 if_block: ; preds = %code %1 = load i32, i32* %kind.addr - %2 = icmp eq i32 %1, 0 + %2 = call i1 @_Int32_opEQ(i32 %1, i32 0) br i1 %2, label %if_then, label %if_else if_then: ; preds = %if_block - %3 = call %"ContiguousMemoryRange[LocString]" @all.581(%"Vector[LocString]"* %ids) + %3 = call %"ContiguousMemoryRange[LocString]" @all.566(%"Vector[LocString]"* %ids) store %"ContiguousMemoryRange[LocString]" %3, %"ContiguousMemoryRange[LocString]"* %"$tmpForRef" - call void @ctor.580(%"ContiguousMemoryRange[LocString]"* %"$rangeVar", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef") + call void @ctor.565(%"ContiguousMemoryRange[LocString]"* %"$rangeVar", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef") br label %while_block if_else: ; preds = %if_block @@ -23846,13 +23178,13 @@ if_end: ; preds = %if_end6, %while_end ret void while_block: ; preds = %while_step, %if_then - %4 = call i1 @isEmpty.583(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") + %4 = call i1 @isEmpty.568(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") %5 = xor i1 true, %4 br i1 %5, label %while_body, label %while_end while_body: ; preds = %while_block - %6 = call %LocString* @front.584(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") - call void @ctor.565(%LocString* %id, %LocString* %6) + %6 = call %LocString* @front.569(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") + call void @ctor.550(%LocString* %id, %LocString* %6) %7 = getelementptr inbounds %LocString, %LocString* %id, i32 0, i32 0 %8 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %7, i32 0, i32 0 %9 = load %Location, %Location* %8 @@ -23863,17 +23195,17 @@ while_body: ; preds = %while_block %14 = load %Node, %Node* %init.addr %15 = call %Node @mkLet(%AstBuilder* %astBuilder, %Location %9, %StringRef %12, %Node %13, %Node %14) store %Node %15, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %v, %Node* %"$tmpForRef1") + call void @ctor.520(%Node* %v, %Node* %"$tmpForRef1") %16 = load %Node, %Node* %res %17 = load %Node, %Node* %v %18 = call %Node @addToNodeList(%AstBuilder* %astBuilder, %Node %16, %Node %17) store %Node %18, %Node* %"$tmpForRef2" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef2") - call void @dtor.571(%LocString* %id) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef2") + call void @dtor.556(%LocString* %id) br label %while_step while_step: ; preds = %while_body - call void @popFront.586(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") + call void @popFront.571(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") br label %while_block while_end: ; preds = %while_block @@ -23881,32 +23213,32 @@ while_end: ; preds = %while_block if_block3: ; preds = %if_else %19 = load i32, i32* %kind.addr - %20 = icmp eq i32 %19, 1 + %20 = call i1 @_Int32_opEQ(i32 %19, i32 1) br i1 %20, label %if_then4, label %if_else5 if_then4: ; preds = %if_block3 - %21 = call %"ContiguousMemoryRange[LocString]" @all.581(%"Vector[LocString]"* %ids) + %21 = call %"ContiguousMemoryRange[LocString]" @all.566(%"Vector[LocString]"* %ids) store %"ContiguousMemoryRange[LocString]" %21, %"ContiguousMemoryRange[LocString]"* %"$tmpForRef8" - call void @ctor.580(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef8") + call void @ctor.565(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef8") br label %while_block9 if_else5: ; preds = %if_block3 - %22 = call %"ContiguousMemoryRange[LocString]" @all.581(%"Vector[LocString]"* %ids) + %22 = call %"ContiguousMemoryRange[LocString]" @all.566(%"Vector[LocString]"* %ids) store %"ContiguousMemoryRange[LocString]" %22, %"ContiguousMemoryRange[LocString]"* %"$tmpForRef18" - call void @ctor.580(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef18") + call void @ctor.565(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef18") br label %while_block19 if_end6: ; preds = %while_end22, %while_end12 br label %if_end while_block9: ; preds = %while_step11, %if_then4 - %23 = call i1 @isEmpty.583(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7") + %23 = call i1 @isEmpty.568(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7") %24 = xor i1 true, %23 br i1 %24, label %while_body10, label %while_end12 while_body10: ; preds = %while_block9 - %25 = call %LocString* @front.584(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7") - call void @ctor.565(%LocString* %id13, %LocString* %25) + %25 = call %LocString* @front.569(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7") + call void @ctor.550(%LocString* %id13, %LocString* %25) %26 = getelementptr inbounds %LocString, %LocString* %id13, i32 0, i32 0 %27 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %26, i32 0, i32 0 %28 = load %Location, %Location* %27 @@ -23917,30 +23249,30 @@ while_body10: ; preds = %while_block9 %33 = load %Node, %Node* %init.addr %34 = call %Node @mkVar(%AstBuilder* %astBuilder, %Location %28, %StringRef %31, %Node %32, %Node %33) store %Node %34, %Node* %"$tmpForRef15" - call void @ctor.535(%Node* %v14, %Node* %"$tmpForRef15") + call void @ctor.520(%Node* %v14, %Node* %"$tmpForRef15") %35 = load %Node, %Node* %res %36 = load %Node, %Node* %v14 %37 = call %Node @addToNodeList(%AstBuilder* %astBuilder, %Node %35, %Node %36) store %Node %37, %Node* %"$tmpForRef16" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef16") - call void @dtor.571(%LocString* %id13) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef16") + call void @dtor.556(%LocString* %id13) br label %while_step11 while_step11: ; preds = %while_body10 - call void @popFront.586(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7") + call void @popFront.571(%"ContiguousMemoryRange[LocString]"* %"$rangeVar7") br label %while_block9 while_end12: ; preds = %while_block9 br label %if_end6 while_block19: ; preds = %while_step21, %if_else5 - %38 = call i1 @isEmpty.583(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17") + %38 = call i1 @isEmpty.568(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17") %39 = xor i1 true, %38 br i1 %39, label %while_body20, label %while_end22 while_body20: ; preds = %while_block19 - %40 = call %LocString* @front.584(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17") - call void @ctor.565(%LocString* %id23, %LocString* %40) + %40 = call %LocString* @front.569(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17") + call void @ctor.550(%LocString* %id23, %LocString* %40) %41 = getelementptr inbounds %LocString, %LocString* %id23, i32 0, i32 0 %42 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %41, i32 0, i32 0 %43 = load %Location, %Location* %42 @@ -23951,17 +23283,17 @@ while_body20: ; preds = %while_block19 %48 = load %Node, %Node* %init.addr %49 = call %Node @mkParameter(%AstBuilder* %astBuilder, %Location %43, %StringRef %46, %Node %47, %Node %48) store %Node %49, %Node* %"$tmpForRef24" - call void @ctor.535(%Node* %p, %Node* %"$tmpForRef24") + call void @ctor.520(%Node* %p, %Node* %"$tmpForRef24") %50 = load %Node, %Node* %res %51 = load %Node, %Node* %p %52 = call %Node @addToNodeList(%AstBuilder* %astBuilder, %Node %50, %Node %51) store %Node %52, %Node* %"$tmpForRef25" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef25") - call void @dtor.571(%LocString* %id23) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef25") + call void @dtor.556(%LocString* %id23) br label %while_step21 while_step21: ; preds = %while_body20 - call void @popFront.586(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17") + call void @popFront.571(%"ContiguousMemoryRange[LocString]"* %"$rangeVar17") br label %while_block19 while_end22: ; preds = %while_block19 @@ -23969,7 +23301,7 @@ while_end22: ; preds = %while_block19 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.580(%"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"* %other) #3 { +define internal void @ctor.565(%"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"* %other) #3 { %other.addr = alloca %"ContiguousMemoryRange[LocString]"* store %"ContiguousMemoryRange[LocString]"* %other, %"ContiguousMemoryRange[LocString]"** %other.addr br label %code @@ -23978,16 +23310,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 0 %2 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %other.addr %3 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %2, i32 0, i32 0 - call void @ctor.576(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) + call void @ctor.561(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) %4 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 1 %5 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %other.addr %6 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %5, i32 0, i32 1 - call void @ctor.576(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) + call void @ctor.561(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) ret void } ; Function Attrs: inlinehint nounwind -define internal %"ContiguousMemoryRange[LocString]" @all.581(%"Vector[LocString]"* %this) #4 { +define internal %"ContiguousMemoryRange[LocString]" @all.566(%"Vector[LocString]"* %this) #4 { %tmp.this = alloca %"ContiguousMemoryRange[LocString]" br label %code @@ -23996,13 +23328,13 @@ code: ; preds = %0 %2 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %1 %3 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 %4 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %3 - call void @ctor.582(%"ContiguousMemoryRange[LocString]"* %tmp.this, %"RawPtr[LocString]" %2, %"RawPtr[LocString]" %4) + call void @ctor.567(%"ContiguousMemoryRange[LocString]"* %tmp.this, %"RawPtr[LocString]" %2, %"RawPtr[LocString]" %4) %5 = load %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %tmp.this ret %"ContiguousMemoryRange[LocString]" %5 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.582(%"ContiguousMemoryRange[LocString]"* %this, %"RawPtr[LocString]" %f_begin, %"RawPtr[LocString]" %f_end) #3 { +define internal void @ctor.567(%"ContiguousMemoryRange[LocString]"* %this, %"RawPtr[LocString]" %f_begin, %"RawPtr[LocString]" %f_end) #3 { %this.addr = alloca %"ContiguousMemoryRange[LocString]"* store %"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"** %this.addr %f_begin.addr = alloca %"RawPtr[LocString]" @@ -24014,36 +23346,33 @@ define internal void @ctor.582(%"ContiguousMemoryRange[LocString]"* %this, %"Raw code: ; preds = %0 %1 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %this.addr %2 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %1, i32 0, i32 0 - call void @ctor.576(%"RawPtr[LocString]"* %2, %"RawPtr[LocString]"* %f_begin.addr) + call void @ctor.561(%"RawPtr[LocString]"* %2, %"RawPtr[LocString]"* %f_begin.addr) %3 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %this.addr %4 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %3, i32 0, i32 1 - call void @ctor.576(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %f_end.addr) + call void @ctor.561(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %f_end.addr) ret void } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.583(%"ContiguousMemoryRange[LocString]"* %this) #4 { - %tmp.this = alloca i64 +define internal i1 @isEmpty.568(%"ContiguousMemoryRange[LocString]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 1 %2 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 0 %3 = load %"RawPtr[LocString]", %"RawPtr[LocString]"* %2 - %4 = call i64 @diff.556(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]" %3) - store i64 0, i64* %tmp.this - %5 = load i64, i64* %tmp.this - %6 = icmp sle i64 %4, %5 - ret i1 %6 + %4 = call i32 @diff.541(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]" %3) + %5 = call i1 @_Int32_opLE(i32 %4, i32 0) + ret i1 %5 } ; Function Attrs: inlinehint nounwind -define internal %LocString* @front.584(%"ContiguousMemoryRange[LocString]"* %this) #4 { +define internal %LocString* @front.569(%"ContiguousMemoryRange[LocString]"* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 0 - %2 = call %LocString* @value.567(%"RawPtr[LocString]"* %1) + %2 = call %LocString* @value.552(%"RawPtr[LocString]"* %1) ret %LocString* %2 } @@ -24066,12 +23395,12 @@ code: ; preds = %0 %4 = load %StringRef, %StringRef* %name.addr %5 = load %Node, %Node* %typeNode.addr %6 = load %Node, %Node* %init.addr - %7 = call %Node @"().585"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) + %7 = call %Node @"().570"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) ret %Node %7 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().585"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5) #4 { +define internal %Node @"().570"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -24094,16 +23423,16 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @popFront.586(%"ContiguousMemoryRange[LocString]"* %this) #3 { +define internal void @popFront.571(%"ContiguousMemoryRange[LocString]"* %this) #3 { %"$tmpForRef" = alloca %"RawPtr[LocString]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 0 %2 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 0 - %3 = call %"RawPtr[LocString]" @advance.568(%"RawPtr[LocString]"* %2) + %3 = call %"RawPtr[LocString]" @advance.553(%"RawPtr[LocString]"* %2) store %"RawPtr[LocString]" %3, %"RawPtr[LocString]"* %"$tmpForRef" - call void @"=.562"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %"$tmpForRef") + call void @"=.547"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %"$tmpForRef") ret void } @@ -24126,7 +23455,7 @@ code: ; preds = %0 %4 = load %StringRef, %StringRef* %name.addr %5 = load %Node, %Node* %typeNode.addr %6 = load %Node, %Node* %init.addr - %7 = call %Node @"().585"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) + %7 = call %Node @"().570"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) ret %Node %7 } @@ -24149,7 +23478,7 @@ code: ; preds = %0 %4 = load %StringRef, %StringRef* %name.addr %5 = load %Node, %Node* %typeNode.addr %6 = load %Node, %Node* %init.addr - %7 = call %Node @"().585"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) + %7 = call %Node @"().570"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) ret %Node %7 } @@ -24163,7 +23492,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 31) + call void @ctor.393(%TokenType* %tmp.this, i32 31) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end @@ -24172,7 +23501,7 @@ if_then: ; preds = %if_block ret %Node %2 if_end: ; preds = %dumy_block, %if_block - call void @ctor.546(%Node* %tmp.this1) + call void @ctor.531(%Node* %tmp.this1) %3 = load %Node, %Node* %tmp.this1 ret %Node %3 @@ -24197,17 +23526,17 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 32) + call void @ctor.393(%TokenType* %tmp.this, i32 32) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block - call void @ctor.546(%Node* %tmp.this1) + call void @ctor.531(%Node* %tmp.this1) %2 = load %Node, %Node* %tmp.this1 ret %Node %2 if_end: ; preds = %dumy_block, %if_block - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) br label %if_block2 dumy_block: ; No predecessors! @@ -24228,7 +23557,7 @@ if_then3: ; preds = %if_block2 %9 = load %StringRef, %StringRef* %tmp.StringRef store %StringRef %9, %StringRef* %"$tmpForRef" %10 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC5", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %10) + call void @"pre_*.518"(%Token* %"$tmpC5", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %10) %11 = getelementptr inbounds %Token, %Token* %"$tmpC5", i32 0, i32 1 %12 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef7, i32 0, i32 0 %13 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef7, i32 0, i32 1 @@ -24238,10 +23567,10 @@ if_then3: ; preds = %if_block2 store i8* getelementptr inbounds ([28 x i8], [28 x i8]* @str.97, i32 0, i32 27), i8** %15 %16 = load %StringRef, %StringRef* %tmp.StringRef7 store %StringRef %16, %StringRef* %"$tmpForRef6" - call void @toString.589(%String* %"$tmpC", %StringRef* %"$tmpForRef", %TokenType* %11, %StringRef* %"$tmpForRef6") - call void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC5") + call void @toString.574(%String* %"$tmpC", %StringRef* %"$tmpForRef", %TokenType* %11, %StringRef* %"$tmpForRef6") + call void @reportError.523(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC5") br label %if_end4 if_end4: ; preds = %if_then3, %if_block2 @@ -24268,24 +23597,24 @@ define internal i1 @parseBlockStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowS code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 25) + call void @ctor.393(%TokenType* %tmp.this, i32 25) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %2, label %if_then, label %if_end if_then: ; preds = %if_block - call void @ctor.546(%Node* %tmp.this1) - call void @"=.544"(%Node* %res, %Node* %tmp.this1) + call void @ctor.531(%Node* %tmp.this1) + call void @"=.529"(%Node* %res, %Node* %tmp.this1) br label %while_block if_end: ; preds = %dumy_block13, %if_block ret i1 false while_block: ; preds = %while_step, %if_then - call void @ctor.404(%TokenType* %tmp.this2, i32 26) + call void @ctor.393(%TokenType* %tmp.this2, i32 26) %3 = call i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this2) %4 = xor i1 true, %3 br i1 %4, label %cond.true, label %cond.false @@ -24294,14 +23623,14 @@ while_body: ; preds = %cond.end %5 = load i1, i1* %topLevel.addr %6 = call %Node @parseStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %5) store %Node %6, %Node* %"$tmpForRef3" - call void @ctor.535(%Node* %s, %Node* %"$tmpForRef3") + call void @ctor.520(%Node* %s, %Node* %"$tmpForRef3") br label %if_block4 while_step: ; preds = %if_end6 br label %while_block while_end: ; preds = %if_else, %cond.end - call void @ctor.404(%TokenType* %tmp.this8, i32 26) + call void @ctor.393(%TokenType* %tmp.this8, i32 26) %7 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this8) br label %if_block9 @@ -24320,7 +23649,7 @@ cond.end: ; preds = %cond.false, %cond.t if_block4: ; preds = %while_body %11 = load %Node, %Node* %s - %12 = call i1 @isSet.587(%Node %11) + %12 = call i1 @isSet.572(%Node %11) br i1 %12, label %if_then5, label %if_else if_then5: ; preds = %if_block4 @@ -24329,7 +23658,7 @@ if_then5: ; preds = %if_block4 %15 = load %Node, %Node* %s %16 = call %Node @addToNodeList(%AstBuilder* %13, %Node %14, %Node %15) store %Node %16, %Node* %"$tmpForRef7" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef7") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef7") br label %if_end6 if_else: ; preds = %if_block4 @@ -24354,7 +23683,7 @@ if_then10: ; preds = %if_block9 %23 = load %Node, %Node* %res %24 = call %Node @mkBlockStmt(%AstBuilder* %19, %Location %22, %Node %23) store %Node %24, %Node* %"$tmpForRef12" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef12") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef12") br label %if_end11 if_end11: ; preds = %if_then10, %if_block9 @@ -24365,7 +23694,7 @@ dumy_block13: ; No predecessors! } ; Function Attrs: inlinehint nounwind -define internal i1 @isSet.587(%Node %n) #4 { +define internal i1 @isSet.572(%Node %n) #4 { %n.addr = alloca %Node store %Node %n, %Node* %n.addr br label %code @@ -24391,12 +23720,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %stmts.addr - %5 = call %Node @"().588"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4) + %5 = call %Node @"().573"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().588"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3) #4 { +define internal %Node @"().573"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %Node @@ -24413,7 +23742,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @toString.589(%String* sret %_result, %StringRef* %a1, %TokenType* %a2, %StringRef* %a3) #4 { +define internal void @toString.574(%String* sret %_result, %StringRef* %a1, %TokenType* %a2, %StringRef* %a3) #4 { %s = alloca %StringOutputStream %"$tmpC" = alloca %StringOutputStream %"$tmpC1" = alloca %StringOutputStream @@ -24421,20 +23750,20 @@ define internal void @toString.589(%String* sret %_result, %StringRef* %a1, %Tok br label %code code: ; preds = %0 - call void @ctor.439(%StringOutputStream* %s) + call void @ctor.428(%StringOutputStream* %s) call void @"<<"(%StringOutputStream* %"$tmpC2", %StringOutputStream* %s, %StringRef* %a1) - call void @"<<.540"(%StringOutputStream* %"$tmpC1", %StringOutputStream* %"$tmpC2", %TokenType* %a2) + call void @"<<.525"(%StringOutputStream* %"$tmpC1", %StringOutputStream* %"$tmpC2", %TokenType* %a2) call void @"<<"(%StringOutputStream* %"$tmpC", %StringOutputStream* %"$tmpC1", %StringRef* %a3) - call void @dtor.442(%StringOutputStream* %"$tmpC") - call void @dtor.442(%StringOutputStream* %"$tmpC1") - call void @dtor.442(%StringOutputStream* %"$tmpC2") + call void @dtor.431(%StringOutputStream* %"$tmpC") + call void @dtor.431(%StringOutputStream* %"$tmpC1") + call void @dtor.431(%StringOutputStream* %"$tmpC2") %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %s, i32 0, i32 0 - call void @ctor.175(%String* %_result, %String* %1) - call void @dtor.442(%StringOutputStream* %s) + call void @ctor.165(%String* %_result, %String* %1) + call void @dtor.431(%StringOutputStream* %s) ret void dumy_block: ; No predecessors! - call void @dtor.442(%StringOutputStream* %s) + call void @dtor.431(%StringOutputStream* %s) ret void } @@ -24463,12 +23792,12 @@ code: ; preds = %0 %6 = load %Node, %Node* %retType.addr %7 = load %Node, %Node* %body.addr %8 = load %Node, %Node* %bodyExpr.addr - %9 = call %Node @"().590"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5, %Node %6, %Node %7, %Node %8) + %9 = call %Node @"().575"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5, %Node %6, %Node %7, %Node %8) ret %Node %9 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().590"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %Node %p4, %Node %p5, %Node %p6, %Node %p7) #4 { +define internal %Node @"().575"(%"FunctionPtr7[Node, UntypedPtr, Location const, Node, Node, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %Node %p4, %Node %p5, %Node %p6, %Node %p7) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %Node @@ -24507,12 +23836,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %expr.addr - %5 = call %Node @"().591"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %1, %UntypedPtr %3, %Node %4) + %5 = call %Node @"().576"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %1, %UntypedPtr %3, %Node %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().591"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %UntypedPtr %p1, %Node %p2) #4 { +define internal %Node @"().576"(%"FunctionPtr2[Node, UntypedPtr, Node]"* %this, %UntypedPtr %p1, %Node %p2) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p2.addr = alloca %Node @@ -24538,12 +23867,12 @@ code: ; preds = %0 %1 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 24 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 - %4 = call %Node @"().592"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %1, %UntypedPtr %3, %Location* %loc.addr) + %4 = call %Node @"().577"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %1, %UntypedPtr %3, %Location* %loc.addr) ret %Node %4 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().592"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %UntypedPtr %p1, %Location* %p2) #4 { +define internal %Node @"().577"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %this, %UntypedPtr %p1, %Location* %p2) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr br label %code @@ -24569,12 +23898,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load i1, i1* %val.addr - %5 = call %Node @"().593"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %1, %UntypedPtr %3, %Location* %loc.addr, i1 %4) + %5 = call %Node @"().578"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %1, %UntypedPtr %3, %Location* %loc.addr, i1 %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().593"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %UntypedPtr %p1, %Location* %p2, i1 %p3) #4 { +define internal %Node @"().578"(%"FunctionPtr3[Node, UntypedPtr, Location const, Bool]"* %this, %UntypedPtr %p1, %Location* %p2, i1 %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca i1 @@ -24603,12 +23932,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load i32, i32* %val.addr - %5 = call %Node @"().594"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %1, %UntypedPtr %3, %Location* %loc.addr, i32 %4) + %5 = call %Node @"().579"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %1, %UntypedPtr %3, %Location* %loc.addr, i32 %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().594"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %UntypedPtr %p1, %Location* %p2, i32 %p3) #4 { +define internal %Node @"().579"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int]"* %this, %UntypedPtr %p1, %Location* %p2, i32 %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca i32 @@ -24637,12 +23966,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load i32, i32* %val.addr - %5 = call %Node @"().595"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %1, %UntypedPtr %3, %Location* %loc.addr, i32 %4) + %5 = call %Node @"().580"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %1, %UntypedPtr %3, %Location* %loc.addr, i32 %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().595"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this, %UntypedPtr %p1, %Location* %p2, i32 %p3) #4 { +define internal %Node @"().580"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this, %UntypedPtr %p1, %Location* %p2, i32 %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca i32 @@ -24652,7 +23981,7 @@ define internal %Node @"().595"(%"FunctionPtr3[Node, UntypedPtr, Location const, code: ; preds = %0 %1 = load %UntypedPtr, %UntypedPtr* %p1.addr %2 = load i32, i32* %p3.addr - %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, UInt]"* %this to %Node (%UntypedPtr, %Location*, i32)** + %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, UInt32]"* %this to %Node (%UntypedPtr, %Location*, i32)** %4 = load %Node (%UntypedPtr, %Location*, i32)*, %Node (%UntypedPtr, %Location*, i32)** %3 %5 = call %Node %4(%UntypedPtr %1, %Location* %p2, i32 %2) ret %Node %5 @@ -24671,12 +24000,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load i64, i64* %val.addr - %5 = call %Node @"().596"(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %1, %UntypedPtr %3, %Location* %loc.addr, i64 %4) + %5 = call %Node @"().581"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %1, %UntypedPtr %3, %Location* %loc.addr, i64 %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().596"(%"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this, %UntypedPtr %p1, %Location* %p2, i64 %p3) #4 { +define internal %Node @"().581"(%"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this, %UntypedPtr %p1, %Location* %p2, i64 %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca i64 @@ -24686,7 +24015,7 @@ define internal %Node @"().596"(%"FunctionPtr3[Node, UntypedPtr, Location const, code: ; preds = %0 %1 = load %UntypedPtr, %UntypedPtr* %p1.addr %2 = load i64, i64* %p3.addr - %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, Long]"* %this to %Node (%UntypedPtr, %Location*, i64)** + %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, Int64]"* %this to %Node (%UntypedPtr, %Location*, i64)** %4 = load %Node (%UntypedPtr, %Location*, i64)*, %Node (%UntypedPtr, %Location*, i64)** %3 %5 = call %Node %4(%UntypedPtr %1, %Location* %p2, i64 %2) ret %Node %5 @@ -24705,12 +24034,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load i64, i64* %val.addr - %5 = call %Node @"().597"(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %1, %UntypedPtr %3, %Location* %loc.addr, i64 %4) + %5 = call %Node @"().582"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %1, %UntypedPtr %3, %Location* %loc.addr, i64 %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().597"(%"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this, %UntypedPtr %p1, %Location* %p2, i64 %p3) #4 { +define internal %Node @"().582"(%"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this, %UntypedPtr %p1, %Location* %p2, i64 %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca i64 @@ -24720,7 +24049,7 @@ define internal %Node @"().597"(%"FunctionPtr3[Node, UntypedPtr, Location const, code: ; preds = %0 %1 = load %UntypedPtr, %UntypedPtr* %p1.addr %2 = load i64, i64* %p3.addr - %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, ULong]"* %this to %Node (%UntypedPtr, %Location*, i64)** + %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, UInt64]"* %this to %Node (%UntypedPtr, %Location*, i64)** %4 = load %Node (%UntypedPtr, %Location*, i64)*, %Node (%UntypedPtr, %Location*, i64)** %3 %5 = call %Node %4(%UntypedPtr %1, %Location* %p2, i64 %2) ret %Node %5 @@ -24739,12 +24068,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load float, float* %val.addr - %5 = call %Node @"().598"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %1, %UntypedPtr %3, %Location* %loc.addr, float %4) + %5 = call %Node @"().583"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %1, %UntypedPtr %3, %Location* %loc.addr, float %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().598"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %UntypedPtr %p1, %Location* %p2, float %p3) #4 { +define internal %Node @"().583"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this, %UntypedPtr %p1, %Location* %p2, float %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca float @@ -24754,7 +24083,7 @@ define internal %Node @"().598"(%"FunctionPtr3[Node, UntypedPtr, Location const, code: ; preds = %0 %1 = load %UntypedPtr, %UntypedPtr* %p1.addr %2 = load float, float* %p3.addr - %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this to %Node (%UntypedPtr, %Location*, float)** + %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, Float32]"* %this to %Node (%UntypedPtr, %Location*, float)** %4 = load %Node (%UntypedPtr, %Location*, float)*, %Node (%UntypedPtr, %Location*, float)** %3 %5 = call %Node %4(%UntypedPtr %1, %Location* %p2, float %2) ret %Node %5 @@ -24773,12 +24102,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load double, double* %val.addr - %5 = call %Node @"().599"(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %1, %UntypedPtr %3, %Location* %loc.addr, double %4) + %5 = call %Node @"().584"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %1, %UntypedPtr %3, %Location* %loc.addr, double %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().599"(%"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this, %UntypedPtr %p1, %Location* %p2, double %p3) #4 { +define internal %Node @"().584"(%"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this, %UntypedPtr %p1, %Location* %p2, double %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca double @@ -24788,7 +24117,7 @@ define internal %Node @"().599"(%"FunctionPtr3[Node, UntypedPtr, Location const, code: ; preds = %0 %1 = load %UntypedPtr, %UntypedPtr* %p1.addr %2 = load double, double* %p3.addr - %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, Double]"* %this to %Node (%UntypedPtr, %Location*, double)** + %3 = bitcast %"FunctionPtr3[Node, UntypedPtr, Location const, Float]"* %this to %Node (%UntypedPtr, %Location*, double)** %4 = load %Node (%UntypedPtr, %Location*, double)*, %Node (%UntypedPtr, %Location*, double)** %3 %5 = call %Node %4(%UntypedPtr %1, %Location* %p2, double %2) ret %Node %5 @@ -24807,12 +24136,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load i8, i8* %val.addr - %5 = call %Node @"().600"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %1, %UntypedPtr %3, %Location* %loc.addr, i8 %4) + %5 = call %Node @"().585"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %1, %UntypedPtr %3, %Location* %loc.addr, i8 %4) ret %Node %5 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().600"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %UntypedPtr %p1, %Location* %p2, i8 %p3) #4 { +define internal %Node @"().585"(%"FunctionPtr3[Node, UntypedPtr, Location const, Char]"* %this, %UntypedPtr %p1, %Location* %p2, i8 %p3) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca i8 @@ -24841,7 +24170,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %StringRef, %StringRef* %data.addr - %5 = call %Node @"().543"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) + %5 = call %Node @"().528"(%"FunctionPtr3[Node, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) ret %Node %5 } @@ -24870,8 +24199,8 @@ define internal %Node @parseExprListOpt(%"SparrowParser[SparrowLayoutDecoder[Spa br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) - call void @ctor.546(%Node* %expr) + call void @ctor.531(%Node* %res) + call void @ctor.531(%Node* %expr) br label %if_block if_block: ; preds = %code @@ -24889,27 +24218,27 @@ if_end: ; preds = %dumy_block, %if_blo %6 = load %Node, %Node* %expr %7 = call %Node @addToNodeList(%AstBuilder* %4, %Node %5, %Node %6) store %Node %7, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") br label %while_block dumy_block: ; No predecessors! br label %if_end while_block: ; preds = %while_step, %if_end - call void @ctor.404(%TokenType* %tmp.this, i32 33) + call void @ctor.393(%TokenType* %tmp.this, i32 33) %8 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %8, label %while_body, label %while_end while_body: ; preds = %while_block %9 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %9, %Node* %"$tmpForRef1" - call void @"=.544"(%Node* %expr, %Node* %"$tmpForRef1") + call void @"=.529"(%Node* %expr, %Node* %"$tmpForRef1") %10 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %11 = load %Node, %Node* %res %12 = load %Node, %Node* %expr %13 = call %Node @addToNodeList(%AstBuilder* %10, %Node %11, %Node %12) store %Node %13, %Node* %"$tmpForRef2" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef2") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef2") br label %while_step while_step: ; preds = %while_body @@ -24937,7 +24266,7 @@ if_block: ; preds = %code if_then: ; preds = %if_block %2 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %2, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") br label %if_block1 if_end: ; preds = %dumy_block, %if_block @@ -24984,15 +24313,15 @@ define internal i1 @nextIsExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScann code: ; preds = %0 %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) + call void @"pre_*.518"(%Token* %"$tmpC", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %1) %2 = getelementptr inbounds %Token, %Token* %"$tmpC", i32 0, i32 1 - call void @ctor.189(%TokenType* %t, %TokenType* %2) - call void @dtor.249(%Token* %"$tmpC") + call void @ctor.178(%TokenType* %t, %TokenType* %2) + call void @dtor.238(%Token* %"$tmpC") br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 36) - %3 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this) + call void @ctor.393(%TokenType* %tmp.this, i32 36) + %3 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block @@ -25000,8 +24329,8 @@ if_then: ; preds = %if_block ret i1 %4 if_end: ; preds = %dumy_block, %if_block - call void @ctor.404(%TokenType* %tmp.this40, i32 37) - %5 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this40) + call void @ctor.393(%TokenType* %tmp.this40, i32 37) + %5 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this40) br i1 %5, label %cond.true37, label %cond.false38 dumy_block: ; No predecessors! @@ -25011,8 +24340,8 @@ cond.true: ; preds = %cond.end3 br label %cond.end cond.false: ; preds = %cond.end3 - call void @ctor.404(%TokenType* %tmp.this66, i32 46) - %6 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this66) + call void @ctor.393(%TokenType* %tmp.this66, i32 46) + %6 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this66) br label %cond.end cond.end: ; preds = %cond.false, %cond.true @@ -25023,8 +24352,8 @@ cond.true1: ; preds = %cond.end6 br label %cond.end3 cond.false2: ; preds = %cond.end6 - call void @ctor.404(%TokenType* %tmp.this64, i32 45) - %7 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this64) + call void @ctor.393(%TokenType* %tmp.this64, i32 45) + %7 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this64) br label %cond.end3 cond.end3: ; preds = %cond.false2, %cond.true1 @@ -25035,8 +24364,8 @@ cond.true4: ; preds = %cond.end9 br label %cond.end6 cond.false5: ; preds = %cond.end9 - call void @ctor.404(%TokenType* %tmp.this62, i32 44) - %8 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this62) + call void @ctor.393(%TokenType* %tmp.this62, i32 44) + %8 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this62) br label %cond.end6 cond.end6: ; preds = %cond.false5, %cond.true4 @@ -25047,8 +24376,8 @@ cond.true7: ; preds = %cond.end12 br label %cond.end9 cond.false8: ; preds = %cond.end12 - call void @ctor.404(%TokenType* %tmp.this60, i32 43) - %9 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this60) + call void @ctor.393(%TokenType* %tmp.this60, i32 43) + %9 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this60) br label %cond.end9 cond.end9: ; preds = %cond.false8, %cond.true7 @@ -25059,8 +24388,8 @@ cond.true10: ; preds = %cond.end15 br label %cond.end12 cond.false11: ; preds = %cond.end15 - call void @ctor.404(%TokenType* %tmp.this58, i32 42) - %10 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this58) + call void @ctor.393(%TokenType* %tmp.this58, i32 42) + %10 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this58) br label %cond.end12 cond.end12: ; preds = %cond.false11, %cond.true10 @@ -25071,8 +24400,8 @@ cond.true13: ; preds = %cond.end18 br label %cond.end15 cond.false14: ; preds = %cond.end18 - call void @ctor.404(%TokenType* %tmp.this56, i32 41) - %11 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this56) + call void @ctor.393(%TokenType* %tmp.this56, i32 41) + %11 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this56) br label %cond.end15 cond.end15: ; preds = %cond.false14, %cond.true13 @@ -25083,8 +24412,8 @@ cond.true16: ; preds = %cond.end21 br label %cond.end18 cond.false17: ; preds = %cond.end21 - call void @ctor.404(%TokenType* %tmp.this54, i32 40) - %12 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this54) + call void @ctor.393(%TokenType* %tmp.this54, i32 40) + %12 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this54) br label %cond.end18 cond.end18: ; preds = %cond.false17, %cond.true16 @@ -25095,8 +24424,8 @@ cond.true19: ; preds = %cond.end24 br label %cond.end21 cond.false20: ; preds = %cond.end24 - call void @ctor.404(%TokenType* %tmp.this52, i32 39) - %13 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this52) + call void @ctor.393(%TokenType* %tmp.this52, i32 39) + %13 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this52) br label %cond.end21 cond.end21: ; preds = %cond.false20, %cond.true19 @@ -25107,8 +24436,8 @@ cond.true22: ; preds = %cond.end27 br label %cond.end24 cond.false23: ; preds = %cond.end27 - call void @ctor.404(%TokenType* %tmp.this50, i32 21) - %14 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this50) + call void @ctor.393(%TokenType* %tmp.this50, i32 21) + %14 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this50) br label %cond.end24 cond.end24: ; preds = %cond.false23, %cond.true22 @@ -25119,8 +24448,8 @@ cond.true25: ; preds = %cond.end30 br label %cond.end27 cond.false26: ; preds = %cond.end30 - call void @ctor.404(%TokenType* %tmp.this48, i32 23) - %15 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this48) + call void @ctor.393(%TokenType* %tmp.this48, i32 23) + %15 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this48) br label %cond.end27 cond.end27: ; preds = %cond.false26, %cond.true25 @@ -25131,8 +24460,8 @@ cond.true28: ; preds = %cond.end33 br label %cond.end30 cond.false29: ; preds = %cond.end33 - call void @ctor.404(%TokenType* %tmp.this46, i32 22) - %16 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this46) + call void @ctor.393(%TokenType* %tmp.this46, i32 22) + %16 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this46) br label %cond.end30 cond.end30: ; preds = %cond.false29, %cond.true28 @@ -25143,8 +24472,8 @@ cond.true31: ; preds = %cond.end36 br label %cond.end33 cond.false32: ; preds = %cond.end36 - call void @ctor.404(%TokenType* %tmp.this44, i32 29) - %17 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this44) + call void @ctor.393(%TokenType* %tmp.this44, i32 29) + %17 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this44) br label %cond.end33 cond.end33: ; preds = %cond.false32, %cond.true31 @@ -25155,8 +24484,8 @@ cond.true34: ; preds = %cond.end39 br label %cond.end36 cond.false35: ; preds = %cond.end39 - call void @ctor.404(%TokenType* %tmp.this42, i32 35) - %18 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this42) + call void @ctor.393(%TokenType* %tmp.this42, i32 35) + %18 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this42) br label %cond.end36 cond.end36: ; preds = %cond.false35, %cond.true34 @@ -25167,8 +24496,8 @@ cond.true37: ; preds = %if_end br label %cond.end39 cond.false38: ; preds = %if_end - call void @ctor.404(%TokenType* %tmp.this41, i32 38) - %19 = call i1 @"==.339"(%TokenType* %t, %TokenType* %tmp.this41) + call void @ctor.393(%TokenType* %tmp.this41, i32 38) + %19 = call i1 @"==.328"(%TokenType* %t, %TokenType* %tmp.this41) br label %cond.end39 cond.end39: ; preds = %cond.false38, %cond.true37 @@ -25447,12 +24776,12 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %base.addr %5 = load %Node, %Node* %args.addr - %6 = call %Node @"().601"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5) + %6 = call %Node @"().586"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5) ret %Node %6 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().601"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %Node %p4) #4 { +define internal %Node @"().586"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %Node %p4) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %Node @@ -25487,7 +24816,7 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %base.addr %5 = load %StringRef, %StringRef* %id.addr - %6 = call %Node @"().545"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) + %6 = call %Node @"().530"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) ret %Node %6 } @@ -25511,14 +24840,14 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 37) + call void @ctor.393(%TokenType* %tmp.this, i32 37) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_else if_then: ; preds = %if_block %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 2 - call void @ctor.175(%String* %_result, %String* %3) + call void @ctor.165(%String* %_result, %String* %3) ret void if_else: ; preds = %if_block @@ -25534,7 +24863,7 @@ if_end: ; preds = %if_end4, %dumy_bloc %8 = load %StringRef, %StringRef* %tmp.StringRef15 store %StringRef %8, %StringRef* %"$tmpForRef" %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC16", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %9) + call void @"pre_*.518"(%Token* %"$tmpC16", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %9) %10 = getelementptr inbounds %Token, %Token* %"$tmpC16", i32 0, i32 1 %11 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef18, i32 0, i32 0 %12 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef18, i32 0, i32 1 @@ -25544,24 +24873,24 @@ if_end: ; preds = %if_end4, %dumy_bloc store i8* getelementptr inbounds ([35 x i8], [35 x i8]* @str.103, i32 0, i32 34), i8** %14 %15 = load %StringRef, %StringRef* %tmp.StringRef18 store %StringRef %15, %StringRef* %"$tmpForRef17" - call void @toString.589(%String* %"$tmpC", %StringRef* %"$tmpForRef", %TokenType* %10, %StringRef* %"$tmpForRef17") - call void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC16") + call void @toString.574(%String* %"$tmpC", %StringRef* %"$tmpForRef", %TokenType* %10, %StringRef* %"$tmpForRef17") + call void @reportError.523(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC16") ret void dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_else - call void @ctor.404(%TokenType* %tmp.this5, i32 38) + call void @ctor.393(%TokenType* %tmp.this5, i32 38) %16 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %16, label %if_then2, label %if_else3 if_then2: ; preds = %if_block1 %17 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %18 = getelementptr inbounds %Token, %Token* %17, i32 0, i32 2 - call void @ctor.175(%String* %_result, %String* %18) + call void @ctor.165(%String* %_result, %String* %18) ret void if_else3: ; preds = %if_block1 @@ -25585,14 +24914,14 @@ if_then8: ; preds = %cond.end store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.101, i32 0, i32 0), i8** %22 store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.101, i32 0, i32 1), i8** %23 %24 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %_result, %StringRef %24) + call void @ctor.448(%String* %_result, %StringRef %24) br i1 %19, label %cond_destruct_alt1, label %cond_destruct_alt2 if_end9: ; preds = %dumy_block11, %cond.end br i1 %19, label %cond_destruct_alt112, label %cond_destruct_alt213 cond.true: ; preds = %if_block7 - call void @ctor.404(%TokenType* %tmp.this10, i32 36) + call void @ctor.393(%TokenType* %tmp.this10, i32 36) %25 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this10) br label %cond.end @@ -25641,12 +24970,12 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %StringRef, %StringRef* %op.addr %5 = load %Node, %Node* %base.addr - %6 = call %Node @"().602"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5) + %6 = call %Node @"().587"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5) ret %Node %6 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().602"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4) #4 { +define internal %Node @"().587"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -25679,14 +25008,14 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 37) + call void @ctor.393(%TokenType* %tmp.this, i32 37) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_else if_then: ; preds = %if_block %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 2 - call void @ctor.175(%String* %_result, %String* %3) + call void @ctor.165(%String* %_result, %String* %3) ret void if_else: ; preds = %if_block @@ -25699,14 +25028,14 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_else - call void @ctor.404(%TokenType* %tmp.this5, i32 38) + call void @ctor.393(%TokenType* %tmp.this5, i32 38) %4 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %4, label %if_then2, label %if_else3 if_then2: ; preds = %if_block1 %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %6 = getelementptr inbounds %Token, %Token* %5, i32 0, i32 2 - call void @ctor.175(%String* %_result, %String* %6) + call void @ctor.165(%String* %_result, %String* %6) ret void if_else3: ; preds = %if_block1 @@ -25730,18 +25059,18 @@ if_then8: ; preds = %cond.end store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.104, i32 0, i32 0), i8** %10 store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.104, i32 0, i32 1), i8** %11 %12 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %_result, %StringRef %12) + call void @ctor.448(%String* %_result, %StringRef %12) br i1 %7, label %cond_destruct_alt1, label %cond_destruct_alt2 if_else9: ; preds = %cond.end - call void @ctor.124(%String* %_result) + call void @ctor.114(%String* %_result) br i1 %7, label %cond_destruct_alt113, label %cond_destruct_alt214 if_end10: ; preds = %dumy_block16, %dumy_block12 br i1 %7, label %cond_destruct_alt117, label %cond_destruct_alt218 cond.true: ; preds = %if_block7 - call void @ctor.404(%TokenType* %tmp.this11, i32 36) + call void @ctor.393(%TokenType* %tmp.this11, i32 36) %13 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this11) br label %cond.end @@ -25805,12 +25134,12 @@ code: ; preds = %0 %4 = load %Node, %Node* %lhs.addr %5 = load %StringRef, %StringRef* %op.addr %6 = load %Node, %Node* %rhs.addr - %7 = call %Node @"().603"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5, %Node %6) + %7 = call %Node @"().588"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5, %Node %6) ret %Node %7 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().603"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %StringRef %p4, %Node %p5) #4 { +define internal %Node @"().588"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, StringRef, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %StringRef %p4, %Node %p5) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %Node @@ -25848,7 +25177,7 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %base.addr %5 = load %StringRef, %StringRef* %op.addr - %6 = call %Node @"().545"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) + %6 = call %Node @"().530"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %StringRef %5) ret %Node %6 } @@ -25863,15 +25192,15 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 3) + call void @ctor.393(%TokenType* %tmp.this, i32 3) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block %2 = call %Node @parseImportNames(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %2, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this1, i32 32) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this1, i32 32) %3 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) ret i1 true @@ -25891,17 +25220,17 @@ define internal %Node @parseImportNames(%"SparrowParser[SparrowLayoutDecoder[Spa br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %2 = load %Node, %Node* %res %3 = call %Node @parseImportName(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %4 = call %Node @addToNodeList(%AstBuilder* %1, %Node %2, %Node %3) store %Node %4, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") br label %while_block while_block: ; preds = %while_step, %code - call void @ctor.404(%TokenType* %tmp.this, i32 33) + call void @ctor.393(%TokenType* %tmp.this, i32 33) %5 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %5, label %while_body, label %while_end @@ -25911,7 +25240,7 @@ while_body: ; preds = %while_block %8 = call %Node @parseImportName(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %9 = call %Node @addToNodeList(%AstBuilder* %6, %Node %7, %Node %8) store %Node %9, %Node* %"$tmpForRef1" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef1") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef1") br label %while_step while_step: ; preds = %while_body @@ -25936,14 +25265,14 @@ define internal %Node @parseImportName(%"SparrowParser[SparrowLayoutDecoder[Spar code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") call void @parseIdEqualOpt(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %2 = call %Node @parseQidOrString(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %2, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %toImport, %Node* %"$tmpForRef1") + call void @ctor.520(%Node* %toImport, %Node* %"$tmpForRef1") %3 = call %Node @parseImportDeclNamesOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %3, %Node* %"$tmpForRef2" - call void @ctor.535(%Node* %declNames, %Node* %"$tmpForRef2") + call void @ctor.520(%Node* %declNames, %Node* %"$tmpForRef2") %4 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %5 = load %Location, %Location* %loc %6 = call %Location @lastLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) @@ -25952,11 +25281,11 @@ code: ; preds = %0 %9 = load %Node, %Node* %toImport %10 = load %Node, %Node* %declNames %11 = call %Node @mkImportName(%AstBuilder* %4, %Location %7, %StringRef %8, %Node %9, %Node %10) - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) ret %Node %11 dumy_block: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) unreachable } @@ -25970,21 +25299,21 @@ define internal void @parseIdEqualOpt(%String* sret %_result, %"SparrowParser[Sp br label %code code: ; preds = %0 - call void @ctor.124(%String* %id) + call void @ctor.114(%String* %id) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 37) + call void @ctor.393(%TokenType* %tmp.this, i32 37) %1 = call i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %cond.true, label %cond.false if_then: ; preds = %cond.end - call void @ctor.404(%TokenType* %tmp.this2, i32 37) + call void @ctor.393(%TokenType* %tmp.this2, i32 37) %2 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this2) %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 2 - %5 = call %String* @"=.278"(%String* %id, %String* %4) - call void @ctor.404(%TokenType* %tmp.this3, i32 36) + %5 = call %String* @"=.267"(%String* %id, %String* %4) + call void @ctor.393(%TokenType* %tmp.this3, i32 36) %6 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this3) br label %if_end @@ -25992,7 +25321,7 @@ if_end: ; preds = %if_then, %cond.end br i1 %1, label %cond_destruct_alt1, label %cond_destruct_alt2 cond.true: ; preds = %if_block - call void @ctor.404(%TokenType* %tmp.this1, i32 36) + call void @ctor.393(%TokenType* %tmp.this1, i32 36) %7 = call i1 @next2Is(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br label %cond.end @@ -26010,12 +25339,12 @@ cond_destruct_alt2: ; preds = %if_end br label %cond_destruct_end cond_destruct_end: ; preds = %cond_destruct_alt2, %cond_destruct_alt1 - call void @ctor.175(%String* %_result, %String* %id) - call void @dtor.250(%String* %id) + call void @ctor.165(%String* %_result, %String* %id) + call void @dtor.239(%String* %id) ret void dumy_block: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) ret void } @@ -26028,7 +25357,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 40) + call void @ctor.393(%TokenType* %tmp.this, i32 40) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end @@ -26060,19 +25389,19 @@ define internal %Node @parseImportDeclNamesOpt(%"SparrowParser[SparrowLayoutDeco br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 29) + call void @ctor.393(%TokenType* %tmp.this, i32 29) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block %2 = call %Node @parseIdOrOperListNode(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %2, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this1, i32 30) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this1, i32 30) %3 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br label %if_end @@ -26092,7 +25421,7 @@ define internal %Node @parseIdOrOperListNode(%"SparrowParser[SparrowLayoutDecode br label %code code: ; preds = %0 - call void @ctor.546(%Node* %res) + call void @ctor.531(%Node* %res) call void @parseIdOrOper(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) %1 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %2 = load %Node, %Node* %res @@ -26104,18 +25433,18 @@ code: ; preds = %0 %8 = call %Node @mkIdentifier(%AstBuilder* %3, %Location %6, %StringRef %7) %9 = call %Node @addToNodeList(%AstBuilder* %1, %Node %2, %Node %8) store %Node %9, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") br label %while_block while_block: ; preds = %while_step, %code - call void @ctor.404(%TokenType* %tmp.this, i32 33) + call void @ctor.393(%TokenType* %tmp.this, i32 33) %10 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %10, label %while_body, label %while_end while_body: ; preds = %while_block call void @parseIdOrOper(%String* %"$tmpC", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) - %11 = call %String* @"=.278"(%String* %id, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") + %11 = call %String* @"=.267"(%String* %id, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") %12 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %13 = load %Node, %Node* %res %14 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 @@ -26126,7 +25455,7 @@ while_body: ; preds = %while_block %19 = call %Node @mkIdentifier(%AstBuilder* %14, %Location %17, %StringRef %18) %20 = call %Node @addToNodeList(%AstBuilder* %12, %Node %13, %Node %19) store %Node %20, %Node* %"$tmpForRef1" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef1") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef1") br label %while_step while_step: ; preds = %while_body @@ -26134,11 +25463,11 @@ while_step: ; preds = %while_body while_end: ; preds = %while_block %21 = load %Node, %Node* %res - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) ret %Node %21 dumy_block: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) unreachable } @@ -26161,7 +25490,7 @@ code: ; preds = %0 %4 = load %StringRef, %StringRef* %alias.addr %5 = load %Node, %Node* %toImport.addr %6 = load %Node, %Node* %decls.addr - %7 = call %Node @"().585"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) + %7 = call %Node @"().570"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) ret %Node %7 } @@ -26181,7 +25510,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 9) + call void @ctor.393(%TokenType* %tmp.this, i32 9) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = xor i1 true, %1 br i1 %2, label %if_then, label %if_end @@ -26192,28 +25521,28 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %4) + call void @ctor.159(%Location* %loc, %Location* %4) call void @parseIdEqualOpt(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - call void @ctor.546(%Node* %usingNode) + call void @ctor.531(%Node* %usingNode) br label %if_block1 dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - %5 = call i1 @isEmpty.384(%String* %id) + %5 = call i1 @isEmpty.373(%String* %id) br i1 %5, label %if_then2, label %if_else if_then2: ; preds = %if_block1 %6 = call %Node @parseQualifiedName(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %6, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %usingNode, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %usingNode, %Node* %"$tmpForRef") br label %if_end3 if_else: ; preds = %if_block1 %7 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %7, %Node* %"$tmpForRef4" - call void @"=.544"(%Node* %usingNode, %Node* %"$tmpForRef4") + call void @"=.529"(%Node* %usingNode, %Node* %"$tmpForRef4") br label %if_end3 if_end3: ; preds = %if_else, %if_then2 @@ -26221,7 +25550,7 @@ if_end3: ; preds = %if_else, %if_then2 %9 = getelementptr inbounds %Token, %Token* %8, i32 0, i32 0 %10 = load %Location, %Location* %9 call void @copyEnd(%Location* %loc, %Location %10) - call void @ctor.404(%TokenType* %tmp.this5, i32 32) + call void @ctor.393(%TokenType* %tmp.this5, i32 32) %11 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) %12 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %13 = load %Location, %Location* %loc @@ -26229,12 +25558,12 @@ if_end3: ; preds = %if_else, %if_then2 %15 = load %Node, %Node* %usingNode %16 = call %Node @mkUsing(%AstBuilder* %12, %Location %13, %StringRef %14, %Node %15) store %Node %16, %Node* %"$tmpForRef6" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef6") - call void @dtor.250(%String* %id) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef6") + call void @dtor.239(%String* %id) ret i1 true dumy_block7: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) unreachable } @@ -26254,7 +25583,7 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %StringRef, %StringRef* %alias.addr %5 = load %Node, %Node* %usingNode.addr - %6 = call %Node @"().602"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5) + %6 = call %Node @"().587"(%"FunctionPtr4[Node, UntypedPtr, Location const, StringRef, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5) ret %Node %6 } @@ -26277,7 +25606,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 8) + call void @ctor.393(%TokenType* %tmp.this, i32 8) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = xor i1 true, %1 br i1 %2, label %if_then, label %if_end @@ -26288,19 +25617,19 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %4) + call void @ctor.159(%Location* %loc, %Location* %4) call void @parseId(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %5 = call %Node @parseFormalsOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %5, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %formals, %Node* %"$tmpForRef") + call void @ctor.520(%Node* %formals, %Node* %"$tmpForRef") %6 = call %Node @parseIfClauseOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %6, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %ifClause, %Node* %"$tmpForRef1") - call void @ctor.404(%TokenType* %tmp.this2, i32 25) + call void @ctor.520(%Node* %ifClause, %Node* %"$tmpForRef1") + call void @ctor.393(%TokenType* %tmp.this2, i32 25) %7 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this2) - call void @ctor.546(%Node* %children) + call void @ctor.531(%Node* %children) call void @parseStmts(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true, %Node* %children) - call void @ctor.404(%TokenType* %tmp.this3, i32 26) + call void @ctor.393(%TokenType* %tmp.this3, i32 26) %8 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this3) %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %10 = getelementptr inbounds %Token, %Token* %9, i32 0, i32 0 @@ -26314,15 +25643,15 @@ if_end: ; preds = %dumy_block, %if_blo %17 = load %Node, %Node* %ifClause %18 = call %Node @mkPackage(%AstBuilder* %12, %Location %13, %StringRef %14, %Node %15, %Node %16, %Node %17) store %Node %18, %Node* %"$tmpForRef4" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef4") - call void @dtor.250(%String* %id) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef4") + call void @dtor.239(%String* %id) ret i1 true dumy_block: ; No predecessors! br label %if_end dumy_block5: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) unreachable } @@ -26336,7 +25665,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 16) + call void @ctor.393(%TokenType* %tmp.this, i32 16) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end @@ -26345,7 +25674,7 @@ if_then: ; preds = %if_block ret %Node %2 if_end: ; preds = %dumy_block, %if_block - call void @ctor.546(%Node* %tmp.this1) + call void @ctor.531(%Node* %tmp.this1) %3 = load %Node, %Node* %tmp.this1 ret %Node %3 @@ -26375,12 +25704,12 @@ code: ; preds = %0 %5 = load %Node, %Node* %children.addr %6 = load %Node, %Node* %params.addr %7 = load %Node, %Node* %ifClause.addr - %8 = call %Node @"().604"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7) + %8 = call %Node @"().589"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7) ret %Node %8 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().604"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5, %Node %p6) #4 { +define internal %Node @"().589"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5, %Node %p6) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -26442,7 +25771,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 5) + call void @ctor.393(%TokenType* %tmp.this, i32 5) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = xor i1 true, %1 br i1 %2, label %if_then, label %if_end @@ -26453,29 +25782,29 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %4) + call void @ctor.159(%Location* %loc, %Location* %4) call void @parseId(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %5 = call %Node @parseFormalsOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %5, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %formals, %Node* %"$tmpForRef") + call void @ctor.520(%Node* %formals, %Node* %"$tmpForRef") br label %if_block1 dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - call void @ctor.404(%TokenType* %tmp.this4, i32 36) + call void @ctor.393(%TokenType* %tmp.this4, i32 36) %6 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this4) br i1 %6, label %if_then2, label %if_else if_then2: ; preds = %if_block1 %7 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %7, %Node* %"$tmpForRef5" - call void @ctor.535(%Node* %underlyingData, %Node* %"$tmpForRef5") + call void @ctor.520(%Node* %underlyingData, %Node* %"$tmpForRef5") %8 = call %Node @parseIfClauseOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %8, %Node* %"$tmpForRef6" - call void @ctor.535(%Node* %ifClause, %Node* %"$tmpForRef6") - call void @ctor.404(%TokenType* %tmp.this7, i32 32) + call void @ctor.520(%Node* %ifClause, %Node* %"$tmpForRef6") + call void @ctor.393(%TokenType* %tmp.this7, i32 32) %9 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this7) %10 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %11 = getelementptr inbounds %Token, %Token* %10, i32 0, i32 0 @@ -26487,26 +25816,26 @@ if_then2: ; preds = %if_block1 %16 = load %Node, %Node* %formals %17 = load %Node, %Node* %underlyingData %18 = load %Node, %Node* %ifClause - call void @ctor.546(%Node* %tmp.this9) + call void @ctor.531(%Node* %tmp.this9) %19 = load %Node, %Node* %tmp.this9 %20 = call %Node @mkDatatype(%AstBuilder* %13, %Location %14, %StringRef %15, %Node %16, %Node %17, %Node %18, %Node %19) store %Node %20, %Node* %"$tmpForRef8" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef8") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef8") br label %if_end3 if_else: ; preds = %if_block1 %21 = call %Node @parseIfClauseOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %21, %Node* %"$tmpForRef11" - call void @ctor.535(%Node* %ifClause10, %Node* %"$tmpForRef11") - call void @ctor.546(%Node* %children) + call void @ctor.520(%Node* %ifClause10, %Node* %"$tmpForRef11") + call void @ctor.531(%Node* %children) br label %if_block12 if_end3: ; preds = %if_end15, %if_then2 - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) ret i1 true if_block12: ; preds = %if_else - call void @ctor.404(%TokenType* %tmp.this16, i32 32) + call void @ctor.393(%TokenType* %tmp.this16, i32 32) %22 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this16) br i1 %22, label %if_then13, label %if_else14 @@ -26514,7 +25843,7 @@ if_then13: ; preds = %if_block12 br label %if_end15 if_else14: ; preds = %if_block12 - call void @ctor.404(%TokenType* %tmp.this17, i32 25) + call void @ctor.393(%TokenType* %tmp.this17, i32 25) %23 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this17) br label %while_block @@ -26527,17 +25856,17 @@ if_end15: ; preds = %while_end, %if_then %28 = load %Location, %Location* %loc %29 = call %StringRef @asStringRef(%String* %id) %30 = load %Node, %Node* %formals - call void @ctor.546(%Node* %tmp.this54) + call void @ctor.531(%Node* %tmp.this54) %31 = load %Node, %Node* %tmp.this54 %32 = load %Node, %Node* %ifClause10 %33 = load %Node, %Node* %children %34 = call %Node @mkDatatype(%AstBuilder* %27, %Location %28, %StringRef %29, %Node %30, %Node %31, %Node %32, %Node %33) store %Node %34, %Node* %"$tmpForRef53" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef53") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef53") br label %if_end3 while_block: ; preds = %while_step, %if_else14 - call void @ctor.404(%TokenType* %tmp.this18, i32 26) + call void @ctor.393(%TokenType* %tmp.this18, i32 26) %35 = call i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this18) %36 = xor i1 true, %35 br i1 %36, label %cond.true, label %cond.false @@ -26549,7 +25878,7 @@ while_step: ; preds = %cond_destruct_end51 br label %while_block while_end: ; preds = %if_then30, %cond.end - call void @ctor.404(%TokenType* %tmp.this52, i32 26) + call void @ctor.393(%TokenType* %tmp.this52, i32 26) %37 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this52) br label %if_end15 @@ -26567,7 +25896,7 @@ cond.end: ; preds = %cond.false, %cond.t br i1 %cond.res, label %while_body, label %while_end while_block19: ; preds = %while_step21, %while_body - call void @ctor.404(%TokenType* %tmp.this26, i32 33) + call void @ctor.393(%TokenType* %tmp.this26, i32 33) %41 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this26) br i1 %41, label %cond.true23, label %cond.false24 @@ -26584,7 +25913,7 @@ cond.true23: ; preds = %while_block19 br label %cond.end25 cond.false24: ; preds = %while_block19 - call void @ctor.404(%TokenType* %tmp.this27, i32 32) + call void @ctor.393(%TokenType* %tmp.this27, i32 32) %42 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this27) br label %cond.end25 @@ -26602,7 +25931,7 @@ cond_destruct_end: ; preds = %cond_destruct_alt2, br label %if_block29 if_block29: ; preds = %cond_destruct_end - call void @ctor.404(%TokenType* %tmp.this32, i32 26) + call void @ctor.393(%TokenType* %tmp.this32, i32 26) %43 = call i1 @nextIs(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this32) br i1 %43, label %if_then30, label %if_end31 @@ -26610,7 +25939,7 @@ if_then30: ; preds = %if_block29 br label %while_end if_end31: ; preds = %dumy_block33, %if_block29 - call void @ctor.546(%Node* %usingNode) + call void @ctor.531(%Node* %usingNode) br label %if_block34 dumy_block33: ; No predecessors! @@ -26626,7 +25955,7 @@ if_then35: ; preds = %if_block34 %47 = load %Node, %Node* %usingNode %48 = call %Node @addToNodeList(%AstBuilder* %45, %Node %46, %Node %47) store %Node %48, %Node* %"$tmpForRef38" - call void @"=.544"(%Node* %children, %Node* %"$tmpForRef38") + call void @"=.529"(%Node* %children, %Node* %"$tmpForRef38") br label %if_end37 if_else36: ; preds = %if_block34 @@ -26637,7 +25966,7 @@ if_end37: ; preds = %if_else36, %if_then br label %while_block39 while_block39: ; preds = %while_step41, %if_end37 - call void @ctor.404(%TokenType* %tmp.this46, i32 33) + call void @ctor.393(%TokenType* %tmp.this46, i32 33) %49 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this46) br i1 %49, label %cond.true43, label %cond.false44 @@ -26654,7 +25983,7 @@ cond.true43: ; preds = %while_block39 br label %cond.end45 cond.false44: ; preds = %while_block39 - call void @ctor.404(%TokenType* %tmp.this47, i32 32) + call void @ctor.393(%TokenType* %tmp.this47, i32 32) %50 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this47) br label %cond.end45 @@ -26672,7 +26001,7 @@ cond_destruct_end51: ; preds = %cond_destruct_alt25 br label %while_step dumy_block55: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) unreachable } @@ -26701,12 +26030,12 @@ code: ; preds = %0 %6 = load %Node, %Node* %underlyingData.addr %7 = load %Node, %Node* %ifClause.addr %8 = load %Node, %Node* %children.addr - %9 = call %Node @"().605"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7, %Node %8) + %9 = call %Node @"().590"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7, %Node %8) ret %Node %9 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().605"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5, %Node %p6, %Node %p7) #4 { +define internal %Node @"().590"(%"FunctionPtr7[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5, %Node %p6, %Node %p7) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -26753,39 +26082,39 @@ define internal void @parseFieldsLine(%"SparrowParser[SparrowLayoutDecoder[Sparr code: ; preds = %0 call void @parseIdList(%"Vector[LocString]"* %ids, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - call void @ctor.404(%TokenType* %tmp.this, i32 31) + call void @ctor.393(%TokenType* %tmp.this, i32 31) %1 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 false) store %Node %2, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %typeNode, %Node* %"$tmpForRef") - call void @ctor.546(%Node* %init) + call void @ctor.520(%Node* %typeNode, %Node* %"$tmpForRef") + call void @ctor.531(%Node* %init) br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this1, i32 36) + call void @ctor.393(%TokenType* %tmp.this1, i32 36) %3 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) br i1 %3, label %if_then, label %if_end if_then: ; preds = %if_block %4 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %4, %Node* %"$tmpForRef2" - call void @"=.544"(%Node* %init, %Node* %"$tmpForRef2") + call void @"=.529"(%Node* %init, %Node* %"$tmpForRef2") br label %if_end if_end: ; preds = %if_then, %if_block - %5 = call %"ContiguousMemoryRange[LocString]" @all.581(%"Vector[LocString]"* %ids) + %5 = call %"ContiguousMemoryRange[LocString]" @all.566(%"Vector[LocString]"* %ids) store %"ContiguousMemoryRange[LocString]" %5, %"ContiguousMemoryRange[LocString]"* %"$tmpForRef3" - call void @ctor.580(%"ContiguousMemoryRange[LocString]"* %"$rangeVar", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef3") + call void @ctor.565(%"ContiguousMemoryRange[LocString]"* %"$rangeVar", %"ContiguousMemoryRange[LocString]"* %"$tmpForRef3") br label %while_block while_block: ; preds = %while_step, %if_end - %6 = call i1 @isEmpty.583(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") + %6 = call i1 @isEmpty.568(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") %7 = xor i1 true, %6 br i1 %7, label %while_body, label %while_end while_body: ; preds = %while_block - %8 = call %LocString* @front.584(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") - call void @ctor.565(%LocString* %id, %LocString* %8) + %8 = call %LocString* @front.569(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") + call void @ctor.550(%LocString* %id, %LocString* %8) %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %10 = getelementptr inbounds %LocString, %LocString* %id, i32 0, i32 0 %11 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %10, i32 0, i32 0 @@ -26797,22 +26126,22 @@ while_body: ; preds = %while_block %17 = load %Node, %Node* %init %18 = call %Node @mkField(%AstBuilder* %9, %Location %12, %StringRef %15, %Node %16, %Node %17) store %Node %18, %Node* %"$tmpForRef4" - call void @ctor.535(%Node* %v, %Node* %"$tmpForRef4") + call void @ctor.520(%Node* %v, %Node* %"$tmpForRef4") %19 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %20 = load %Node, %Node* %res %21 = load %Node, %Node* %v %22 = call %Node @addToNodeList(%AstBuilder* %19, %Node %20, %Node %21) store %Node %22, %Node* %"$tmpForRef5" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef5") - call void @dtor.571(%LocString* %id) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef5") + call void @dtor.556(%LocString* %id) br label %while_step while_step: ; preds = %while_body - call void @popFront.586(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") + call void @popFront.571(%"ContiguousMemoryRange[LocString]"* %"$rangeVar") br label %while_block while_end: ; preds = %while_block - call void @dtor.577(%"Vector[LocString]"* %ids) + call void @dtor.562(%"Vector[LocString]"* %ids) ret void } @@ -26835,7 +26164,7 @@ code: ; preds = %0 %4 = load %StringRef, %StringRef* %name.addr %5 = load %Node, %Node* %typeNode.addr %6 = load %Node, %Node* %init.addr - %7 = call %Node @"().585"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) + %7 = call %Node @"().570"(%"FunctionPtr5[Node, UntypedPtr, Location const, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6) ret %Node %7 } @@ -26859,7 +26188,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 4) + call void @ctor.393(%TokenType* %tmp.this, i32 4) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = xor i1 true, %1 br i1 %2, label %if_then, label %if_end @@ -26870,20 +26199,20 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %4) + call void @ctor.159(%Location* %loc, %Location* %4) call void @parseId(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - call void @ctor.404(%TokenType* %tmp.this1, i32 29) + call void @ctor.393(%TokenType* %tmp.this1, i32 29) %5 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) call void @parseId(%String* %paramName, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %6 = call %Node @parseTypeNode(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %6, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %baseConcept, %Node* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this2, i32 30) + call void @ctor.520(%Node* %baseConcept, %Node* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this2, i32 30) %7 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this2) %8 = call %Node @parseIfClauseOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %8, %Node* %"$tmpForRef3" - call void @ctor.535(%Node* %ifClause, %Node* %"$tmpForRef3") - call void @ctor.404(%TokenType* %tmp.this4, i32 32) + call void @ctor.520(%Node* %ifClause, %Node* %"$tmpForRef3") + call void @ctor.393(%TokenType* %tmp.this4, i32 32) %9 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this4) %10 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %11 = getelementptr inbounds %Token, %Token* %10, i32 0, i32 0 @@ -26897,17 +26226,17 @@ if_end: ; preds = %dumy_block, %if_blo %18 = load %Node, %Node* %ifClause %19 = call %Node @mkConcept(%AstBuilder* %13, %Location %14, %StringRef %15, %StringRef %16, %Node %17, %Node %18) store %Node %19, %Node* %"$tmpForRef5" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef5") - call void @dtor.250(%String* %paramName) - call void @dtor.250(%String* %id) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef5") + call void @dtor.239(%String* %paramName) + call void @dtor.239(%String* %id) ret i1 true dumy_block: ; No predecessors! br label %if_end dumy_block6: ; No predecessors! - call void @dtor.250(%String* %paramName) - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %paramName) + call void @dtor.239(%String* %id) unreachable } @@ -26933,12 +26262,12 @@ code: ; preds = %0 %5 = load %StringRef, %StringRef* %paramName.addr %6 = load %Node, %Node* %baseConcept.addr %7 = load %Node, %Node* %ifClause.addr - %8 = call %Node @"().606"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %StringRef %5, %Node %6, %Node %7) + %8 = call %Node @"().591"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %StringRef %5, %Node %6, %Node %7) ret %Node %8 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().606"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %StringRef %p4, %Node %p5, %Node %p6) #4 { +define internal %Node @"().591"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, StringRef, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %StringRef %p4, %Node %p5, %Node %p6) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -26985,7 +26314,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 7) + call void @ctor.393(%TokenType* %tmp.this, i32 7) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_else @@ -26998,12 +26327,12 @@ if_else: ; preds = %if_block if_end: ; preds = %if_end4, %if_then call void @parseIdList(%"Vector[LocString]"* %ids, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - call void @ctor.546(%Node* %typeNode) - call void @ctor.546(%Node* %init) + call void @ctor.531(%Node* %typeNode) + call void @ctor.531(%Node* %init) br label %if_block6 if_block1: ; preds = %if_else - call void @ctor.404(%TokenType* %tmp.this5, i32 10) + call void @ctor.393(%TokenType* %tmp.this5, i32 10) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %2, label %if_then2, label %if_else3 @@ -27021,51 +26350,51 @@ dumy_block: ; No predecessors! br label %if_end4 if_block6: ; preds = %if_end - call void @ctor.404(%TokenType* %tmp.this10, i32 31) + call void @ctor.393(%TokenType* %tmp.this10, i32 31) %3 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this10) br i1 %3, label %if_then7, label %if_else8 if_then7: ; preds = %if_block6 %4 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 false) store %Node %4, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %typeNode, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %typeNode, %Node* %"$tmpForRef") br label %if_block11 if_else8: ; preds = %if_block6 - call void @ctor.404(%TokenType* %tmp.this16, i32 36) + call void @ctor.393(%TokenType* %tmp.this16, i32 36) %5 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this16) %6 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %6, %Node* %"$tmpForRef17" - call void @"=.544"(%Node* %init, %Node* %"$tmpForRef17") + call void @"=.529"(%Node* %init, %Node* %"$tmpForRef17") br label %if_end9 if_end9: ; preds = %if_else8, %if_end13 - call void @ctor.404(%TokenType* %tmp.this18, i32 32) + call void @ctor.393(%TokenType* %tmp.this18, i32 32) %7 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this18) %8 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %9 = load %Node, %Node* %typeNode %10 = load %Node, %Node* %init %11 = load i32, i32* %kind call void @createFormals(%AstBuilder* %8, %"Vector[LocString]"* %ids, %Node %9, %Node %10, i32 %11, %Node* %res) - call void @dtor.577(%"Vector[LocString]"* %ids) + call void @dtor.562(%"Vector[LocString]"* %ids) ret i1 true if_block11: ; preds = %if_then7 - call void @ctor.404(%TokenType* %tmp.this14, i32 36) + call void @ctor.393(%TokenType* %tmp.this14, i32 36) %12 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this14) br i1 %12, label %if_then12, label %if_end13 if_then12: ; preds = %if_block11 %13 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %13, %Node* %"$tmpForRef15" - call void @"=.544"(%Node* %init, %Node* %"$tmpForRef15") + call void @"=.529"(%Node* %init, %Node* %"$tmpForRef15") br label %if_end13 if_end13: ; preds = %if_then12, %if_block11 br label %if_end9 dumy_block19: ; No predecessors! - call void @dtor.577(%"Vector[LocString]"* %ids) + call void @dtor.562(%"Vector[LocString]"* %ids) unreachable } @@ -27094,7 +26423,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 6) + call void @ctor.393(%TokenType* %tmp.this, i32 6) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) %2 = xor i1 true, %1 br i1 %2, label %if_then, label %if_end @@ -27105,45 +26434,45 @@ if_then: ; preds = %if_block if_end: ; preds = %dumy_block, %if_block %3 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %4 = getelementptr inbounds %Token, %Token* %3, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %4) + call void @ctor.159(%Location* %loc, %Location* %4) call void @parseFunNameString(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) %5 = call %Node @parseFormalsOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %5, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %formals, %Node* %"$tmpForRef") + call void @ctor.520(%Node* %formals, %Node* %"$tmpForRef") %6 = call %Node @parseTypeNode(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %6, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %retType, %Node* %"$tmpForRef1") - call void @ctor.546(%Node* %body) - call void @ctor.546(%Node* %bodyExp) - call void @ctor.546(%Node* %ifClause) + call void @ctor.520(%Node* %retType, %Node* %"$tmpForRef1") + call void @ctor.531(%Node* %body) + call void @ctor.531(%Node* %bodyExp) + call void @ctor.531(%Node* %ifClause) br label %if_block2 dumy_block: ; No predecessors! br label %if_end if_block2: ; preds = %if_end - call void @ctor.404(%TokenType* %tmp.this5, i32 36) + call void @ctor.393(%TokenType* %tmp.this5, i32 36) %7 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %7, label %if_then3, label %if_else if_then3: ; preds = %if_block2 %8 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %8, %Node* %"$tmpForRef6" - call void @"=.544"(%Node* %bodyExp, %Node* %"$tmpForRef6") + call void @"=.529"(%Node* %bodyExp, %Node* %"$tmpForRef6") %9 = call %Node @parseIfClauseOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %9, %Node* %"$tmpForRef7" - call void @"=.544"(%Node* %ifClause, %Node* %"$tmpForRef7") - call void @ctor.404(%TokenType* %tmp.this8, i32 32) + call void @"=.529"(%Node* %ifClause, %Node* %"$tmpForRef7") + call void @ctor.393(%TokenType* %tmp.this8, i32 32) %10 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this8) br label %if_end4 if_else: ; preds = %if_block2 %11 = call %Node @parseIfClauseOpt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %11, %Node* %"$tmpForRef9" - call void @"=.544"(%Node* %ifClause, %Node* %"$tmpForRef9") + call void @"=.529"(%Node* %ifClause, %Node* %"$tmpForRef9") %12 = call %Node @parseFunBody(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Node %12, %Node* %"$tmpForRef10" - call void @"=.544"(%Node* %body, %Node* %"$tmpForRef10") + call void @"=.529"(%Node* %body, %Node* %"$tmpForRef10") br label %if_end4 if_end4: ; preds = %if_else, %if_then3 @@ -27161,12 +26490,12 @@ if_end4: ; preds = %if_else, %if_then3 %23 = load %Node, %Node* %ifClause %24 = call %Node @mkFun(%AstBuilder* %16, %Location %17, %StringRef %18, %Node %19, %Node %20, %Node %21, %Node %22, %Node %23) store %Node %24, %Node* %"$tmpForRef11" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef11") - call void @dtor.250(%String* %id) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef11") + call void @dtor.239(%String* %id) ret i1 true dumy_block12: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) unreachable } @@ -27183,7 +26512,7 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 34) + call void @ctor.393(%TokenType* %tmp.this, i32 34) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end @@ -27195,7 +26524,7 @@ if_then: ; preds = %if_block store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.105, i32 0, i32 0), i8** %4 store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @str.105, i32 0, i32 1), i8** %5 %6 = load %StringRef, %StringRef* %tmp.StringRef - call void @ctor.459(%String* %_result, %StringRef %6) + call void @ctor.448(%String* %_result, %StringRef %6) ret void if_end: ; preds = %dumy_block, %if_block @@ -27205,12 +26534,12 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - call void @ctor.404(%TokenType* %tmp.this4, i32 29) + call void @ctor.393(%TokenType* %tmp.this4, i32 29) %7 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this4) br i1 %7, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 - call void @ctor.404(%TokenType* %tmp.this5, i32 30) + call void @ctor.393(%TokenType* %tmp.this5, i32 30) %8 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) %9 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef6, i32 0, i32 0 %10 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef6, i32 0, i32 1 @@ -27219,7 +26548,7 @@ if_then2: ; preds = %if_block1 store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str.106, i32 0, i32 0), i8** %11 store i8* getelementptr inbounds ([3 x i8], [3 x i8]* @str.106, i32 0, i32 2), i8** %12 %13 = load %StringRef, %StringRef* %tmp.StringRef6 - call void @ctor.459(%String* %_result, %StringRef %13) + call void @ctor.448(%String* %_result, %StringRef %13) ret void if_end3: ; preds = %dumy_block7, %if_block1 @@ -27258,12 +26587,12 @@ code: ; preds = %0 %7 = load %Node, %Node* %body.addr %8 = load %Node, %Node* %bodyExp.addr %9 = load %Node, %Node* %ifClause.addr - %10 = call %Node @"().607"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7, %Node %8, %Node %9) + %10 = call %Node @"().592"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7, %Node %8, %Node %9) ret %Node %10 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().607"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5, %Node %p6, %Node %p7, %Node %p8) #4 { +define internal %Node @"().592"(%"FunctionPtr8[Node, UntypedPtr, Location const, StringRef, Node, Node, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %StringRef %p3, %Node %p4, %Node %p5, %Node %p6, %Node %p7, %Node %p8) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %StringRef @@ -27323,30 +26652,30 @@ define internal i1 @parseIfStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScan code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 16) + call void @ctor.393(%TokenType* %tmp.this, i32 16) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %2, label %if_then, label %if_end if_then: ; preds = %if_block %3 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %3, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %expr, %Node* %"$tmpForRef1") + call void @ctor.520(%Node* %expr, %Node* %"$tmpForRef1") %4 = load i1, i1* %topLevel.addr %5 = call %Node @parseStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %4) store %Node %5, %Node* %"$tmpForRef2" - call void @ctor.535(%Node* %thenClause, %Node* %"$tmpForRef2") - call void @ctor.546(%Node* %elseClause) + call void @ctor.520(%Node* %thenClause, %Node* %"$tmpForRef2") + call void @ctor.531(%Node* %elseClause) br label %if_block3 if_end: ; preds = %dumy_block, %if_block ret i1 false if_block3: ; preds = %if_then - call void @ctor.404(%TokenType* %tmp.this6, i32 24) + call void @ctor.393(%TokenType* %tmp.this6, i32 24) %6 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this6) br i1 %6, label %if_then4, label %if_end5 @@ -27354,7 +26683,7 @@ if_then4: ; preds = %if_block3 %7 = load i1, i1* %topLevel.addr %8 = call %Node @parseStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %7) store %Node %8, %Node* %"$tmpForRef7" - call void @"=.544"(%Node* %elseClause, %Node* %"$tmpForRef7") + call void @"=.529"(%Node* %elseClause, %Node* %"$tmpForRef7") br label %if_end5 if_end5: ; preds = %if_then4, %if_block3 @@ -27369,7 +26698,7 @@ if_end5: ; preds = %if_then4, %if_block %16 = load %Node, %Node* %elseClause %17 = call %Node @mkIfStmt(%AstBuilder* %12, %Location %13, %Node %14, %Node %15, %Node %16) store %Node %17, %Node* %"$tmpForRef8" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef8") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef8") ret i1 true dumy_block: ; No predecessors! @@ -27395,12 +26724,12 @@ code: ; preds = %0 %4 = load %Node, %Node* %expr.addr %5 = load %Node, %Node* %thenClause.addr %6 = load %Node, %Node* %elseClause.addr - %7 = call %Node @"().608"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5, %Node %6) + %7 = call %Node @"().593"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5, %Node %6) ret %Node %7 } ; Function Attrs: inlinehint nounwind -define internal %Node @"().608"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %Node %p4, %Node %p5) #4 { +define internal %Node @"().593"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %this, %UntypedPtr %p1, %Location* %p2, %Node %p3, %Node %p4, %Node %p5) #4 { %p1.addr = alloca %UntypedPtr store %UntypedPtr %p1, %UntypedPtr* %p1.addr %p3.addr = alloca %Node @@ -27444,43 +26773,43 @@ define internal i1 @parseForStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowSca code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 15) + call void @ctor.393(%TokenType* %tmp.this, i32 15) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %2, label %if_then, label %if_end if_then: ; preds = %if_block call void @parseId(%String* %id, %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) - call void @ctor.546(%Node* %typeNode) + call void @ctor.531(%Node* %typeNode) br label %if_block1 if_end: ; preds = %dumy_block, %if_block ret i1 false if_block1: ; preds = %if_then - call void @ctor.404(%TokenType* %tmp.this4, i32 31) + call void @ctor.393(%TokenType* %tmp.this4, i32 31) %3 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this4) br i1 %3, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 %4 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 false) store %Node %4, %Node* %"$tmpForRef5" - call void @"=.544"(%Node* %typeNode, %Node* %"$tmpForRef5") + call void @"=.529"(%Node* %typeNode, %Node* %"$tmpForRef5") br label %if_end3 if_end3: ; preds = %if_then2, %if_block1 - call void @ctor.404(%TokenType* %tmp.this6, i32 36) + call void @ctor.393(%TokenType* %tmp.this6, i32 36) %5 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this6) %6 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %6, %Node* %"$tmpForRef7" - call void @ctor.535(%Node* %range, %Node* %"$tmpForRef7") + call void @ctor.520(%Node* %range, %Node* %"$tmpForRef7") %7 = load i1, i1* %topLevel.addr %8 = call %Node @parseStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %7) store %Node %8, %Node* %"$tmpForRef8" - call void @ctor.535(%Node* %action, %Node* %"$tmpForRef8") + call void @ctor.520(%Node* %action, %Node* %"$tmpForRef8") %9 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %10 = getelementptr inbounds %Token, %Token* %9, i32 0, i32 0 %11 = load %Location, %Location* %10 @@ -27493,12 +26822,12 @@ if_end3: ; preds = %if_then2, %if_block %17 = load %Node, %Node* %action %18 = call %Node @mkForStmt(%AstBuilder* %12, %Location %13, %StringRef %14, %Node %15, %Node %16, %Node %17) store %Node %18, %Node* %"$tmpForRef9" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef9") - call void @dtor.250(%String* %id) + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef9") + call void @dtor.239(%String* %id) ret i1 true dumy_block: ; No predecessors! - call void @dtor.250(%String* %id) + call void @dtor.239(%String* %id) br label %if_end } @@ -27524,7 +26853,7 @@ code: ; preds = %0 %5 = load %Node, %Node* %typeNode.addr %6 = load %Node, %Node* %range.addr %7 = load %Node, %Node* %action.addr - %8 = call %Node @"().604"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7) + %8 = call %Node @"().589"(%"FunctionPtr6[Node, UntypedPtr, Location const, StringRef, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4, %Node %5, %Node %6, %Node %7) ret %Node %8 } @@ -27553,26 +26882,26 @@ define internal i1 @parseWhileStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowS code: ; preds = %0 %1 = call %Location @curLoc(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this) store %Location %1, %Location* %"$tmpForRef" - call void @ctor.169(%Location* %loc, %Location* %"$tmpForRef") + call void @ctor.159(%Location* %loc, %Location* %"$tmpForRef") br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 20) + call void @ctor.393(%TokenType* %tmp.this, i32 20) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %2, label %if_then, label %if_end if_then: ; preds = %if_block %3 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %3, %Node* %"$tmpForRef1" - call void @ctor.535(%Node* %expr, %Node* %"$tmpForRef1") - call void @ctor.546(%Node* %stepAction) + call void @ctor.520(%Node* %expr, %Node* %"$tmpForRef1") + call void @ctor.531(%Node* %stepAction) br label %if_block2 if_end: ; preds = %dumy_block, %if_block ret i1 false if_block2: ; preds = %if_then - call void @ctor.404(%TokenType* %tmp.this5, i32 32) + call void @ctor.393(%TokenType* %tmp.this5, i32 32) %4 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this5) br i1 %4, label %if_then3, label %if_end4 @@ -27583,7 +26912,7 @@ if_end4: ; preds = %if_end8, %if_block2 %5 = load i1, i1* %topLevel.addr %6 = call %Node @parseStmt(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 %5) store %Node %6, %Node* %"$tmpForRef13" - call void @ctor.535(%Node* %body, %Node* %"$tmpForRef13") + call void @ctor.520(%Node* %body, %Node* %"$tmpForRef13") %7 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %8 = getelementptr inbounds %Token, %Token* %7, i32 0, i32 0 %9 = load %Location, %Location* %8 @@ -27595,7 +26924,7 @@ if_end4: ; preds = %if_end8, %if_block2 %14 = load %Node, %Node* %body %15 = call %Node @mkWhileStmt(%AstBuilder* %10, %Location %11, %Node %12, %Node %13, %Node %14) store %Node %15, %Node* %"$tmpForRef14" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef14") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef14") ret i1 true if_block6: ; preds = %if_then3 @@ -27613,7 +26942,7 @@ if_then7: ; preds = %cond.end %22 = load %StringRef, %StringRef* %tmp.StringRef store %StringRef %22, %StringRef* %"$tmpForRef9" %23 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 0 - call void @"pre_*.533"(%Token* %"$tmpC10", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %23) + call void @"pre_*.518"(%Token* %"$tmpC10", %"RangeWithLookahead[SparrowLayoutDecoder[SparrowScanner]]"* %23) %24 = getelementptr inbounds %Token, %Token* %"$tmpC10", i32 0, i32 1 %25 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef12, i32 0, i32 0 %26 = getelementptr inbounds %StringRef, %StringRef* %tmp.StringRef12, i32 0, i32 1 @@ -27623,10 +26952,10 @@ if_then7: ; preds = %cond.end store i8* getelementptr inbounds ([42 x i8], [42 x i8]* @str.108, i32 0, i32 41), i8** %28 %29 = load %StringRef, %StringRef* %tmp.StringRef12 store %StringRef %29, %StringRef* %"$tmpForRef11" - call void @toString.589(%String* %"$tmpC", %StringRef* %"$tmpForRef9", %TokenType* %24, %StringRef* %"$tmpForRef11") - call void @reportError.538(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") - call void @dtor.250(%String* %"$tmpC") - call void @dtor.249(%Token* %"$tmpC10") + call void @toString.574(%String* %"$tmpC", %StringRef* %"$tmpForRef9", %TokenType* %24, %StringRef* %"$tmpForRef11") + call void @reportError.523(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") + call void @dtor.238(%Token* %"$tmpC10") br label %if_end8 if_end8: ; preds = %if_then7, %cond.end @@ -27668,7 +26997,7 @@ code: ; preds = %0 %4 = load %Node, %Node* %expr.addr %5 = load %Node, %Node* %stepAction.addr %6 = load %Node, %Node* %body.addr - %7 = call %Node @"().608"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5, %Node %6) + %7 = call %Node @"().593"(%"FunctionPtr5[Node, UntypedPtr, Location const, Node, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5, %Node %6) ret %Node %7 } @@ -27684,21 +27013,21 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 11) + call void @ctor.393(%TokenType* %tmp.this, i32 11) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %3) - call void @ctor.404(%TokenType* %tmp.this1, i32 32) + call void @ctor.159(%Location* %loc, %Location* %3) + call void @ctor.393(%TokenType* %tmp.this1, i32 32) %4 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %6 = load %Location, %Location* %loc %7 = call %Node @mkBreakStmt(%AstBuilder* %5, %Location %6) store %Node %7, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") ret i1 true if_end: ; preds = %dumy_block, %if_block @@ -27718,7 +27047,7 @@ code: ; preds = %0 %1 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 38 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 - %4 = call %Node @"().592"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %1, %UntypedPtr %3, %Location* %loc.addr) + %4 = call %Node @"().577"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %1, %UntypedPtr %3, %Location* %loc.addr) ret %Node %4 } @@ -27734,21 +27063,21 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 13) + call void @ctor.393(%TokenType* %tmp.this, i32 13) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %3) - call void @ctor.404(%TokenType* %tmp.this1, i32 32) + call void @ctor.159(%Location* %loc, %Location* %3) + call void @ctor.393(%TokenType* %tmp.this1, i32 32) %4 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) %5 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 3 %6 = load %Location, %Location* %loc %7 = call %Node @mkContinueStmt(%AstBuilder* %5, %Location %6) store %Node %7, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef") ret i1 true if_end: ; preds = %dumy_block, %if_block @@ -27768,7 +27097,7 @@ code: ; preds = %0 %1 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 39 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 - %4 = call %Node @"().592"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %1, %UntypedPtr %3, %Location* %loc.addr) + %4 = call %Node @"().577"(%"FunctionPtr2[Node, UntypedPtr, Location const]"* %1, %UntypedPtr %3, %Location* %loc.addr) ret %Node %4 } @@ -27787,30 +27116,30 @@ code: ; preds = %0 br label %if_block if_block: ; preds = %code - call void @ctor.404(%TokenType* %tmp.this, i32 17) + call void @ctor.393(%TokenType* %tmp.this, i32 17) %1 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) br i1 %1, label %if_then, label %if_end if_then: ; preds = %if_block %2 = getelementptr inbounds %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]", %"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i32 0, i32 1 %3 = getelementptr inbounds %Token, %Token* %2, i32 0, i32 0 - call void @ctor.169(%Location* %loc, %Location* %3) - call void @ctor.546(%Node* %expr) + call void @ctor.159(%Location* %loc, %Location* %3) + call void @ctor.531(%Node* %expr) br label %if_block1 if_end: ; preds = %dumy_block, %if_block ret i1 false if_block1: ; preds = %if_then - call void @ctor.404(%TokenType* %tmp.this3, i32 32) + call void @ctor.393(%TokenType* %tmp.this3, i32 32) %4 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this3) br i1 %4, label %if_end2, label %if_else if_else: ; preds = %if_block1 %5 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %5, %Node* %"$tmpForRef" - call void @"=.544"(%Node* %expr, %Node* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this4, i32 32) + call void @"=.529"(%Node* %expr, %Node* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this4, i32 32) %6 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this4) br label %if_end2 @@ -27820,7 +27149,7 @@ if_end2: ; preds = %if_else, %if_block1 %9 = load %Node, %Node* %expr %10 = call %Node @mkReturnStmt(%AstBuilder* %7, %Location %8, %Node %9) store %Node %10, %Node* %"$tmpForRef5" - call void @"=.544"(%Node* %res, %Node* %"$tmpForRef5") + call void @"=.529"(%Node* %res, %Node* %"$tmpForRef5") ret i1 true dumy_block: ; No predecessors! @@ -27840,7 +27169,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %AstBuilder, %AstBuilder* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %expr.addr - %5 = call %Node @"().588"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4) + %5 = call %Node @"().573"(%"FunctionPtr3[Node, UntypedPtr, Location const, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4) ret %Node %5 } @@ -27860,7 +27189,7 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %main.addr %5 = load %Node, %Node* %mods.addr - %6 = call %Node @"().601"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5) + %6 = call %Node @"().586"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5) ret %Node %6 } @@ -27880,7 +27209,7 @@ code: ; preds = %0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %Node, %Node* %moduleName.addr %5 = load %Node, %Node* %decls.addr - %6 = call %Node @"().601"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5) + %6 = call %Node @"().586"(%"FunctionPtr4[Node, UntypedPtr, Location const, Node, Node]"* %1, %UntypedPtr %3, %Location* %loc.addr, %Node %4, %Node %5) ret %Node %6 } @@ -27905,10 +27234,10 @@ define internal %Node @parseExpression(%"SparrowParser[SparrowLayoutDecoder[Spar code: ; preds = %0 %1 = call %Node @parseExpr(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, i1 true) store %Node %1, %Node* %"$tmpForRef" - call void @ctor.535(%Node* %res, %Node* %"$tmpForRef") - call void @ctor.404(%TokenType* %tmp.this, i32 32) + call void @ctor.520(%Node* %res, %Node* %"$tmpForRef") + call void @ctor.393(%TokenType* %tmp.this, i32 32) %2 = call i1 @accept(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this) - call void @ctor.404(%TokenType* %tmp.this1, i32 0) + call void @ctor.393(%TokenType* %tmp.this1, i32 0) %3 = call i1 @expect(%"SparrowParser[SparrowLayoutDecoder[SparrowScanner]]"* %this, %TokenType* %tmp.this1) %4 = load %Node, %Node* %res ret %Node %4 @@ -27963,29 +27292,29 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.609(%LocString* %this) #3 { +define internal void @ctor.594(%LocString* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %LocString, %LocString* %this, i32 0, i32 0 - call void @ctor.610(%"Tuple[Location, String]"* %1) + call void @ctor.595(%"Tuple[Location, String]"* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.610(%"Tuple[Location, String]"* %this) #3 { +define internal void @ctor.595(%"Tuple[Location, String]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %this, i32 0, i32 0 - call void @ctor.118(%Location* %1) + call void @ctor.108(%Location* %1) %2 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %this, i32 0, i32 1 - call void @ctor.124(%String* %2) + call void @ctor.114(%String* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.611"(%LocString* %this, %LocString* %other) #3 { +define internal void @"=.596"(%LocString* %this, %LocString* %other) #3 { %other.addr = alloca %LocString* store %LocString* %other, %LocString** %other.addr br label %code @@ -27994,12 +27323,12 @@ code: ; preds = %0 %1 = getelementptr inbounds %LocString, %LocString* %this, i32 0, i32 0 %2 = load %LocString*, %LocString** %other.addr %3 = getelementptr inbounds %LocString, %LocString* %2, i32 0, i32 0 - call void @"=.612"(%"Tuple[Location, String]"* %1, %"Tuple[Location, String]"* %3) + call void @"=.597"(%"Tuple[Location, String]"* %1, %"Tuple[Location, String]"* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.612"(%"Tuple[Location, String]"* %this, %"Tuple[Location, String]"* %other) #3 { +define internal void @"=.597"(%"Tuple[Location, String]"* %this, %"Tuple[Location, String]"* %other) #3 { %other.addr = alloca %"Tuple[Location, String]"* store %"Tuple[Location, String]"* %other, %"Tuple[Location, String]"** %other.addr br label %code @@ -28008,16 +27337,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %this, i32 0, i32 0 %2 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %other.addr %3 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %2, i32 0, i32 0 - call void @"=.272"(%Location* %1, %Location* %3) + call void @"=.261"(%Location* %1, %Location* %3) %4 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %this, i32 0, i32 1 %5 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %other.addr %6 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %5, i32 0, i32 1 - %7 = call %String* @"=.278"(%String* %4, %String* %6) + %7 = call %String* @"=.267"(%String* %4, %String* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.613"(%LocString* %this, %LocString* %other) #3 { +define internal i1 @"==.598"(%LocString* %this, %LocString* %other) #3 { %this.addr = alloca %LocString* store %LocString* %this, %LocString** %this.addr %other.addr = alloca %LocString* @@ -28029,12 +27358,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %LocString, %LocString* %1, i32 0, i32 0 %3 = load %LocString*, %LocString** %other.addr %4 = getelementptr inbounds %LocString, %LocString* %3, i32 0, i32 0 - %5 = call i1 @"==.614"(%"Tuple[Location, String]"* %2, %"Tuple[Location, String]"* %4) + %5 = call i1 @"==.599"(%"Tuple[Location, String]"* %2, %"Tuple[Location, String]"* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.614"(%"Tuple[Location, String]"* %this, %"Tuple[Location, String]"* %other) #3 { +define internal i1 @"==.599"(%"Tuple[Location, String]"* %this, %"Tuple[Location, String]"* %other) #3 { %this.addr = alloca %"Tuple[Location, String]"* store %"Tuple[Location, String]"* %this, %"Tuple[Location, String]"** %this.addr %other.addr = alloca %"Tuple[Location, String]"* @@ -28046,7 +27375,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %1, i32 0, i32 0 %3 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %other.addr %4 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %3, i32 0, i32 0 - %5 = call i1 @"==.324"(%Location* %2, %Location* %4) + %5 = call i1 @"==.313"(%Location* %2, %Location* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -28054,7 +27383,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %6, i32 0, i32 1 %8 = load %"Tuple[Location, String]"*, %"Tuple[Location, String]"** %other.addr %9 = getelementptr inbounds %"Tuple[Location, String]", %"Tuple[Location, String]"* %8, i32 0, i32 1 - %10 = call i1 @"==.331"(%String* %7, %String* %9) + %10 = call i1 @"==.320"(%String* %7, %String* %9) br label %cond.end cond.false: ; preds = %code @@ -28075,7 +27404,7 @@ define internal %LineCol @mkLineCol(i32 %line, i32 %col) #4 { br label %code code: ; preds = %0 - call void @ctor.120(%LineCol* %res) + call void @ctor.110(%LineCol* %res) %1 = load i32, i32* %line.addr %2 = getelementptr inbounds %LineCol, %LineCol* %res, i32 0, i32 0 store i32 %1, i32* %2 @@ -28092,7 +27421,7 @@ define internal %Location @mkLocation() #4 { br label %code code: ; preds = %0 - call void @ctor.118(%Location* %res) + call void @ctor.108(%Location* %res) call void @setOne(%Location* %res) %1 = load %Location, %Location* %res ret %Location %1 @@ -28100,54 +27429,42 @@ code: ; preds = %0 ; Function Attrs: inlinehint nounwind define internal void @setOne(%Location* %l) #4 { - %tmp.this = alloca i32 - %tmp.this1 = alloca i32 - %tmp.this2 = alloca i32 - %tmp.this3 = alloca i32 br label %code code: ; preds = %0 - store i32 1, i32* %tmp.this - %1 = load i32, i32* %tmp.this - %2 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 - %3 = getelementptr inbounds %LineCol, %LineCol* %2, i32 0, i32 0 - store i32 %1, i32* %3 - store i32 1, i32* %tmp.this1 - %4 = load i32, i32* %tmp.this1 - %5 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 - %6 = getelementptr inbounds %LineCol, %LineCol* %5, i32 0, i32 1 - store i32 %4, i32* %6 - store i32 1, i32* %tmp.this2 - %7 = load i32, i32* %tmp.this2 - %8 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 - %9 = getelementptr inbounds %LineCol, %LineCol* %8, i32 0, i32 0 - store i32 %7, i32* %9 - store i32 1, i32* %tmp.this3 - %10 = load i32, i32* %tmp.this3 - %11 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 - %12 = getelementptr inbounds %LineCol, %LineCol* %11, i32 0, i32 1 - store i32 %10, i32* %12 + %1 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 + %2 = getelementptr inbounds %LineCol, %LineCol* %1, i32 0, i32 0 + store i32 1, i32* %2 + %3 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 + %4 = getelementptr inbounds %LineCol, %LineCol* %3, i32 0, i32 1 + store i32 1, i32* %4 + %5 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 + %6 = getelementptr inbounds %LineCol, %LineCol* %5, i32 0, i32 0 + store i32 1, i32* %6 + %7 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 + %8 = getelementptr inbounds %LineCol, %LineCol* %7, i32 0, i32 1 + store i32 1, i32* %8 ret void } ; Function Attrs: inlinehint nounwind -define internal %Location @mkLocation.615(%SourceCode %sourceCode) #4 { +define internal %Location @mkLocation.600(%SourceCode %sourceCode) #4 { %sourceCode.addr = alloca %SourceCode store %SourceCode %sourceCode, %SourceCode* %sourceCode.addr %res = alloca %Location br label %code code: ; preds = %0 - call void @ctor.118(%Location* %res) + call void @ctor.108(%Location* %res) %1 = getelementptr inbounds %Location, %Location* %res, i32 0, i32 0 - call void @"=.273"(%SourceCode* %1, %SourceCode* %sourceCode.addr) + call void @"=.262"(%SourceCode* %1, %SourceCode* %sourceCode.addr) call void @setOne(%Location* %res) %2 = load %Location, %Location* %res ret %Location %2 } ; Function Attrs: inlinehint nounwind -define internal %Location @mkLocation.616(%SourceCode %sourceCode, %LineCol %start, %LineCol %end) #4 { +define internal %Location @mkLocation.601(%SourceCode %sourceCode, %LineCol %start, %LineCol %end) #4 { %sourceCode.addr = alloca %SourceCode store %SourceCode %sourceCode, %SourceCode* %sourceCode.addr %start.addr = alloca %LineCol @@ -28158,13 +27475,13 @@ define internal %Location @mkLocation.616(%SourceCode %sourceCode, %LineCol %sta br label %code code: ; preds = %0 - call void @ctor.118(%Location* %res) + call void @ctor.108(%Location* %res) %1 = getelementptr inbounds %Location, %Location* %res, i32 0, i32 0 - call void @"=.273"(%SourceCode* %1, %SourceCode* %sourceCode.addr) + call void @"=.262"(%SourceCode* %1, %SourceCode* %sourceCode.addr) %2 = getelementptr inbounds %Location, %Location* %res, i32 0, i32 1 - call void @"=.274"(%LineCol* %2, %LineCol* %start.addr) + call void @"=.263"(%LineCol* %2, %LineCol* %start.addr) %3 = getelementptr inbounds %Location, %Location* %res, i32 0, i32 2 - call void @"=.274"(%LineCol* %3, %LineCol* %end.addr) + call void @"=.263"(%LineCol* %3, %LineCol* %end.addr) %4 = load %Location, %Location* %res ret %Location %4 } @@ -28178,7 +27495,7 @@ define internal void @copyStart(%Location* %l, %Location %other) #4 { code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 %2 = getelementptr inbounds %Location, %Location* %other.addr, i32 0, i32 1 - call void @"=.274"(%LineCol* %1, %LineCol* %2) + call void @"=.263"(%LineCol* %1, %LineCol* %2) ret void } @@ -28191,10 +27508,10 @@ define internal void @setAsStartOf(%Location* %l, %Location %other) #4 { code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 %2 = getelementptr inbounds %Location, %Location* %other.addr, i32 0, i32 1 - call void @"=.274"(%LineCol* %1, %LineCol* %2) + call void @"=.263"(%LineCol* %1, %LineCol* %2) %3 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 %4 = getelementptr inbounds %Location, %Location* %other.addr, i32 0, i32 1 - call void @"=.274"(%LineCol* %3, %LineCol* %4) + call void @"=.263"(%LineCol* %3, %LineCol* %4) ret void } @@ -28207,10 +27524,10 @@ define internal void @setAsEndOf(%Location* %l, %Location %other) #4 { code: ; preds = %0 %1 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 1 %2 = getelementptr inbounds %Location, %Location* %other.addr, i32 0, i32 2 - call void @"=.274"(%LineCol* %1, %LineCol* %2) + call void @"=.263"(%LineCol* %1, %LineCol* %2) %3 = getelementptr inbounds %Location, %Location* %l, i32 0, i32 2 %4 = getelementptr inbounds %Location, %Location* %other.addr, i32 0, i32 2 - call void @"=.274"(%LineCol* %3, %LineCol* %4) + call void @"=.263"(%LineCol* %3, %LineCol* %4) ret void } @@ -28232,7 +27549,7 @@ if_block: ; preds = %code %4 = getelementptr inbounds %Location, %Location* %rhs.addr, i32 0, i32 1 %5 = getelementptr inbounds %LineCol, %LineCol* %4, i32 0, i32 0 %6 = load i32, i32* %5 - %7 = icmp slt i32 %3, %6 + %7 = call i1 @_Int32_opLT(i32 %3, i32 %6) br i1 %7, label %if_then, label %if_end if_then: ; preds = %if_block @@ -28251,7 +27568,7 @@ if_block1: ; preds = %if_end %11 = getelementptr inbounds %Location, %Location* %rhs.addr, i32 0, i32 1 %12 = getelementptr inbounds %LineCol, %LineCol* %11, i32 0, i32 0 %13 = load i32, i32* %12 - %14 = icmp sgt i32 %10, %13 + %14 = call i1 @_Int32_opGT(i32 %10, i32 %13) br i1 %14, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 @@ -28270,7 +27587,7 @@ if_block5: ; preds = %if_end3 %18 = getelementptr inbounds %Location, %Location* %rhs.addr, i32 0, i32 1 %19 = getelementptr inbounds %LineCol, %LineCol* %18, i32 0, i32 1 %20 = load i32, i32* %19 - %21 = icmp slt i32 %17, %20 + %21 = call i1 @_Int32_opLT(i32 %17, i32 %20) br i1 %21, label %if_then6, label %if_end7 if_then6: ; preds = %if_block5 @@ -28289,7 +27606,7 @@ if_block9: ; preds = %if_end7 %25 = getelementptr inbounds %Location, %Location* %rhs.addr, i32 0, i32 1 %26 = getelementptr inbounds %LineCol, %LineCol* %25, i32 0, i32 1 %27 = load i32, i32* %26 - %28 = icmp sgt i32 %24, %27 + %28 = call i1 @_Int32_opGT(i32 %24, i32 %27) br i1 %28, label %if_then10, label %if_end11 if_then10: ; preds = %if_block9 @@ -28308,7 +27625,7 @@ if_block13: ; preds = %if_end11 %32 = getelementptr inbounds %Location, %Location* %rhs.addr, i32 0, i32 2 %33 = getelementptr inbounds %LineCol, %LineCol* %32, i32 0, i32 0 %34 = load i32, i32* %33 - %35 = icmp slt i32 %31, %34 + %35 = call i1 @_Int32_opLT(i32 %31, i32 %34) br i1 %35, label %if_then14, label %if_end15 if_then14: ; preds = %if_block13 @@ -28327,7 +27644,7 @@ if_block17: ; preds = %if_end15 %39 = getelementptr inbounds %Location, %Location* %rhs.addr, i32 0, i32 2 %40 = getelementptr inbounds %LineCol, %LineCol* %39, i32 0, i32 0 %41 = load i32, i32* %40 - %42 = icmp sgt i32 %38, %41 + %42 = call i1 @_Int32_opGT(i32 %38, i32 %41) br i1 %42, label %if_then18, label %if_end19 if_then18: ; preds = %if_block17 @@ -28340,7 +27657,7 @@ if_end19: ; preds = %dumy_block20, %if_b %46 = getelementptr inbounds %Location, %Location* %rhs.addr, i32 0, i32 2 %47 = getelementptr inbounds %LineCol, %LineCol* %46, i32 0, i32 1 %48 = load i32, i32* %47 - %49 = icmp slt i32 %45, %48 + %49 = call i1 @_Int32_opLT(i32 %45, i32 %48) ret i1 %49 dumy_block20: ; No predecessors! @@ -28348,7 +27665,7 @@ dumy_block20: ; No predecessors! } ; Function Attrs: inlinehint nounwind -define internal i1 @"<.617"(%LineCol %lhs, %LineCol %rhs) #4 { +define internal i1 @"<.602"(%LineCol %lhs, %LineCol %rhs) #4 { %lhs.addr = alloca %LineCol store %LineCol %lhs, %LineCol* %lhs.addr %rhs.addr = alloca %LineCol @@ -28363,7 +27680,7 @@ if_block: ; preds = %code %2 = load i32, i32* %1 %3 = getelementptr inbounds %LineCol, %LineCol* %rhs.addr, i32 0, i32 0 %4 = load i32, i32* %3 - %5 = icmp slt i32 %2, %4 + %5 = call i1 @_Int32_opLT(i32 %2, i32 %4) br i1 %5, label %if_then, label %if_end if_then: ; preds = %if_block @@ -28380,7 +27697,7 @@ if_block1: ; preds = %if_end %7 = load i32, i32* %6 %8 = getelementptr inbounds %LineCol, %LineCol* %rhs.addr, i32 0, i32 0 %9 = load i32, i32* %8 - %10 = icmp sgt i32 %7, %9 + %10 = call i1 @_Int32_opGT(i32 %7, i32 %9) br i1 %10, label %if_then2, label %if_end3 if_then2: ; preds = %if_block1 @@ -28391,7 +27708,7 @@ if_end3: ; preds = %dumy_block4, %if_bl %12 = load i32, i32* %11 %13 = getelementptr inbounds %LineCol, %LineCol* %rhs.addr, i32 0, i32 1 %14 = load i32, i32* %13 - %15 = icmp slt i32 %12, %14 + %15 = call i1 @_Int32_opLT(i32 %12, i32 %14) ret i1 %15 dumy_block4: ; No predecessors! @@ -28399,53 +27716,47 @@ dumy_block4: ; No predecessors! } ; Function Attrs: inlinehint nounwind -define internal void @ctor.618(%String* %this, i64 %count, i8 %ch) #4 { - %count.addr = alloca i64 - store i64 %count, i64* %count.addr +define internal void @ctor.603(%String* %this, i32 %count, i8 %ch) #4 { + %count.addr = alloca i32 + store i32 %count, i32* %count.addr %ch.addr = alloca i8 store i8 %ch, i8* %ch.addr %tmp.this = alloca i8 br label %code code: ; preds = %0 - %1 = load i64, i64* %count.addr - call void @ctor.177(%String* %this, i64 %1) + %1 = load i32, i32* %count.addr + call void @ctor.167(%String* %this, i32 %1) %2 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 %3 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %2) %4 = load i8, i8* %ch.addr store i8 %4, i8* %tmp.this %5 = load i8, i8* %tmp.this - %6 = load i64, i64* %count.addr - call void bitcast (void (i8*, i8, i64)* @_spr_memset to void (%UntypedPtr, i8, i64)*)(%UntypedPtr %3, i8 %5, i64 %6) + %6 = load i32, i32* %count.addr + call void bitcast (void (i8*, i8, i64)* @_spr_memset to void (%UntypedPtr, i8, i32)*)(%UntypedPtr %3, i8 %5, i32 %6) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.619(%String* %this, %"RawPtr[Char]" %_begin, %"RawPtr[Char]" %_end) #4 { +define internal void @ctor.604(%String* %this, %"RawPtr[Char]" %_begin, %"RawPtr[Char]" %_end) #4 { %_begin.addr = alloca %"RawPtr[Char]" store %"RawPtr[Char]" %_begin, %"RawPtr[Char]"* %_begin.addr %_end.addr = alloca %"RawPtr[Char]" store %"RawPtr[Char]" %_end, %"RawPtr[Char]"* %_end.addr - %size = alloca i64 - %tmp.this = alloca i64 - %tmp.this1 = alloca i64 + %size = alloca i32 br label %code code: ; preds = %0 %1 = load %"RawPtr[Char]", %"RawPtr[Char]"* %_begin.addr - %2 = call i64 @diff(%"RawPtr[Char]"* %_end.addr, %"RawPtr[Char]" %1) - store i64 %2, i64* %size - %3 = load i64, i64* %size - store i64 %3, i64* %tmp.this - %4 = load i64, i64* %tmp.this - call void @ctor.177(%String* %this, i64 %4) - %5 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %6 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %5) - %7 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %_begin.addr) - %8 = load i64, i64* %size - store i64 %8, i64* %tmp.this1 - %9 = load i64, i64* %tmp.this1 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %6, %UntypedPtr %7, i64 %9) + %2 = call i32 @diff(%"RawPtr[Char]"* %_end.addr, %"RawPtr[Char]" %1) + store i32 %2, i32* %size + %3 = load i32, i32* %size + call void @ctor.167(%String* %this, i32 %3) + %4 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %5 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %4) + %6 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %_begin.addr) + %7 = load i32, i32* %size + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %5, %UntypedPtr %6, i32 %7) ret void } @@ -28454,32 +27765,29 @@ define internal i1 @"!="(%String* %this, %String* %other) #4 { br label %code code: ; preds = %0 - %1 = call i1 @"==.331"(%String* %this, %String* %other) + %1 = call i1 @"==.320"(%String* %this, %String* %other) %2 = xor i1 true, %1 ret i1 %2 } ; Function Attrs: inlinehint nounwind -define internal i8* @at.620(%String* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal i8* @at.605(%String* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - store i64 %2, i64* %tmp.this - %3 = load i64, i64* %tmp.this - %4 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i64 %3) - store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" - %5 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") - ret i8* %5 + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i32 %2) + store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" + %4 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") + ret i8* %4 } ; Function Attrs: inlinehint nounwind -define internal i8* @front.621(%String* %this) #4 { +define internal i8* @front.606(%String* %this) #4 { br label %code code: ; preds = %0 @@ -28489,88 +27797,76 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i8* @back.622(%String* %this) #4 { +define internal i8* @back.607(%String* %this) #4 { %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this - %2 = load i64, i64* %tmp.this - %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i64 %2) - store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" - %4 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") - ret i8* %4 + %2 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i32 -1) + store %"RawPtr[Char]" %2, %"RawPtr[Char]"* %"$tmpForRef" + %3 = call i8* @value(%"RawPtr[Char]"* %"$tmpForRef") + ret i8* %3 } ; Function Attrs: inlinehint nounwind -define internal %StringRef @subrange.623(%String* %this, i64 %index, i64 %num) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr - %num.addr = alloca i64 - store i64 %num, i64* %num.addr +define internal %StringRef @subrange.608(%String* %this, i32 %index, i32 %num) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr + %num.addr = alloca i32 + store i32 %num, i32* %num.addr %tmp.this = alloca %StringRef %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this1 = alloca i64 - %"$tmpForRef2" = alloca %"RawPtr[Char]" - %tmp.this3 = alloca i64 + %"$tmpForRef1" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 %1 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %2 = load i64, i64* %index.addr - store i64 %2, i64* %tmp.this1 - %3 = load i64, i64* %tmp.this1 - %4 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i64 %3) - store %"RawPtr[Char]" %4, %"RawPtr[Char]"* %"$tmpForRef" - %5 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %"$tmpForRef") - %6 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %7 = load i64, i64* %index.addr - %8 = load i64, i64* %num.addr - %9 = add i64 %7, %8 - store i64 %9, i64* %tmp.this3 - %10 = load i64, i64* %tmp.this3 - %11 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %6, i64 %10) - store %"RawPtr[Char]" %11, %"RawPtr[Char]"* %"$tmpForRef2" - %12 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %"$tmpForRef2") - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %5, %UntypedPtr %12) - %13 = load %StringRef, %StringRef* %tmp.this - %14 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %14) - ret %StringRef %13 + %2 = load i32, i32* %index.addr + %3 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %1, i32 %2) + store %"RawPtr[Char]" %3, %"RawPtr[Char]"* %"$tmpForRef" + %4 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %"$tmpForRef") + %5 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %6 = load i32, i32* %index.addr + %7 = load i32, i32* %num.addr + %8 = call i32 @_Int32_opPlus(i32 %6, i32 %7) + %9 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %5, i32 %8) + store %"RawPtr[Char]" %9, %"RawPtr[Char]"* %"$tmpForRef1" + %10 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %"$tmpForRef1") + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %4, %UntypedPtr %10) + %11 = load %StringRef, %StringRef* %tmp.this + %12 = load %StringRef, %StringRef* %tmp.this + call void @dtor.51(%StringRef %12) + ret %StringRef %11 dumy_block: ; No predecessors! - %15 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %15) + %13 = load %StringRef, %StringRef* %tmp.this + call void @dtor.51(%StringRef %13) unreachable } ; Function Attrs: inlinehint nounwind -define internal void @resize(%String* %this, i64 %n) #4 { - %n.addr = alloca i64 - store i64 %n, i64* %n.addr - %oldSize = alloca i64 +define internal void @resize(%String* %this, i32 %n) #4 { + %n.addr = alloca i32 + store i32 %n, i32* %n.addr + %oldSize = alloca i32 %newEnd = alloca %"RawPtr[Char]" %"$tmpForRef" = alloca %"RawPtr[Char]" - %tmp.this = alloca i64 %"$tmpForRef4" = alloca %"RawPtr[Char]" - %tmp.this5 = alloca i64 - %newEnd6 = alloca %"RawPtr[Char]" - %"$tmpForRef7" = alloca %"RawPtr[Char]" - %tmp.this8 = alloca i64 - %"$tmpForRef13" = alloca %"RawPtr[Char]" + %newEnd5 = alloca %"RawPtr[Char]" + %"$tmpForRef6" = alloca %"RawPtr[Char]" + %"$tmpForRef11" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 - %1 = call i64 @size.176(%String* %this) - store i64 %1, i64* %oldSize + %1 = call i32 @size.166(%String* %this) + store i32 %1, i32* %oldSize br label %if_block if_block: ; preds = %code - %2 = load i64, i64* %n.addr - %3 = load i64, i64* %oldSize - %4 = icmp eq i64 %2, %3 + %2 = load i32, i32* %n.addr + %3 = load i32, i32* %oldSize + %4 = call i1 @_Int32_opEQ(i32 %2, i32 %3) br i1 %4, label %if_then, label %if_end if_then: ; preds = %if_block @@ -28583,53 +27879,47 @@ dumy_block: ; No predecessors! br label %if_end if_block1: ; preds = %if_end - %5 = load i64, i64* %n.addr - %6 = load i64, i64* %oldSize - %7 = icmp slt i64 %5, %6 + %5 = load i32, i32* %n.addr + %6 = load i32, i32* %oldSize + %7 = call i1 @_Int32_opLT(i32 %5, i32 %6) br i1 %7, label %if_then2, label %if_else if_then2: ; preds = %if_block1 %8 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %9 = load i64, i64* %n.addr - store i64 %9, i64* %tmp.this - %10 = load i64, i64* %tmp.this - %11 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %8, i64 %10) - store %"RawPtr[Char]" %11, %"RawPtr[Char]"* %"$tmpForRef" - call void @ctor.178(%"RawPtr[Char]"* %newEnd, %"RawPtr[Char]"* %"$tmpForRef") + %9 = load i32, i32* %n.addr + %10 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %8, i32 %9) + store %"RawPtr[Char]" %10, %"RawPtr[Char]"* %"$tmpForRef" + call void @ctor.168(%"RawPtr[Char]"* %newEnd, %"RawPtr[Char]"* %"$tmpForRef") br label %while_block if_else: ; preds = %if_block1 - %12 = load i64, i64* %n.addr - call void @reserve(%String* %this, i64 %12) - %13 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 - %14 = load i64, i64* %n.addr - store i64 %14, i64* %tmp.this8 - %15 = load i64, i64* %tmp.this8 - %16 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %13, i64 %15) - store %"RawPtr[Char]" %16, %"RawPtr[Char]"* %"$tmpForRef7" - call void @ctor.178(%"RawPtr[Char]"* %newEnd6, %"RawPtr[Char]"* %"$tmpForRef7") - br label %while_block9 + %11 = load i32, i32* %n.addr + call void @reserve(%String* %this, i32 %11) + %12 = getelementptr inbounds %String, %String* %this, i32 0, i32 0 + %13 = load i32, i32* %n.addr + %14 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %12, i32 %13) + store %"RawPtr[Char]" %14, %"RawPtr[Char]"* %"$tmpForRef6" + call void @ctor.168(%"RawPtr[Char]"* %newEnd5, %"RawPtr[Char]"* %"$tmpForRef6") + br label %while_block7 -if_end3: ; preds = %while_end12, %while_end +if_end3: ; preds = %while_end10, %while_end ret void while_block: ; preds = %while_step, %if_then2 - %17 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %18 = call i1 @"==.257"(%"RawPtr[Char]"* %17, %"RawPtr[Char]"* %newEnd) - %19 = xor i1 true, %18 - br i1 %19, label %while_body, label %while_end + %15 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %16 = call i1 @"==.246"(%"RawPtr[Char]"* %15, %"RawPtr[Char]"* %newEnd) + %17 = xor i1 true, %16 + br i1 %17, label %while_body, label %while_end while_body: ; preds = %while_block - %20 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %18 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %19 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %20 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %19, i32 -1) + store %"RawPtr[Char]" %20, %"RawPtr[Char]"* %"$tmpForRef4" + call void @"=.176"(%"RawPtr[Char]"* %18, %"RawPtr[Char]"* %"$tmpForRef4") %21 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - store i64 -1, i64* %tmp.this5 - %22 = load i64, i64* %tmp.this5 - %23 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %21, i64 %22) - store %"RawPtr[Char]" %23, %"RawPtr[Char]"* %"$tmpForRef4" - call void @"=.186"(%"RawPtr[Char]"* %20, %"RawPtr[Char]"* %"$tmpForRef4") - %24 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %25 = call i8* @value(%"RawPtr[Char]"* %24) - %26 = load i8, i8* %25 + %22 = call i8* @value(%"RawPtr[Char]"* %21) + %23 = load i8, i8* %22 br label %while_step while_step: ; preds = %while_body @@ -28638,27 +27928,27 @@ while_step: ; preds = %while_body while_end: ; preds = %while_block br label %if_end3 -while_block9: ; preds = %while_step11, %if_else - %27 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %28 = call i1 @"==.257"(%"RawPtr[Char]"* %27, %"RawPtr[Char]"* %newEnd6) - %29 = xor i1 true, %28 - br i1 %29, label %while_body10, label %while_end12 +while_block7: ; preds = %while_step9, %if_else + %24 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %25 = call i1 @"==.246"(%"RawPtr[Char]"* %24, %"RawPtr[Char]"* %newEnd5) + %26 = xor i1 true, %25 + br i1 %26, label %while_body8, label %while_end10 -while_body10: ; preds = %while_block9 +while_body8: ; preds = %while_block7 + %27 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 + %28 = call i8* @value(%"RawPtr[Char]"* %27) + store i8 0, i8* %28 + %29 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %30 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %31 = call i8* @value(%"RawPtr[Char]"* %30) - store i8 0, i8* %31 - %32 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %33 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 - %34 = call %"RawPtr[Char]" @advance.258(%"RawPtr[Char]"* %33) - store %"RawPtr[Char]" %34, %"RawPtr[Char]"* %"$tmpForRef13" - call void @"=.186"(%"RawPtr[Char]"* %32, %"RawPtr[Char]"* %"$tmpForRef13") - br label %while_step11 + %31 = call %"RawPtr[Char]" @advance.247(%"RawPtr[Char]"* %30) + store %"RawPtr[Char]" %31, %"RawPtr[Char]"* %"$tmpForRef11" + call void @"=.176"(%"RawPtr[Char]"* %29, %"RawPtr[Char]"* %"$tmpForRef11") + br label %while_step9 -while_step11: ; preds = %while_body10 - br label %while_block9 +while_step9: ; preds = %while_body8 + br label %while_block7 -while_end12: ; preds = %while_block9 +while_end10: ; preds = %while_block7 br label %if_end3 } @@ -28680,11 +27970,11 @@ code: ; preds = %0 %4 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %"$tmpForRef") %5 = getelementptr inbounds %String, %String* %this, i32 0, i32 1 %6 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %5) - call void @ctor.60(%StringRef* %tmp.this, %UntypedPtr %4, %UntypedPtr %6) + call void @ctor.50(%StringRef* %tmp.this, %UntypedPtr %4, %UntypedPtr %6) %7 = load %StringRef, %StringRef* %tmp.this - call void @insertBefore.470(%String* %this, i8 %1, %StringRef %7) + call void @insertBefore.459(%String* %this, i8 %1, %StringRef %7) %8 = load %StringRef, %StringRef* %tmp.this - call void @dtor.61(%StringRef %8) + call void @dtor.51(%StringRef %8) ret void } @@ -28699,130 +27989,144 @@ define internal %"RawPtr[Char]" @_backPtr(%StringRef %s) #4 { code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %s.addr, i32 0, i32 1 %2 = load %UntypedPtr, %UntypedPtr* %1 - call void @ctor.55(%UntypedPtr* %tmp.this1, %UntypedPtr %2) + call void @ctor.45(%UntypedPtr* %tmp.this1, %UntypedPtr %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - call void @ctor.180(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %3) + call void @ctor.170(%"RawPtr[Char]"* %tmp.this, %UntypedPtr %3) %4 = load %"RawPtr[Char]", %"RawPtr[Char]"* %tmp.this ret %"RawPtr[Char]" %4 } ; Function Attrs: inlinehint nounwind -define internal void @remove.624(%String* %this, i64 %index) #4 { - %index.addr = alloca i64 - store i64 %index, i64* %index.addr +define internal void @remove.609(%String* %this, i32 %index) #4 { + %index.addr = alloca i32 + store i32 %index, i32* %index.addr %r = alloca %StringRef - %tmp.this = alloca i64 br label %code code: ; preds = %0 - %1 = call %StringRef @all.473(%String* %this) - call void @ctor.59(%StringRef* %r, %StringRef %1) - %2 = load i64, i64* %index.addr - call void @popFront.64(%StringRef* %r, i64 %2) - %3 = call i64 @size.176(%String* %this) - %4 = load i64, i64* %index.addr - %5 = call i64 @_SizeType_opMinus(i64 %3, i64 %4) - store i64 1, i64* %tmp.this - %6 = load i64, i64* %tmp.this - %7 = call i64 @_SizeType_opMinus(i64 %5, i64 %6) - call void @popBack.65(%StringRef* %r, i64 %7) + %1 = call %StringRef @all.462(%String* %this) + call void @ctor.49(%StringRef* %r, %StringRef %1) + %2 = load i32, i32* %index.addr + call void @popFront.54(%StringRef* %r, i32 %2) + %3 = call i32 @size.166(%String* %this) + %4 = load i32, i32* %index.addr + %5 = call i32 @_Int32_opMinus(i32 %3, i32 %4) + %6 = call i32 @_Int32_opMinus(i32 %5, i32 1) + call void @popBack.55(%StringRef* %r, i32 %6) + %7 = load %StringRef, %StringRef* %r + call void @remove(%String* %this, %StringRef %7) %8 = load %StringRef, %StringRef* %r - call void @remove(%String* %this, %StringRef %8) - %9 = load %StringRef, %StringRef* %r - call void @dtor.61(%StringRef %9) + call void @dtor.51(%StringRef %8) ret void } ; Function Attrs: inlinehint nounwind -define internal void @"+.625"(%String* sret %_result, %String* %x, %String* %y) #4 { - %sz1 = alloca i64 - %sz2 = alloca i64 +define internal void @"+.610"(%String* sret %_result, %String* %x, %String* %y) #4 { + %sz1 = alloca i32 + %sz2 = alloca i32 %res = alloca %String %"$tmpForRef" = alloca %"RawPtr[Char]" br label %code code: ; preds = %0 - %1 = call i64 @size.176(%String* %x) - store i64 %1, i64* %sz1 - %2 = call i64 @size.176(%String* %y) - store i64 %2, i64* %sz2 - %3 = load i64, i64* %sz1 - %4 = load i64, i64* %sz2 - %5 = add i64 %3, %4 - call void @ctor.177(%String* %res, i64 %5) + %1 = call i32 @size.166(%String* %x) + store i32 %1, i32* %sz1 + %2 = call i32 @size.166(%String* %y) + store i32 %2, i32* %sz2 + %3 = load i32, i32* %sz1 + %4 = load i32, i32* %sz2 + %5 = call i32 @_Int32_opPlus(i32 %3, i32 %4) + call void @ctor.167(%String* %res, i32 %5) %6 = getelementptr inbounds %String, %String* %res, i32 0, i32 0 %7 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %6) %8 = getelementptr inbounds %String, %String* %x, i32 0, i32 0 %9 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %8) - %10 = load i64, i64* %sz1 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %7, %UntypedPtr %9, i64 %10) + %10 = load i32, i32* %sz1 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %7, %UntypedPtr %9, i32 %10) %11 = getelementptr inbounds %String, %String* %res, i32 0, i32 0 - %12 = load i64, i64* %sz1 - %13 = call %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %11, i64 %12) + %12 = load i32, i32* %sz1 + %13 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %11, i32 %12) store %"RawPtr[Char]" %13, %"RawPtr[Char]"* %"$tmpForRef" %14 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %"$tmpForRef") %15 = getelementptr inbounds %String, %String* %y, i32 0, i32 0 %16 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %15) - %17 = load i64, i64* %sz2 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %14, %UntypedPtr %16, i64 %17) - call void @ctor.175(%String* %_result, %String* %res) - call void @dtor.250(%String* %res) + %17 = load i32, i32* %sz2 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %14, %UntypedPtr %16, i32 %17) + call void @ctor.165(%String* %_result, %String* %res) + call void @dtor.239(%String* %res) ret void dumy_block: ; No predecessors! - call void @dtor.250(%String* %res) + call void @dtor.239(%String* %res) ret void } ; Function Attrs: inlinehint nounwind -define internal void @"+.626"(%String* sret %_result, %String* %x, %StringRef %y) #4 { +define internal void @"+.611"(%String* sret %_result, %String* %x, %StringRef %y) #4 { %y.addr = alloca %StringRef store %StringRef %y, %StringRef* %y.addr - %sz1 = alloca i64 - %sz2 = alloca i64 + %sz1 = alloca i32 + %sz2 = alloca i32 %res = alloca %String %"$tmpForRef" = alloca %"RawPtr[Char]" %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 - %1 = call i64 @size.176(%String* %x) - store i64 %1, i64* %sz1 + %1 = call i32 @size.166(%String* %x) + store i32 %1, i32* %sz1 %2 = load %StringRef, %StringRef* %y.addr - %3 = call i64 @size(%StringRef %2) - store i64 %3, i64* %sz2 - %4 = load i64, i64* %sz1 - %5 = load i64, i64* %sz2 - %6 = add i64 %4, %5 - call void @ctor.177(%String* %res, i64 %6) + %3 = call i32 @size(%StringRef %2) + store i32 %3, i32* %sz2 + %4 = load i32, i32* %sz1 + %5 = load i32, i32* %sz2 + %6 = call i32 @_Int32_opPlus(i32 %4, i32 %5) + call void @ctor.167(%String* %res, i32 %6) %7 = getelementptr inbounds %String, %String* %res, i32 0, i32 0 %8 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %7) %9 = getelementptr inbounds %String, %String* %x, i32 0, i32 0 %10 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %9) - %11 = load i64, i64* %sz1 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %8, %UntypedPtr %10, i64 %11) + %11 = load i32, i32* %sz1 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %8, %UntypedPtr %10, i32 %11) %12 = getelementptr inbounds %String, %String* %res, i32 0, i32 0 - %13 = load i64, i64* %sz1 - %14 = call %"RawPtr[Char]" @advance.187(%"RawPtr[Char]"* %12, i64 %13) + %13 = load i32, i32* %sz1 + %14 = call %"RawPtr[Char]" @advance(%"RawPtr[Char]"* %12, i32 %13) store %"RawPtr[Char]" %14, %"RawPtr[Char]"* %"$tmpForRef" %15 = call %UntypedPtr @untypedPtr(%"RawPtr[Char]"* %"$tmpForRef") %16 = getelementptr inbounds %StringRef, %StringRef* %y.addr, i32 0, i32 0 %17 = load %UntypedPtr, %UntypedPtr* %16 - call void @ctor.55(%UntypedPtr* %tmp.this, %UntypedPtr %17) + call void @ctor.45(%UntypedPtr* %tmp.this, %UntypedPtr %17) %18 = load %UntypedPtr, %UntypedPtr* %tmp.this - %19 = load i64, i64* %sz2 - call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i64)*)(%UntypedPtr %15, %UntypedPtr %18, i64 %19) - call void @ctor.175(%String* %_result, %String* %res) - call void @dtor.250(%String* %res) + %19 = load i32, i32* %sz2 + call void bitcast (void (i8*, i8*, i64)* @_spr_memcpy to void (%UntypedPtr, %UntypedPtr, i32)*)(%UntypedPtr %15, %UntypedPtr %18, i32 %19) + call void @ctor.165(%String* %_result, %String* %res) + call void @dtor.239(%String* %res) ret void dumy_block: ; No predecessors! - call void @dtor.250(%String* %res) + call void @dtor.239(%String* %res) + ret void +} + +; Function Attrs: inlinehint nounwind +define internal void @ulongToString(%String* sret %_result, i64 %x) #4 { + %x.addr = alloca i64 + store i64 %x, i64* %x.addr + %buf = alloca [16 x i8] + br label %code + +code: ; preds = %0 + %1 = load i64, i64* %x.addr + %2 = bitcast [16 x i8]* %buf to i8* + call void @_ULong_to_CString(i64 %1, i8* %2) + %3 = bitcast [16 x i8]* %buf to i8* + %4 = call %StringRef @_String_fromCString(i8* %3) + call void @ctor.448(%String* %_result, %StringRef %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.627"(%StringOutputStream* %this, %StringOutputStream* %other) #3 { +define internal void @"=.612"(%StringOutputStream* %this, %StringOutputStream* %other) #3 { %other.addr = alloca %StringOutputStream* store %StringOutputStream* %other, %StringOutputStream** %other.addr br label %code @@ -28831,12 +28135,12 @@ code: ; preds = %0 %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 %2 = load %StringOutputStream*, %StringOutputStream** %other.addr %3 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %2, i32 0, i32 0 - %4 = call %String* @"=.278"(%String* %1, %String* %3) + %4 = call %String* @"=.267"(%String* %1, %String* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.628"(%StringOutputStream* %this, %StringOutputStream* %other) #3 { +define internal i1 @"==.613"(%StringOutputStream* %this, %StringOutputStream* %other) #3 { %this.addr = alloca %StringOutputStream* store %StringOutputStream* %this, %StringOutputStream** %this.addr %other.addr = alloca %StringOutputStream* @@ -28848,25 +28152,115 @@ code: ; preds = %0 %2 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %1, i32 0, i32 0 %3 = load %StringOutputStream*, %StringOutputStream** %other.addr %4 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %3, i32 0, i32 0 - %5 = call i1 @"==.331"(%String* %2, %String* %4) + %5 = call i1 @"==.320"(%String* %2, %String* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal void @"<<<.629"(%StringOutputStream* %this, %String* %s) #3 { +define internal void @"<<<.614"(%StringOutputStream* %this, %String* %s) #3 { %"$tmpForRef" = alloca %StringRef br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 - %2 = call %StringRef @all.473(%String* %s) + %2 = call %StringRef @all.462(%String* %s) store %StringRef %2, %StringRef* %"$tmpForRef" call void @append(%String* %1, %StringRef* %"$tmpForRef") ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"<<<.630"(%StringOutputStream* %this, double %x) #3 { +define internal void @"<<<.615"(%StringOutputStream* %this, i32 %x) #3 { + %x.addr = alloca i32 + store i32 %x, i32* %x.addr + %"$tmpForRef" = alloca %StringRef + %"$tmpC" = alloca %String + %tmp.this = alloca i64 + br label %code + +code: ; preds = %0 + %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 + %2 = load i32, i32* %x.addr + %3 = zext i32 %2 to i64 + store i64 %3, i64* %tmp.this + %4 = load i64, i64* %tmp.this + call void @ulongToString(%String* %"$tmpC", i64 %4) + %5 = call %StringRef @all.462(%String* %"$tmpC") + store %StringRef %5, %StringRef* %"$tmpForRef" + call void @append(%String* %1, %StringRef* %"$tmpForRef") + call void @dtor.239(%String* %"$tmpC") + ret void +} + +; Function Attrs: alwaysinline nounwind +define internal void @"<<<.616"(%StringOutputStream* %this, i64 %x) #3 { + %x.addr = alloca i64 + store i64 %x, i64* %x.addr + %"$tmpForRef" = alloca %StringRef + %"$tmpC" = alloca %String + %tmp.this = alloca i64 + br label %code + +code: ; preds = %0 + %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 + %2 = load i64, i64* %x.addr + store i64 %2, i64* %tmp.this + %3 = load i64, i64* %tmp.this + call void @ulongToString(%String* %"$tmpC", i64 %3) + %4 = call %StringRef @all.462(%String* %"$tmpC") + store %StringRef %4, %StringRef* %"$tmpForRef" + call void @append(%String* %1, %StringRef* %"$tmpForRef") + call void @dtor.239(%String* %"$tmpC") + ret void +} + +; Function Attrs: alwaysinline nounwind +define internal void @"<<<.617"(%StringOutputStream* %this, i64 %x) #3 { + %x.addr = alloca i64 + store i64 %x, i64* %x.addr + %"$tmpForRef" = alloca %StringRef + %"$tmpC" = alloca %String + %tmp.this = alloca i64 + br label %code + +code: ; preds = %0 + %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 + %2 = load i64, i64* %x.addr + store i64 %2, i64* %tmp.this + %3 = load i64, i64* %tmp.this + call void @ulongToString(%String* %"$tmpC", i64 %3) + %4 = call %StringRef @all.462(%String* %"$tmpC") + store %StringRef %4, %StringRef* %"$tmpForRef" + call void @append(%String* %1, %StringRef* %"$tmpForRef") + call void @dtor.239(%String* %"$tmpC") + ret void +} + +; Function Attrs: alwaysinline nounwind +define internal void @"<<<.618"(%StringOutputStream* %this, float %x) #3 { + %x.addr = alloca float + store float %x, float* %x.addr + %"$tmpForRef" = alloca %StringRef + %"$tmpC" = alloca %String + %tmp.this = alloca i64 + br label %code + +code: ; preds = %0 + %1 = getelementptr inbounds %StringOutputStream, %StringOutputStream* %this, i32 0, i32 0 + %2 = load float, float* %x.addr + %3 = fptoui float %2 to i64 + store i64 %3, i64* %tmp.this + %4 = load i64, i64* %tmp.this + call void @ulongToString(%String* %"$tmpC", i64 %4) + %5 = call %StringRef @all.462(%String* %"$tmpC") + store %StringRef %5, %StringRef* %"$tmpForRef" + call void @append(%String* %1, %StringRef* %"$tmpForRef") + call void @dtor.239(%String* %"$tmpC") + ret void +} + +; Function Attrs: alwaysinline nounwind +define internal void @"<<<.619"(%StringOutputStream* %this, double %x) #3 { %x.addr = alloca double store double %x, double* %x.addr %"$tmpForRef" = alloca %StringRef @@ -28881,36 +28275,36 @@ code: ; preds = %0 store i64 %3, i64* %tmp.this %4 = load i64, i64* %tmp.this call void @ulongToString(%String* %"$tmpC", i64 %4) - %5 = call %StringRef @all.473(%String* %"$tmpC") + %5 = call %StringRef @all.462(%String* %"$tmpC") store %StringRef %5, %StringRef* %"$tmpForRef" call void @append(%String* %1, %StringRef* %"$tmpForRef") - call void @dtor.250(%String* %"$tmpC") + call void @dtor.239(%String* %"$tmpC") ret void } ; Function Attrs: inlinehint nounwind -define internal void @toString.631(%String* sret %_result) #4 { +define internal void @toString.620(%String* sret %_result) #4 { br label %code code: ; preds = %0 - call void @ctor.124(%String* %_result) + call void @ctor.114(%String* %_result) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.632(%"ContiguousMemoryRange[LocString]"* %this) #3 { +define internal void @ctor.621(%"ContiguousMemoryRange[LocString]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 0 - call void @ctor.551(%"RawPtr[LocString]"* %1) + call void @ctor.536(%"RawPtr[LocString]"* %1) %2 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 1 - call void @ctor.551(%"RawPtr[LocString]"* %2) + call void @ctor.536(%"RawPtr[LocString]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.633(%"ContiguousMemoryRange[LocString]"* %this) #3 { +define internal void @dtor.622(%"ContiguousMemoryRange[LocString]"* %this) #3 { br label %code code: ; preds = %0 @@ -28918,7 +28312,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.634"(%"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"* %other) #3 { +define internal void @"=.623"(%"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"* %other) #3 { %other.addr = alloca %"ContiguousMemoryRange[LocString]"* store %"ContiguousMemoryRange[LocString]"* %other, %"ContiguousMemoryRange[LocString]"** %other.addr br label %code @@ -28927,16 +28321,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 0 %2 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %other.addr %3 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %2, i32 0, i32 0 - call void @"=.562"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) + call void @"=.547"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) %4 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %this, i32 0, i32 1 %5 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %other.addr %6 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %5, i32 0, i32 1 - call void @"=.562"(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) + call void @"=.547"(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.635"(%"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"* %other) #3 { +define internal i1 @"==.624"(%"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"* %other) #3 { %this.addr = alloca %"ContiguousMemoryRange[LocString]"* store %"ContiguousMemoryRange[LocString]"* %this, %"ContiguousMemoryRange[LocString]"** %this.addr %other.addr = alloca %"ContiguousMemoryRange[LocString]"* @@ -28948,7 +28342,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %1, i32 0, i32 0 %3 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %other.addr %4 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %3, i32 0, i32 0 - %5 = call i1 @"==.554"(%"RawPtr[LocString]"* %2, %"RawPtr[LocString]"* %4) + %5 = call i1 @"==.539"(%"RawPtr[LocString]"* %2, %"RawPtr[LocString]"* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -28956,7 +28350,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %6, i32 0, i32 1 %8 = load %"ContiguousMemoryRange[LocString]"*, %"ContiguousMemoryRange[LocString]"** %other.addr %9 = getelementptr inbounds %"ContiguousMemoryRange[LocString]", %"ContiguousMemoryRange[LocString]"* %8, i32 0, i32 1 - %10 = call i1 @"==.554"(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) + %10 = call i1 @"==.539"(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) br label %cond.end cond.false: ; preds = %code @@ -28968,19 +28362,19 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.636(%"ContiguousMemoryRange[Char]"* %this) #3 { +define internal void @ctor.625(%"ContiguousMemoryRange[Char]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 - call void @ctor.125(%"RawPtr[Char]"* %1) + call void @ctor.115(%"RawPtr[Char]"* %1) %2 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 1 - call void @ctor.125(%"RawPtr[Char]"* %2) + call void @ctor.115(%"RawPtr[Char]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.637(%"ContiguousMemoryRange[Char]"* %this) #3 { +define internal void @dtor.626(%"ContiguousMemoryRange[Char]"* %this) #3 { br label %code code: ; preds = %0 @@ -28988,7 +28382,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.638"(%"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"* %other) #3 { +define internal void @"=.627"(%"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"* %other) #3 { %other.addr = alloca %"ContiguousMemoryRange[Char]"* store %"ContiguousMemoryRange[Char]"* %other, %"ContiguousMemoryRange[Char]"** %other.addr br label %code @@ -28997,16 +28391,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 0 %2 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %other.addr %3 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %2, i32 0, i32 0 - call void @"=.186"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) + call void @"=.176"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) %4 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %this, i32 0, i32 1 %5 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %other.addr %6 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %5, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) + call void @"=.176"(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.639"(%"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"* %other) #3 { +define internal i1 @"==.628"(%"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"* %other) #3 { %this.addr = alloca %"ContiguousMemoryRange[Char]"* store %"ContiguousMemoryRange[Char]"* %this, %"ContiguousMemoryRange[Char]"** %this.addr %other.addr = alloca %"ContiguousMemoryRange[Char]"* @@ -29018,7 +28412,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %1, i32 0, i32 0 %3 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %other.addr %4 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %3, i32 0, i32 0 - %5 = call i1 @"==.257"(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %4) + %5 = call i1 @"==.246"(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -29026,7 +28420,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %6, i32 0, i32 1 %8 = load %"ContiguousMemoryRange[Char]"*, %"ContiguousMemoryRange[Char]"** %other.addr %9 = getelementptr inbounds %"ContiguousMemoryRange[Char]", %"ContiguousMemoryRange[Char]"* %8, i32 0, i32 1 - %10 = call i1 @"==.257"(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) + %10 = call i1 @"==.246"(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) br label %cond.end cond.false: ; preds = %code @@ -29038,19 +28432,19 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.640(%"ContiguousMemoryRange[Token]"* %this) #3 { +define internal void @ctor.629(%"ContiguousMemoryRange[Token]"* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 - call void @ctor.137(%"RawPtr[Token]"* %1) + call void @ctor.127(%"RawPtr[Token]"* %1) %2 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 1 - call void @ctor.137(%"RawPtr[Token]"* %2) + call void @ctor.127(%"RawPtr[Token]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.641(%"ContiguousMemoryRange[Token]"* %this) #3 { +define internal void @dtor.630(%"ContiguousMemoryRange[Token]"* %this) #3 { br label %code code: ; preds = %0 @@ -29058,7 +28452,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.642"(%"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"* %other) #3 { +define internal void @"=.631"(%"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"* %other) #3 { %other.addr = alloca %"ContiguousMemoryRange[Token]"* store %"ContiguousMemoryRange[Token]"* %other, %"ContiguousMemoryRange[Token]"** %other.addr br label %code @@ -29067,16 +28461,16 @@ code: ; preds = %0 %1 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 0 %2 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %other.addr %3 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %2, i32 0, i32 0 - call void @"=.198"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) + call void @"=.187"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) %4 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %this, i32 0, i32 1 %5 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %other.addr %6 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %5, i32 0, i32 1 - call void @"=.198"(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) + call void @"=.187"(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.643"(%"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"* %other) #3 { +define internal i1 @"==.632"(%"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"* %other) #3 { %this.addr = alloca %"ContiguousMemoryRange[Token]"* store %"ContiguousMemoryRange[Token]"* %this, %"ContiguousMemoryRange[Token]"** %this.addr %other.addr = alloca %"ContiguousMemoryRange[Token]"* @@ -29088,7 +28482,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %1, i32 0, i32 0 %3 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %other.addr %4 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %3, i32 0, i32 0 - %5 = call i1 @"==.205"(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %4) + %5 = call i1 @"==.194"(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code @@ -29096,7 +28490,7 @@ cond.true: ; preds = %code %7 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %6, i32 0, i32 1 %8 = load %"ContiguousMemoryRange[Token]"*, %"ContiguousMemoryRange[Token]"** %other.addr %9 = getelementptr inbounds %"ContiguousMemoryRange[Token]", %"ContiguousMemoryRange[Token]"* %8, i32 0, i32 1 - %10 = call i1 @"==.205"(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) + %10 = call i1 @"==.194"(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) br label %cond.end cond.false: ; preds = %code @@ -29108,57 +28502,57 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.644(%"ContiguousMemoryRange[UInt]"* %this, %"RawPtr[UInt]" %f_begin, %"RawPtr[UInt]" %f_end) #3 { - %this.addr = alloca %"ContiguousMemoryRange[UInt]"* - store %"ContiguousMemoryRange[UInt]"* %this, %"ContiguousMemoryRange[UInt]"** %this.addr - %f_begin.addr = alloca %"RawPtr[UInt]" - store %"RawPtr[UInt]" %f_begin, %"RawPtr[UInt]"* %f_begin.addr - %f_end.addr = alloca %"RawPtr[UInt]" - store %"RawPtr[UInt]" %f_end, %"RawPtr[UInt]"* %f_end.addr +define internal void @ctor.633(%"ContiguousMemoryRange[Int]"* %this, %"RawPtr[Int]" %f_begin, %"RawPtr[Int]" %f_end) #3 { + %this.addr = alloca %"ContiguousMemoryRange[Int]"* + store %"ContiguousMemoryRange[Int]"* %this, %"ContiguousMemoryRange[Int]"** %this.addr + %f_begin.addr = alloca %"RawPtr[Int]" + store %"RawPtr[Int]" %f_begin, %"RawPtr[Int]"* %f_begin.addr + %f_end.addr = alloca %"RawPtr[Int]" + store %"RawPtr[Int]" %f_end, %"RawPtr[Int]"* %f_end.addr br label %code code: ; preds = %0 - %1 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %this.addr - %2 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %1, i32 0, i32 0 - call void @ctor.218(%"RawPtr[UInt]"* %2, %"RawPtr[UInt]"* %f_begin.addr) - %3 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %this.addr - %4 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %3, i32 0, i32 1 - call void @ctor.218(%"RawPtr[UInt]"* %4, %"RawPtr[UInt]"* %f_end.addr) + %1 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %this.addr + %2 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %1, i32 0, i32 0 + call void @ctor.207(%"RawPtr[Int]"* %2, %"RawPtr[Int]"* %f_begin.addr) + %3 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %this.addr + %4 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %3, i32 0, i32 1 + call void @ctor.207(%"RawPtr[Int]"* %4, %"RawPtr[Int]"* %f_end.addr) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.645(%"ContiguousMemoryRange[UInt]"* %this) #3 { +define internal void @ctor.634(%"ContiguousMemoryRange[Int]"* %this) #3 { br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %this, i32 0, i32 0 - call void @ctor.139(%"RawPtr[UInt]"* %1) - %2 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %this, i32 0, i32 1 - call void @ctor.139(%"RawPtr[UInt]"* %2) + %1 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %this, i32 0, i32 0 + call void @ctor.129(%"RawPtr[Int]"* %1) + %2 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %this, i32 0, i32 1 + call void @ctor.129(%"RawPtr[Int]"* %2) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.646(%"ContiguousMemoryRange[UInt]"* %this, %"ContiguousMemoryRange[UInt]"* %other) #3 { - %other.addr = alloca %"ContiguousMemoryRange[UInt]"* - store %"ContiguousMemoryRange[UInt]"* %other, %"ContiguousMemoryRange[UInt]"** %other.addr +define internal void @ctor.635(%"ContiguousMemoryRange[Int]"* %this, %"ContiguousMemoryRange[Int]"* %other) #3 { + %other.addr = alloca %"ContiguousMemoryRange[Int]"* + store %"ContiguousMemoryRange[Int]"* %other, %"ContiguousMemoryRange[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %this, i32 0, i32 0 - %2 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %other.addr - %3 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %2, i32 0, i32 0 - call void @ctor.218(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]"* %3) - %4 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %this, i32 0, i32 1 - %5 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %other.addr - %6 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %5, i32 0, i32 1 - call void @ctor.218(%"RawPtr[UInt]"* %4, %"RawPtr[UInt]"* %6) + %1 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %this, i32 0, i32 0 + %2 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %other.addr + %3 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %2, i32 0, i32 0 + call void @ctor.207(%"RawPtr[Int]"* %1, %"RawPtr[Int]"* %3) + %4 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %this, i32 0, i32 1 + %5 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %other.addr + %6 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %5, i32 0, i32 1 + call void @ctor.207(%"RawPtr[Int]"* %4, %"RawPtr[Int]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.647(%"ContiguousMemoryRange[UInt]"* %this) #3 { +define internal void @dtor.636(%"ContiguousMemoryRange[Int]"* %this) #3 { br label %code code: ; preds = %0 @@ -29166,45 +28560,45 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.648"(%"ContiguousMemoryRange[UInt]"* %this, %"ContiguousMemoryRange[UInt]"* %other) #3 { - %other.addr = alloca %"ContiguousMemoryRange[UInt]"* - store %"ContiguousMemoryRange[UInt]"* %other, %"ContiguousMemoryRange[UInt]"** %other.addr +define internal void @"=.637"(%"ContiguousMemoryRange[Int]"* %this, %"ContiguousMemoryRange[Int]"* %other) #3 { + %other.addr = alloca %"ContiguousMemoryRange[Int]"* + store %"ContiguousMemoryRange[Int]"* %other, %"ContiguousMemoryRange[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %this, i32 0, i32 0 - %2 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %other.addr - %3 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %2, i32 0, i32 0 - call void @"=.212"(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]"* %3) - %4 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %this, i32 0, i32 1 - %5 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %other.addr - %6 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %5, i32 0, i32 1 - call void @"=.212"(%"RawPtr[UInt]"* %4, %"RawPtr[UInt]"* %6) + %1 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %this, i32 0, i32 0 + %2 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %other.addr + %3 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %2, i32 0, i32 0 + call void @"=.201"(%"RawPtr[Int]"* %1, %"RawPtr[Int]"* %3) + %4 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %this, i32 0, i32 1 + %5 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %other.addr + %6 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %5, i32 0, i32 1 + call void @"=.201"(%"RawPtr[Int]"* %4, %"RawPtr[Int]"* %6) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.649"(%"ContiguousMemoryRange[UInt]"* %this, %"ContiguousMemoryRange[UInt]"* %other) #3 { - %this.addr = alloca %"ContiguousMemoryRange[UInt]"* - store %"ContiguousMemoryRange[UInt]"* %this, %"ContiguousMemoryRange[UInt]"** %this.addr - %other.addr = alloca %"ContiguousMemoryRange[UInt]"* - store %"ContiguousMemoryRange[UInt]"* %other, %"ContiguousMemoryRange[UInt]"** %other.addr +define internal i1 @"==.638"(%"ContiguousMemoryRange[Int]"* %this, %"ContiguousMemoryRange[Int]"* %other) #3 { + %this.addr = alloca %"ContiguousMemoryRange[Int]"* + store %"ContiguousMemoryRange[Int]"* %this, %"ContiguousMemoryRange[Int]"** %this.addr + %other.addr = alloca %"ContiguousMemoryRange[Int]"* + store %"ContiguousMemoryRange[Int]"* %other, %"ContiguousMemoryRange[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %this.addr - %2 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %1, i32 0, i32 0 - %3 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %other.addr - %4 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %3, i32 0, i32 0 - %5 = call i1 @"==.260"(%"RawPtr[UInt]"* %2, %"RawPtr[UInt]"* %4) + %1 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %this.addr + %2 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %1, i32 0, i32 0 + %3 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %other.addr + %4 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %3, i32 0, i32 0 + %5 = call i1 @"==.249"(%"RawPtr[Int]"* %2, %"RawPtr[Int]"* %4) br i1 %5, label %cond.true, label %cond.false cond.true: ; preds = %code - %6 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %this.addr - %7 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %6, i32 0, i32 1 - %8 = load %"ContiguousMemoryRange[UInt]"*, %"ContiguousMemoryRange[UInt]"** %other.addr - %9 = getelementptr inbounds %"ContiguousMemoryRange[UInt]", %"ContiguousMemoryRange[UInt]"* %8, i32 0, i32 1 - %10 = call i1 @"==.260"(%"RawPtr[UInt]"* %7, %"RawPtr[UInt]"* %9) + %6 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %this.addr + %7 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %6, i32 0, i32 1 + %8 = load %"ContiguousMemoryRange[Int]"*, %"ContiguousMemoryRange[Int]"** %other.addr + %9 = getelementptr inbounds %"ContiguousMemoryRange[Int]", %"ContiguousMemoryRange[Int]"* %8, i32 0, i32 1 + %10 = call i1 @"==.249"(%"RawPtr[Int]"* %7, %"RawPtr[Int]"* %9) br label %cond.end cond.false: ; preds = %code @@ -29216,7 +28610,7 @@ cond.end: ; preds = %cond.false, %cond.t } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.650(%"RawPtr[Char]"* %this) #3 { +define internal void @dtor.639(%"RawPtr[Char]"* %this) #3 { br label %code code: ; preds = %0 @@ -29224,7 +28618,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.651(%"RawPtr[LocString]"* %this) #3 { +define internal void @dtor.640(%"RawPtr[LocString]"* %this) #3 { br label %code code: ; preds = %0 @@ -29232,7 +28626,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.652(%"RawPtr[Token]"* %this) #3 { +define internal void @dtor.641(%"RawPtr[Token]"* %this) #3 { br label %code code: ; preds = %0 @@ -29240,7 +28634,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.653(%"RawPtr[UInt]"* %this) #3 { +define internal void @dtor.642(%"RawPtr[Int]"* %this) #3 { br label %code code: ; preds = %0 @@ -29248,7 +28642,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.654(%"NumericRangeInc[Int]"* %this) #3 { +define internal void @ctor.643(%"NumericRangeInc[Int]"* %this) #3 { br label %code code: ; preds = %0 @@ -29262,7 +28656,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.655(%"NumericRangeInc[Int]"* %this, %"NumericRangeInc[Int]"* %other) #3 { +define internal void @ctor.644(%"NumericRangeInc[Int]"* %this, %"NumericRangeInc[Int]"* %other) #3 { %other.addr = alloca %"NumericRangeInc[Int]"* store %"NumericRangeInc[Int]"* %other, %"NumericRangeInc[Int]"** %other.addr br label %code @@ -29287,7 +28681,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.656"(%"NumericRangeInc[Int]"* %this, %"NumericRangeInc[Int]"* %other) #3 { +define internal void @"=.645"(%"NumericRangeInc[Int]"* %this, %"NumericRangeInc[Int]"* %other) #3 { %other.addr = alloca %"NumericRangeInc[Int]"* store %"NumericRangeInc[Int]"* %other, %"NumericRangeInc[Int]"** %other.addr br label %code @@ -29312,7 +28706,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.657"(%"NumericRangeInc[Int]"* %this, %"NumericRangeInc[Int]"* %other) #3 { +define internal i1 @"==.646"(%"NumericRangeInc[Int]"* %this, %"NumericRangeInc[Int]"* %other) #3 { %this.addr = alloca %"NumericRangeInc[Int]"* store %"NumericRangeInc[Int]"* %this, %"NumericRangeInc[Int]"** %this.addr %other.addr = alloca %"NumericRangeInc[Int]"* @@ -29326,7 +28720,7 @@ code: ; preds = %0 %4 = load %"NumericRangeInc[Int]"*, %"NumericRangeInc[Int]"** %other.addr %5 = getelementptr inbounds %"NumericRangeInc[Int]", %"NumericRangeInc[Int]"* %4, i32 0, i32 0 %6 = load i32, i32* %5 - %7 = icmp eq i32 %3, %6 + %7 = call i1 @_Int32_opEQ(i32 %3, i32 %6) br i1 %7, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 @@ -29353,7 +28747,7 @@ cond.true1: ; preds = %code %18 = load %"NumericRangeInc[Int]"*, %"NumericRangeInc[Int]"** %other.addr %19 = getelementptr inbounds %"NumericRangeInc[Int]", %"NumericRangeInc[Int]"* %18, i32 0, i32 1 %20 = load i32, i32* %19 - %21 = icmp eq i32 %17, %20 + %21 = call i1 @_Int32_opEQ(i32 %17, i32 %20) br label %cond.end3 cond.false2: ; preds = %code @@ -29453,7 +28847,7 @@ declare double @llvm.truc.f64(double) declare double @llvm.rint.f64(double) #6 ; Function Attrs: alwaysinline nounwind -define internal void @ctor.658(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #3 { +define internal void @ctor.647(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #3 { %other.addr = alloca %"Vector[LocString]"* store %"Vector[LocString]"* %other, %"Vector[LocString]"** %other.addr br label %code @@ -29462,20 +28856,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 %2 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %3 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %2, i32 0, i32 0 - call void @ctor.576(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) + call void @ctor.561(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) %4 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 %5 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %6 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %5, i32 0, i32 1 - call void @ctor.576(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) + call void @ctor.561(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) %7 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 %8 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %9 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %8, i32 0, i32 2 - call void @ctor.576(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) + call void @ctor.561(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.659(%"Vector[LocString]"* %this) #3 { +define internal void @dtor.648(%"Vector[LocString]"* %this) #3 { br label %code code: ; preds = %0 @@ -29483,7 +28877,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.660"(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #3 { +define internal void @"=.649"(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #3 { %other.addr = alloca %"Vector[LocString]"* store %"Vector[LocString]"* %other, %"Vector[LocString]"** %other.addr br label %code @@ -29492,20 +28886,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 0 %2 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %3 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %2, i32 0, i32 0 - call void @"=.562"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) + call void @"=.547"(%"RawPtr[LocString]"* %1, %"RawPtr[LocString]"* %3) %4 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 1 %5 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %6 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %5, i32 0, i32 1 - call void @"=.562"(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) + call void @"=.547"(%"RawPtr[LocString]"* %4, %"RawPtr[LocString]"* %6) %7 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %this, i32 0, i32 2 %8 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %9 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %8, i32 0, i32 2 - call void @"=.562"(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) + call void @"=.547"(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.661"(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #3 { +define internal i1 @"==.650"(%"Vector[LocString]"* %this, %"Vector[LocString]"* %other) #3 { %this.addr = alloca %"Vector[LocString]"* store %"Vector[LocString]"* %this, %"Vector[LocString]"** %this.addr %other.addr = alloca %"Vector[LocString]"* @@ -29517,7 +28911,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %1, i32 0, i32 0 %3 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %4 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %3, i32 0, i32 0 - %5 = call i1 @"==.554"(%"RawPtr[LocString]"* %2, %"RawPtr[LocString]"* %4) + %5 = call i1 @"==.539"(%"RawPtr[LocString]"* %2, %"RawPtr[LocString]"* %4) br i1 %5, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 @@ -29525,7 +28919,7 @@ cond.true: ; preds = %cond.end3 %7 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %6, i32 0, i32 2 %8 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %9 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %8, i32 0, i32 2 - %10 = call i1 @"==.554"(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) + %10 = call i1 @"==.539"(%"RawPtr[LocString]"* %7, %"RawPtr[LocString]"* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -29540,7 +28934,7 @@ cond.true1: ; preds = %code %12 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %11, i32 0, i32 1 %13 = load %"Vector[LocString]"*, %"Vector[LocString]"** %other.addr %14 = getelementptr inbounds %"Vector[LocString]", %"Vector[LocString]"* %13, i32 0, i32 1 - %15 = call i1 @"==.554"(%"RawPtr[LocString]"* %12, %"RawPtr[LocString]"* %14) + %15 = call i1 @"==.539"(%"RawPtr[LocString]"* %12, %"RawPtr[LocString]"* %14) br label %cond.end3 cond.false2: ; preds = %code @@ -29552,7 +28946,7 @@ cond.end3: ; preds = %cond.false2, %cond. } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.662(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #3 { +define internal void @ctor.651(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #3 { %other.addr = alloca %"Vector[Char]"* store %"Vector[Char]"* %other, %"Vector[Char]"** %other.addr br label %code @@ -29561,20 +28955,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 %2 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %3 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %2, i32 0, i32 0 - call void @ctor.178(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) + call void @ctor.168(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) %4 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %5 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %6 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %5, i32 0, i32 1 - call void @ctor.178(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) + call void @ctor.168(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) %7 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 %8 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %9 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %8, i32 0, i32 2 - call void @ctor.178(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) + call void @ctor.168(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.663(%"Vector[Char]"* %this) #3 { +define internal void @dtor.652(%"Vector[Char]"* %this) #3 { br label %code code: ; preds = %0 @@ -29582,7 +28976,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.664"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #3 { +define internal void @"=.653"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #3 { %other.addr = alloca %"Vector[Char]"* store %"Vector[Char]"* %other, %"Vector[Char]"** %other.addr br label %code @@ -29591,20 +28985,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 0 %2 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %3 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %2, i32 0, i32 0 - call void @"=.186"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) + call void @"=.176"(%"RawPtr[Char]"* %1, %"RawPtr[Char]"* %3) %4 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 1 %5 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %6 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %5, i32 0, i32 1 - call void @"=.186"(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) + call void @"=.176"(%"RawPtr[Char]"* %4, %"RawPtr[Char]"* %6) %7 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %this, i32 0, i32 2 %8 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %9 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %8, i32 0, i32 2 - call void @"=.186"(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) + call void @"=.176"(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.665"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #3 { +define internal i1 @"==.654"(%"Vector[Char]"* %this, %"Vector[Char]"* %other) #3 { %this.addr = alloca %"Vector[Char]"* store %"Vector[Char]"* %this, %"Vector[Char]"** %this.addr %other.addr = alloca %"Vector[Char]"* @@ -29616,7 +29010,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %1, i32 0, i32 0 %3 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %4 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %3, i32 0, i32 0 - %5 = call i1 @"==.257"(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %4) + %5 = call i1 @"==.246"(%"RawPtr[Char]"* %2, %"RawPtr[Char]"* %4) br i1 %5, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 @@ -29624,7 +29018,7 @@ cond.true: ; preds = %cond.end3 %7 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %6, i32 0, i32 2 %8 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %9 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %8, i32 0, i32 2 - %10 = call i1 @"==.257"(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) + %10 = call i1 @"==.246"(%"RawPtr[Char]"* %7, %"RawPtr[Char]"* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -29639,7 +29033,7 @@ cond.true1: ; preds = %code %12 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %11, i32 0, i32 1 %13 = load %"Vector[Char]"*, %"Vector[Char]"** %other.addr %14 = getelementptr inbounds %"Vector[Char]", %"Vector[Char]"* %13, i32 0, i32 1 - %15 = call i1 @"==.257"(%"RawPtr[Char]"* %12, %"RawPtr[Char]"* %14) + %15 = call i1 @"==.246"(%"RawPtr[Char]"* %12, %"RawPtr[Char]"* %14) br label %cond.end3 cond.false2: ; preds = %code @@ -29651,7 +29045,7 @@ cond.end3: ; preds = %cond.false2, %cond. } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.666(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #3 { +define internal void @ctor.655(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #3 { %other.addr = alloca %"Vector[Token]"* store %"Vector[Token]"* %other, %"Vector[Token]"** %other.addr br label %code @@ -29660,20 +29054,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 %2 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %3 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %2, i32 0, i32 0 - call void @ctor.204(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) + call void @ctor.193(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) %4 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %5 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %6 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %5, i32 0, i32 1 - call void @ctor.204(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) + call void @ctor.193(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) %7 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 %8 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %9 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %8, i32 0, i32 2 - call void @ctor.204(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) + call void @ctor.193(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.667(%"Vector[Token]"* %this) #3 { +define internal void @dtor.656(%"Vector[Token]"* %this) #3 { br label %code code: ; preds = %0 @@ -29681,7 +29075,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.668"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #3 { +define internal void @"=.657"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #3 { %other.addr = alloca %"Vector[Token]"* store %"Vector[Token]"* %other, %"Vector[Token]"** %other.addr br label %code @@ -29690,20 +29084,20 @@ code: ; preds = %0 %1 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 0 %2 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %3 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %2, i32 0, i32 0 - call void @"=.198"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) + call void @"=.187"(%"RawPtr[Token]"* %1, %"RawPtr[Token]"* %3) %4 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 1 %5 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %6 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %5, i32 0, i32 1 - call void @"=.198"(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) + call void @"=.187"(%"RawPtr[Token]"* %4, %"RawPtr[Token]"* %6) %7 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %this, i32 0, i32 2 %8 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %9 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %8, i32 0, i32 2 - call void @"=.198"(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) + call void @"=.187"(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.669"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #3 { +define internal i1 @"==.658"(%"Vector[Token]"* %this, %"Vector[Token]"* %other) #3 { %this.addr = alloca %"Vector[Token]"* store %"Vector[Token]"* %this, %"Vector[Token]"** %this.addr %other.addr = alloca %"Vector[Token]"* @@ -29715,7 +29109,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %1, i32 0, i32 0 %3 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %4 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %3, i32 0, i32 0 - %5 = call i1 @"==.205"(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %4) + %5 = call i1 @"==.194"(%"RawPtr[Token]"* %2, %"RawPtr[Token]"* %4) br i1 %5, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 @@ -29723,7 +29117,7 @@ cond.true: ; preds = %cond.end3 %7 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %6, i32 0, i32 2 %8 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %9 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %8, i32 0, i32 2 - %10 = call i1 @"==.205"(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) + %10 = call i1 @"==.194"(%"RawPtr[Token]"* %7, %"RawPtr[Token]"* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -29738,7 +29132,7 @@ cond.true1: ; preds = %code %12 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %11, i32 0, i32 1 %13 = load %"Vector[Token]"*, %"Vector[Token]"** %other.addr %14 = getelementptr inbounds %"Vector[Token]", %"Vector[Token]"* %13, i32 0, i32 1 - %15 = call i1 @"==.205"(%"RawPtr[Token]"* %12, %"RawPtr[Token]"* %14) + %15 = call i1 @"==.194"(%"RawPtr[Token]"* %12, %"RawPtr[Token]"* %14) br label %cond.end3 cond.false2: ; preds = %code @@ -29750,29 +29144,29 @@ cond.end3: ; preds = %cond.false2, %cond. } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.670(%"Vector[UInt]"* %this, %"Vector[UInt]"* %other) #3 { - %other.addr = alloca %"Vector[UInt]"* - store %"Vector[UInt]"* %other, %"Vector[UInt]"** %other.addr +define internal void @ctor.659(%"Vector[Int]"* %this, %"Vector[Int]"* %other) #3 { + %other.addr = alloca %"Vector[Int]"* + store %"Vector[Int]"* %other, %"Vector[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %2 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %3 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %2, i32 0, i32 0 - call void @ctor.218(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]"* %3) - %4 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %5 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %6 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %5, i32 0, i32 1 - call void @ctor.218(%"RawPtr[UInt]"* %4, %"RawPtr[UInt]"* %6) - %7 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - %8 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %9 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %8, i32 0, i32 2 - call void @ctor.218(%"RawPtr[UInt]"* %7, %"RawPtr[UInt]"* %9) + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %2 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %3 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %2, i32 0, i32 0 + call void @ctor.207(%"RawPtr[Int]"* %1, %"RawPtr[Int]"* %3) + %4 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %5 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %6 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %5, i32 0, i32 1 + call void @ctor.207(%"RawPtr[Int]"* %4, %"RawPtr[Int]"* %6) + %7 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + %8 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %9 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %8, i32 0, i32 2 + call void @ctor.207(%"RawPtr[Int]"* %7, %"RawPtr[Int]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.671(%"Vector[UInt]"* %this) #3 { +define internal void @dtor.660(%"Vector[Int]"* %this) #3 { br label %code code: ; preds = %0 @@ -29780,49 +29174,49 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.672"(%"Vector[UInt]"* %this, %"Vector[UInt]"* %other) #3 { - %other.addr = alloca %"Vector[UInt]"* - store %"Vector[UInt]"* %other, %"Vector[UInt]"** %other.addr +define internal void @"=.661"(%"Vector[Int]"* %this, %"Vector[Int]"* %other) #3 { + %other.addr = alloca %"Vector[Int]"* + store %"Vector[Int]"* %other, %"Vector[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 0 - %2 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %3 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %2, i32 0, i32 0 - call void @"=.212"(%"RawPtr[UInt]"* %1, %"RawPtr[UInt]"* %3) - %4 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 1 - %5 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %6 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %5, i32 0, i32 1 - call void @"=.212"(%"RawPtr[UInt]"* %4, %"RawPtr[UInt]"* %6) - %7 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %this, i32 0, i32 2 - %8 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %9 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %8, i32 0, i32 2 - call void @"=.212"(%"RawPtr[UInt]"* %7, %"RawPtr[UInt]"* %9) + %1 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 0 + %2 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %3 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %2, i32 0, i32 0 + call void @"=.201"(%"RawPtr[Int]"* %1, %"RawPtr[Int]"* %3) + %4 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 1 + %5 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %6 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %5, i32 0, i32 1 + call void @"=.201"(%"RawPtr[Int]"* %4, %"RawPtr[Int]"* %6) + %7 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %this, i32 0, i32 2 + %8 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %9 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %8, i32 0, i32 2 + call void @"=.201"(%"RawPtr[Int]"* %7, %"RawPtr[Int]"* %9) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.673"(%"Vector[UInt]"* %this, %"Vector[UInt]"* %other) #3 { - %this.addr = alloca %"Vector[UInt]"* - store %"Vector[UInt]"* %this, %"Vector[UInt]"** %this.addr - %other.addr = alloca %"Vector[UInt]"* - store %"Vector[UInt]"* %other, %"Vector[UInt]"** %other.addr +define internal i1 @"==.662"(%"Vector[Int]"* %this, %"Vector[Int]"* %other) #3 { + %this.addr = alloca %"Vector[Int]"* + store %"Vector[Int]"* %this, %"Vector[Int]"** %this.addr + %other.addr = alloca %"Vector[Int]"* + store %"Vector[Int]"* %other, %"Vector[Int]"** %other.addr br label %code code: ; preds = %0 - %1 = load %"Vector[UInt]"*, %"Vector[UInt]"** %this.addr - %2 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %1, i32 0, i32 0 - %3 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %4 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %3, i32 0, i32 0 - %5 = call i1 @"==.260"(%"RawPtr[UInt]"* %2, %"RawPtr[UInt]"* %4) + %1 = load %"Vector[Int]"*, %"Vector[Int]"** %this.addr + %2 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %1, i32 0, i32 0 + %3 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %4 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %3, i32 0, i32 0 + %5 = call i1 @"==.249"(%"RawPtr[Int]"* %2, %"RawPtr[Int]"* %4) br i1 %5, label %cond.true1, label %cond.false2 cond.true: ; preds = %cond.end3 - %6 = load %"Vector[UInt]"*, %"Vector[UInt]"** %this.addr - %7 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %6, i32 0, i32 2 - %8 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %9 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %8, i32 0, i32 2 - %10 = call i1 @"==.260"(%"RawPtr[UInt]"* %7, %"RawPtr[UInt]"* %9) + %6 = load %"Vector[Int]"*, %"Vector[Int]"** %this.addr + %7 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %6, i32 0, i32 2 + %8 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %9 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %8, i32 0, i32 2 + %10 = call i1 @"==.249"(%"RawPtr[Int]"* %7, %"RawPtr[Int]"* %9) br label %cond.end cond.false: ; preds = %cond.end3 @@ -29833,11 +29227,11 @@ cond.end: ; preds = %cond.false, %cond.t ret i1 %cond.res4 cond.true1: ; preds = %code - %11 = load %"Vector[UInt]"*, %"Vector[UInt]"** %this.addr - %12 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %11, i32 0, i32 1 - %13 = load %"Vector[UInt]"*, %"Vector[UInt]"** %other.addr - %14 = getelementptr inbounds %"Vector[UInt]", %"Vector[UInt]"* %13, i32 0, i32 1 - %15 = call i1 @"==.260"(%"RawPtr[UInt]"* %12, %"RawPtr[UInt]"* %14) + %11 = load %"Vector[Int]"*, %"Vector[Int]"** %this.addr + %12 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %11, i32 0, i32 1 + %13 = load %"Vector[Int]"*, %"Vector[Int]"** %other.addr + %14 = getelementptr inbounds %"Vector[Int]", %"Vector[Int]"* %13, i32 0, i32 1 + %15 = call i1 @"==.249"(%"RawPtr[Int]"* %12, %"RawPtr[Int]"* %14) br label %cond.end3 cond.false2: ; preds = %code @@ -29857,7 +29251,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.674(%ErrorReporter* %this) #3 { +define internal void @dtor.663(%ErrorReporter* %this) #3 { br label %code code: ; preds = %0 @@ -29865,7 +29259,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @reportError.675(%ErrorReporter* %obj, %Location %loc, %StringRef %msg) #4 { +define internal void @reportError.664(%ErrorReporter* %obj, %Location %loc, %StringRef %msg) #4 { %loc.addr = alloca %Location store %Location %loc, %Location* %loc.addr %msg.addr = alloca %StringRef @@ -29877,12 +29271,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %ErrorReporter, %ErrorReporter* %obj, i32 0, i32 0 %3 = load %UntypedPtr, %UntypedPtr* %2 %4 = load %StringRef, %StringRef* %msg.addr - call void @"().438"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) + call void @"().427"(%"FunctionPtr3[Void, UntypedPtr, Location const, StringRef]"* %1, %UntypedPtr %3, %Location* %loc.addr, %StringRef %4) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.676(%AstBuilder* %this) #3 { +define internal void @dtor.665(%AstBuilder* %this) #3 { br label %code code: ; preds = %0 @@ -29901,7 +29295,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isalnum(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -29919,7 +29313,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isblank(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -29937,7 +29331,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @iscntrl(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -29955,7 +29349,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isgraph(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -29973,7 +29367,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @islower(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -29991,7 +29385,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isprint(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -30009,7 +29403,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @ispunct(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -30027,7 +29421,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isspace(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -30045,7 +29439,7 @@ code: ; preds = %0 call void @_ass_32_8z(i32* %tmp.this, i8 %1) %2 = load i32, i32* %tmp.this %3 = call i32 @isupper(i32 %2) - %4 = icmp ne i32 0, %3 + %4 = call i1 @_Int32_opNE(i32 0, i32 %3) ret i1 %4 } @@ -30067,34 +29461,34 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @ctor.677(%File* %this) #4 { +define internal void @ctor.666(%File* %this) #4 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %File, %File* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.678(%File* %this, %File* %other) #4 { +define internal void @ctor.667(%File* %this, %File* %other) #4 { %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 %1 = getelementptr inbounds %File, %File* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %1) + call void @ctor.46(%UntypedPtr* %1) %2 = getelementptr inbounds %File, %File* %this, i32 0, i32 0 %3 = getelementptr inbounds %File, %File* %other, i32 0, i32 0 call void @"="(%UntypedPtr* %2, %UntypedPtr* %3) %4 = getelementptr inbounds %File, %File* %other, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %tmp.this) + call void @ctor.46(%UntypedPtr* %tmp.this) call void @"="(%UntypedPtr* %4, %UntypedPtr* %tmp.this) ret void } ; Function Attrs: inlinehint nounwind -define internal void @dtor.679(%File* %this) #4 { +define internal void @dtor.668(%File* %this) #4 { br label %code code: ; preds = %0 @@ -30121,7 +29515,7 @@ if_then: ; preds = %if_block if_end: ; preds = %if_then, %if_block %3 = getelementptr inbounds %File, %File* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %tmp.this) + call void @ctor.46(%UntypedPtr* %tmp.this) call void @"="(%UntypedPtr* %3, %UntypedPtr* %tmp.this) ret void } @@ -30133,8 +29527,8 @@ define internal i1 @isOpen(%File* %this) #4 { code: ; preds = %0 %1 = getelementptr inbounds %File, %File* %this, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %tmp.this) - %2 = call i1 @"==.326"(%UntypedPtr* %1, %UntypedPtr* %tmp.this) + call void @ctor.46(%UntypedPtr* %tmp.this) + %2 = call i1 @"==.315"(%UntypedPtr* %1, %UntypedPtr* %tmp.this) %3 = xor i1 true, %2 ret i1 %3 } @@ -30142,7 +29536,7 @@ code: ; preds = %0 declare void @fclose(%File) ; Function Attrs: inlinehint nounwind -define internal void @"=.680"(%File* %this, %File* %other) #4 { +define internal void @"=.669"(%File* %this, %File* %other) #4 { %tmp.this = alloca %UntypedPtr br label %code @@ -30151,7 +29545,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %File, %File* %other, i32 0, i32 0 call void @"="(%UntypedPtr* %1, %UntypedPtr* %2) %3 = getelementptr inbounds %File, %File* %other, i32 0, i32 0 - call void @ctor.56(%UntypedPtr* %tmp.this) + call void @ctor.46(%UntypedPtr* %tmp.this) call void @"="(%UntypedPtr* %3, %UntypedPtr* %tmp.this) ret void } @@ -30174,7 +29568,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i32 @flush.681(%File* %this) #4 { +define internal i32 @flush.670(%File* %this) #4 { br label %code code: ; preds = %0 @@ -30197,48 +29591,42 @@ cond_end: ; preds = %cond_alt2, %cond_al ; Function Attrs: inlinehint nounwind define internal void @readLine(%String* sret %_result, %File* %this) #4 { %res = alloca %String - %tmp.this = alloca i64 %cstr = alloca i8* - %tmp.this1 = alloca %UntypedPtr - %tmp.this2 = alloca i64 + %tmp.this = alloca %UntypedPtr br label %code code: ; preds = %0 - store i64 256, i64* %tmp.this - %1 = load i64, i64* %tmp.this - call void @ctor.177(%String* %res, i64 %1) - store i64 0, i64* %tmp.this2 - %2 = load i64, i64* %tmp.this2 - %3 = call i8* @"().332"(%String* %res, i64 %2) - call void @ctor.67(%UntypedPtr* %tmp.this1, i8* %3) - %4 = load %UntypedPtr, %UntypedPtr* %tmp.this1 - %5 = load %File, %File* %this - %6 = call i8* @fgets(%UntypedPtr %4, i32 256, %File %5) - store i8* %6, i8** %cstr + call void @ctor.167(%String* %res, i32 256) + %1 = call i8* @"().321"(%String* %res, i32 0) + call void @ctor.57(%UntypedPtr* %tmp.this, i8* %1) + %2 = load %UntypedPtr, %UntypedPtr* %tmp.this + %3 = load %File, %File* %this + %4 = call i8* @fgets(%UntypedPtr %2, i32 256, %File %3) + store i8* %4, i8** %cstr br label %if_block if_block: ; preds = %code - %7 = load i8*, i8** %cstr - %8 = call i1 @implOpRefEQ(i8* %7, i8* null) - br i1 %8, label %if_then, label %if_else + %5 = load i8*, i8** %cstr + %6 = call i1 @implOpRefEQ(i8* %5, i8* null) + br i1 %6, label %if_then, label %if_else if_then: ; preds = %if_block call void @clear(%String* %res) br label %if_end if_else: ; preds = %if_block - %9 = load i8*, i8** %cstr - %10 = call i64 @cStringLen(i8* %9) - call void @resize(%String* %res, i64 %10) + %7 = load i8*, i8** %cstr + %8 = call i32 @cStringLen(i8* %7) + call void @resize(%String* %res, i32 %8) br label %if_end if_end: ; preds = %if_else, %if_then - call void @ctor.175(%String* %_result, %String* %res) - call void @dtor.250(%String* %res) + call void @ctor.165(%String* %_result, %String* %res) + call void @dtor.239(%String* %res) ret void dumy_block: ; No predecessors! - call void @dtor.250(%String* %res) + call void @dtor.239(%String* %res) ret void } @@ -30251,49 +29639,42 @@ define internal i32 @write(%File* %this, %StringRef %data) #4 { %res = alloca i32 %tmp.this = alloca %UntypedPtr %tmp.this1 = alloca i32 - %tmp.this2 = alloca i32 br label %code code: ; preds = %0 %1 = getelementptr inbounds %StringRef, %StringRef* %data.addr, i32 0, i32 0 %2 = load %UntypedPtr, %UntypedPtr* %1 - call void @ctor.55(%UntypedPtr* %tmp.this, %UntypedPtr %2) + call void @ctor.45(%UntypedPtr* %tmp.this, %UntypedPtr %2) %3 = load %UntypedPtr, %UntypedPtr* %tmp.this - store i32 1, i32* %tmp.this1 - %4 = load i32, i32* %tmp.this1 - %5 = load %StringRef, %StringRef* %data.addr - %6 = call i64 @size(%StringRef %5) - %7 = trunc i64 %6 to i32 - store i32 %7, i32* %tmp.this2 - %8 = load i32, i32* %tmp.this2 - %9 = load %File, %File* %this - %10 = call i32 @fwrite(%UntypedPtr %3, i32 %4, i32 %8, %File %9) - store i32 %10, i32* %res - %11 = load i32, i32* %res - ret i32 %11 + %4 = load %StringRef, %StringRef* %data.addr + %5 = call i32 @size(%StringRef %4) + store i32 %5, i32* %tmp.this1 + %6 = load i32, i32* %tmp.this1 + %7 = load %File, %File* %this + %8 = call i32 @fwrite(%UntypedPtr %3, i32 1, i32 %6, %File %7) + store i32 %8, i32* %res + %9 = load i32, i32* %res + ret i32 %9 } declare i32 @fwrite(%UntypedPtr, i32, i32, %File) ; Function Attrs: inlinehint nounwind -define internal i32 @size.682(%File* %this) #4 { - %tmp.this = alloca i64 +define internal i32 @size.671(%File* %this) #4 { %res = alloca i32 br label %code code: ; preds = %0 %1 = load %File, %File* %this - store i64 0, i64* %tmp.this - %2 = load i64, i64* %tmp.this - call void @fseek(%File %1, i64 %2, i32 2) - %3 = load %File, %File* %this - %4 = call i64 @ftell(%File %3) - %5 = trunc i64 %4 to i32 - store i32 %5, i32* %res - %6 = load %File, %File* %this - call void @rewind(%File %6) - %7 = load i32, i32* %res - ret i32 %7 + call void @fseek(%File %1, i64 0, i32 2) + %2 = load %File, %File* %this + %3 = call i64 @ftell(%File %2) + %4 = trunc i64 %3 to i32 + store i32 %4, i32* %res + %5 = load %File, %File* %this + call void @rewind(%File %5) + %6 = load i32, i32* %res + ret i32 %6 } declare void @fseek(%File, i64, i32) @@ -30303,16 +29684,16 @@ declare i64 @ftell(%File) declare void @rewind(%File) ; Function Attrs: inlinehint nounwind -define internal void @all.683(%FileRange* sret %_result, %File* %this) #4 { +define internal void @all.672(%FileRange* sret %_result, %File* %this) #4 { br label %code code: ; preds = %0 - call void @ctor.684(%FileRange* %_result, %File* %this) + call void @ctor.673(%FileRange* %_result, %File* %this) ret void } ; Function Attrs: inlinehint nounwind -define internal void @ctor.684(%FileRange* %this, %File* %file) #4 { +define internal void @ctor.673(%FileRange* %this, %File* %file) #4 { br label %code code: ; preds = %0 @@ -30350,7 +29731,7 @@ if_end: ; preds = %if_then, %if_block } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.685(%FileRange* %this) #3 { +define internal void @ctor.674(%FileRange* %this) #3 { br label %code code: ; preds = %0 @@ -30364,7 +29745,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.686(%FileRange* %this, %FileRange* %other) #3 { +define internal void @ctor.675(%FileRange* %this, %FileRange* %other) #3 { %other.addr = alloca %FileRange* store %FileRange* %other, %FileRange** %other.addr br label %code @@ -30389,7 +29770,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.687(%FileRange* %this) #3 { +define internal void @dtor.676(%FileRange* %this) #3 { br label %code code: ; preds = %0 @@ -30397,7 +29778,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal void @"=.688"(%FileRange* %this, %FileRange* %other) #3 { +define internal void @"=.677"(%FileRange* %this, %FileRange* %other) #3 { %other.addr = alloca %FileRange* store %FileRange* %other, %FileRange** %other.addr br label %code @@ -30422,7 +29803,7 @@ code: ; preds = %0 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.689"(%FileRange* %this, %FileRange* %other) #3 { +define internal i1 @"==.678"(%FileRange* %this, %FileRange* %other) #3 { %this.addr = alloca %FileRange* store %FileRange* %this, %FileRange** %this.addr %other.addr = alloca %FileRange* @@ -30477,7 +29858,7 @@ cond.end3: ; preds = %cond.false2, %cond. } ; Function Attrs: inlinehint nounwind -define internal i1 @isEmpty.690(%FileRange* %s) #4 { +define internal i1 @isEmpty.679(%FileRange* %s) #4 { br label %code code: ; preds = %0 @@ -30487,7 +29868,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal i8 @front.691(%FileRange* %s) #4 { +define internal i8 @front.680(%FileRange* %s) #4 { br label %code code: ; preds = %0 @@ -30497,7 +29878,7 @@ code: ; preds = %0 } ; Function Attrs: inlinehint nounwind -define internal void @popFront.692(%FileRange* %s) #4 { +define internal void @popFront.681(%FileRange* %s) #4 { br label %code code: ; preds = %0 @@ -30526,17 +29907,17 @@ if_end: ; preds = %if_then, %if_block declare i32 @fread(%UntypedPtr, i32, i32, %File) ; Function Attrs: alwaysinline nounwind -define internal void @ctor.693(%FileCharSource* %this) #3 { +define internal void @ctor.682(%FileCharSource* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 - call void @ctor.677(%File* %1) + call void @ctor.666(%File* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @ctor.694(%FileCharSource* %this, %FileCharSource* %other) #3 { +define internal void @ctor.683(%FileCharSource* %this, %FileCharSource* %other) #3 { %other.addr = alloca %FileCharSource* store %FileCharSource* %other, %FileCharSource** %other.addr br label %code @@ -30545,22 +29926,22 @@ code: ; preds = %0 %1 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 %2 = load %FileCharSource*, %FileCharSource** %other.addr %3 = getelementptr inbounds %FileCharSource, %FileCharSource* %2, i32 0, i32 0 - call void @ctor.678(%File* %1, %File* %3) + call void @ctor.667(%File* %1, %File* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @dtor.695(%FileCharSource* %this) #3 { +define internal void @dtor.684(%FileCharSource* %this) #3 { br label %code code: ; preds = %0 %1 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 - call void @dtor.679(%File* %1) + call void @dtor.668(%File* %1) ret void } ; Function Attrs: alwaysinline nounwind -define internal void @"=.696"(%FileCharSource* %this, %FileCharSource* %other) #3 { +define internal void @"=.685"(%FileCharSource* %this, %FileCharSource* %other) #3 { %other.addr = alloca %FileCharSource* store %FileCharSource* %other, %FileCharSource** %other.addr br label %code @@ -30569,12 +29950,12 @@ code: ; preds = %0 %1 = getelementptr inbounds %FileCharSource, %FileCharSource* %this, i32 0, i32 0 %2 = load %FileCharSource*, %FileCharSource** %other.addr %3 = getelementptr inbounds %FileCharSource, %FileCharSource* %2, i32 0, i32 0 - call void @"=.680"(%File* %1, %File* %3) + call void @"=.669"(%File* %1, %File* %3) ret void } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.697"(%FileCharSource* %this, %FileCharSource* %other) #3 { +define internal i1 @"==.686"(%FileCharSource* %this, %FileCharSource* %other) #3 { %this.addr = alloca %FileCharSource* store %FileCharSource* %this, %FileCharSource** %this.addr %other.addr = alloca %FileCharSource* @@ -30586,12 +29967,12 @@ code: ; preds = %0 %2 = getelementptr inbounds %FileCharSource, %FileCharSource* %1, i32 0, i32 0 %3 = load %FileCharSource*, %FileCharSource** %other.addr %4 = getelementptr inbounds %FileCharSource, %FileCharSource* %3, i32 0, i32 0 - %5 = call i1 @"==.698"(%File* %2, %File* %4) + %5 = call i1 @"==.687"(%File* %2, %File* %4) ret i1 %5 } ; Function Attrs: alwaysinline nounwind -define internal i1 @"==.698"(%File* %this, %File* %other) #3 { +define internal i1 @"==.687"(%File* %this, %File* %other) #3 { %this.addr = alloca %File* store %File* %this, %File** %this.addr %other.addr = alloca %File* @@ -30603,7 +29984,7 @@ code: ; preds = %0 %2 = getelementptr inbounds %File, %File* %1, i32 0, i32 0 %3 = load %File*, %File** %other.addr %4 = getelementptr inbounds %File, %File* %3, i32 0, i32 0 - %5 = call i1 @"==.326"(%UntypedPtr* %2, %UntypedPtr* %4) + %5 = call i1 @"==.315"(%UntypedPtr* %2, %UntypedPtr* %4) ret i1 %5 } diff --git a/src/SparrowFrontend/Grammar/rangeWithLookahead.spr b/src/SparrowFrontend/Grammar/rangeWithLookahead.spr index 75342b48..b7f5d949 100644 --- a/src/SparrowFrontend/Grammar/rangeWithLookahead.spr +++ b/src/SparrowFrontend/Grammar/rangeWithLookahead.spr @@ -33,7 +33,7 @@ fun popFront(this: !RangeWithLookahead) if (buffer.isEmpty) && !!source buffer += (source++) -fun peek(this: !RangeWithLookahead, n: UInt): RetType +fun peek(this: !RangeWithLookahead, n: Int): RetType // If not enough elements in the buffer, add them now while n >= buffer.size && !!source buffer += (source++) @@ -42,7 +42,7 @@ fun peek(this: !RangeWithLookahead, n: UInt): RetType else return RetType() // not enough elements in the source -fun hasLessThan(this: !RangeWithLookahead, n: UInt): Bool +fun hasLessThan(this: !RangeWithLookahead, n: Int): Bool // Try to fill the buffer with the amount of elements while n >= buffer.size && !!source buffer += (source++) diff --git a/src/SparrowFrontend/Grammar/scanner.spr b/src/SparrowFrontend/Grammar/scanner.spr index d3968ee5..9758839f 100644 --- a/src/SparrowFrontend/Grammar/scanner.spr +++ b/src/SparrowFrontend/Grammar/scanner.spr @@ -96,11 +96,11 @@ package _Impl fun peekChar(this: !SparrowScanner): Char return _src.source peek 1 - fun peekChar(this: !SparrowScanner, n: UInt): Char + fun peekChar(this: !SparrowScanner, n: Int): Char return _src.source peek n /// Check if the source to has less than the given number of characters - fun hasLessThan(this: !SparrowScanner, n: UInt): Bool + fun hasLessThan(this: !SparrowScanner, n: Int): Bool return _src.source hasLessThan n /// Advances the input stream while the predicate matches @@ -369,7 +369,7 @@ package _Impl _src advance 2 _curToken.intData = consumeDigits(_src, 2, _curToken.data) else if ch == '0'.char && ch2 == 'o'.char - _src advance 1 + _src advance 2 _curToken.intData = consumeDigits(_src, 8, _curToken.data) else // At this point we assume we are not parsing a floating point number @@ -395,6 +395,11 @@ package _Impl ch = toLower(*_src) if ch == 'e'.char this advanceAndCapture1 + // exponent sign + ch = *_src + if ch == '+'.char || ch == '-'.char + this advanceAndCapture1 + // exponent number this advanceAndCaptureDigit \isDigit // Suffix for floats -- don't capture these @@ -424,7 +429,7 @@ package _Impl // Compute the value and return the token type if isFloating _curToken.data += Char(0) - _curToken.floatData = (_curToken.data.asStringRef asDouble) + _curToken.floatData = (_curToken.data.asStringRef asFloat) _curToken.data popBack return ife(isLong, tkDOUBLE_LITERAL, tkFLOAT_LITERAL) @@ -436,20 +441,20 @@ package _Impl fun getDigitVal(c: Char) = (Int(c) - Int('0'.char)) fun getXdigitVal(c: Char) = ife(isDigit(c), Int(c) - Int('0'.char), 10 + Int(toLower(c)) - Int('a'.char)) - fun consumeDigits(r: !Range, base: ULong, capture: !String): ULong - var res: ULong = 0 + fun consumeDigits(r: !Range, base: Int, capture: !String): UInt64 + var res: UInt64 = 0UL if base == 16 while !!r && (isXdigit(*r) || *r == '_'.char) ; r.popFront if *r != '_'.char capture += *r - res *= base - res += getXdigitVal(*r) + res *= UInt64(base) + res += UInt64(getXdigitVal(*r)) else while !!r && (isXdigit(*r) || *r == '_'.char) ; r.popFront if *r != '_'.char capture += *r - res *= base - res += getDigitVal(*r) + res *= UInt64(base) + res += UInt64(getDigitVal(*r)) return res fun checkEscapeChar(this: !SparrowScanner): Bool diff --git a/src/SparrowFrontend/Grammar/token.spr b/src/SparrowFrontend/Grammar/token.spr index d2f35356..736c06be 100644 --- a/src/SparrowFrontend/Grammar/token.spr +++ b/src/SparrowFrontend/Grammar/token.spr @@ -11,8 +11,8 @@ datatype Token loc: Location type: TokenType data: String - intData: ULong - floatData: Double + intData: UInt64 + floatData: Float /// Concept modeling the output of the scanner /// It's basically a range of tokens diff --git a/src/SparrowFrontend/Helpers/CommonCode.cpp b/src/SparrowFrontend/Helpers/CommonCode.cpp index 0bf48a17..30dfcd79 100644 --- a/src/SparrowFrontend/Helpers/CommonCode.cpp +++ b/src/SparrowFrontend/Helpers/CommonCode.cpp @@ -204,6 +204,7 @@ Node* SprFrontend::createTempVarConstruct(const Location& loc, CompilationContex CHECK(loc, constructAction->nodeKind == nkFeatherExpFunCall); Node* funCall = constructAction; CHECK(loc, Nest_nodeArraySize(funCall->children) != 0); + bool varRefGiven = varRef != nullptr; if (!varRef) { varRef = Feather_mkVarRef(loc, var); Nest_setContext(varRef, context); @@ -219,8 +220,12 @@ Node* SprFrontend::createTempVarConstruct(const Location& loc, CompilationContex destructAction = Feather_mkTempDestructAction(loc, dtorCall); } + // Make sure the resulting type is temp + Node* tmpVarRef = varRefGiven ? varRef + : static_cast( + Feather::VarRefExp::create(loc, var, typeKindTemp)); Node* res = - Feather_mkNodeList(loc, fromIniList({var, constructAction, destructAction, varRef})); + Feather_mkNodeList(loc, fromIniList({var, constructAction, destructAction, tmpVarRef})); Nest_setContext(res, context); if (!Nest_computeType(res)) return nullptr; diff --git a/src/SparrowFrontend/Helpers/Ct.cpp b/src/SparrowFrontend/Helpers/Ct.cpp index b906e84e..571f3798 100644 --- a/src/SparrowFrontend/Helpers/Ct.cpp +++ b/src/SparrowFrontend/Helpers/Ct.cpp @@ -85,6 +85,3 @@ int SprFrontend::getIntCtValue(Node* val) { return evalValue(val, StdDef::t char* SprFrontend::getByteRefCtValue(Node* val) { return evalValue(val, StdDef::typeRefByte); } -size_t SprFrontend::getSizeTypeCtValue(Node* val) { - return evalValue(val, StdDef::typeSizeType); -} diff --git a/src/SparrowFrontend/Helpers/Ct.h b/src/SparrowFrontend/Helpers/Ct.h index b761c149..52437f96 100644 --- a/src/SparrowFrontend/Helpers/Ct.h +++ b/src/SparrowFrontend/Helpers/Ct.h @@ -13,5 +13,4 @@ StringRef getStringCtValue(Node* val); bool getBoolCtValue(Node* val); int getIntCtValue(Node* val); char* getByteRefCtValue(Node* val); -size_t getSizeTypeCtValue(Node* val); } // namespace SprFrontend diff --git a/src/SparrowFrontend/Helpers/Impl/Intrinsics.cpp b/src/SparrowFrontend/Helpers/Impl/Intrinsics.cpp index 63762559..934b571b 100644 --- a/src/SparrowFrontend/Helpers/Impl/Intrinsics.cpp +++ b/src/SparrowFrontend/Helpers/Impl/Intrinsics.cpp @@ -178,10 +178,10 @@ NodeHandle impl_convertsTo(CompilationContext* context, const Location& loc, Nod NodeHandle impl_staticBuffer(CompilationContext* context, const Location& loc, NodeRange args) { CHECK(loc, args.size() == 1); - size_t size = getSizeTypeCtValue(args[0]); + int size = getIntCtValue(args[0]); - if (size > numeric_limits::max()) - REP_ERROR_RET(nullptr, loc, "Size of static buffer is too large"); + if (size < 0) + REP_ERROR_RET(nullptr, loc, "Size of static buffer is negative (%1%)") % size; Type arrType = Feather_getArrayType(StdDef::typeByte, (size_t)size); return createTypeNode(context, loc, arrType); diff --git a/src/SparrowFrontend/Helpers/SprTypeTraits.cpp b/src/SparrowFrontend/Helpers/SprTypeTraits.cpp index 818fa71a..50abf083 100644 --- a/src/SparrowFrontend/Helpers/SprTypeTraits.cpp +++ b/src/SparrowFrontend/Helpers/SprTypeTraits.cpp @@ -135,6 +135,10 @@ Type getTypeValueImpl(Node* typeNode, bool reportErrors = false) { } // namespace Type SprFrontend::commonType(CompilationContext* context, Type t1, Type t2) { + // Remove categories + t1 = removeCategoryIfPresent(t1); + t2 = removeCategoryIfPresent(t2); + // Check if the types are the same if (t1 == t2) return t1; diff --git a/src/SparrowFrontend/Helpers/StdDef.cpp b/src/SparrowFrontend/Helpers/StdDef.cpp index 86c47d6f..a64822e1 100644 --- a/src/SparrowFrontend/Helpers/StdDef.cpp +++ b/src/SparrowFrontend/Helpers/StdDef.cpp @@ -18,13 +18,11 @@ TypeWithStorage StdDef::typeNull = nullptr; TypeWithStorage StdDef::typeBool = nullptr; TypeWithStorage StdDef::typeByte = nullptr; TypeWithStorage StdDef::typeInt = nullptr; -TypeWithStorage StdDef::typeSizeType = nullptr; TypeWithStorage StdDef::typeStringRef = nullptr; TypeWithStorage StdDef::typeRefType = nullptr; TypeWithStorage StdDef::typeRefByte = nullptr; TypeWithStorage StdDef::typeRefInt = nullptr; -TypeWithStorage StdDef::typeSizeTypeCt = nullptr; Node* StdDef::clsType = nullptr; Node* StdDef::clsNull = nullptr; @@ -69,15 +67,12 @@ void SprFrontend::checkStdClass(Node* cls) { } else if (clsName == "Bool") { StdDef::clsBool = cls; StdDef::typeBool = Feather_getDataType(cls, 0, modeRt); - } else if (clsName == "Byte") { + } else if (clsName == "Int8") { StdDef::typeByte = Feather_getDataType(cls, 0, modeRt); StdDef::typeRefByte = Feather_getDataType(cls, 1, modeRt); } else if (clsName == "Int") { StdDef::typeInt = Feather_getDataType(cls, 0, modeRt); StdDef::typeRefInt = Feather_getDataType(cls, 1, modeRt); - } else if (clsName == "SizeType") { - StdDef::typeSizeType = Feather_getDataType(cls, 0, modeRt); - StdDef::typeSizeTypeCt = Feather_getDataType(cls, 0, modeCt); } else if (clsName == "Type") { StdDef::typeType = Feather_getDataType(cls, 0, modeRt); StdDef::typeRefType = Feather_getDataType(cls, 1, modeRt); @@ -86,10 +81,9 @@ void SprFrontend::checkStdClass(Node* cls) { classesFound = StdDef::typeVoid != nullptr && StdDef::typeNull != nullptr && StdDef::typeBool != nullptr && StdDef::typeByte != nullptr && - StdDef::typeInt != nullptr && StdDef::typeSizeType != nullptr && - StdDef::typeType != nullptr && StdDef::typeStringRef != nullptr && - StdDef::typeRefByte != nullptr && StdDef::typeRefType != nullptr && - StdDef::typeSizeTypeCt != nullptr; + StdDef::typeInt != nullptr && StdDef::typeType != nullptr && + StdDef::typeStringRef != nullptr && StdDef::typeRefByte != nullptr && + StdDef::typeRefType != nullptr; } void SprFrontend::checkStdFunction(Node* fun) { diff --git a/src/SparrowFrontend/Helpers/StdDef.h b/src/SparrowFrontend/Helpers/StdDef.h index 430a36a6..0e9ca511 100644 --- a/src/SparrowFrontend/Helpers/StdDef.h +++ b/src/SparrowFrontend/Helpers/StdDef.h @@ -14,13 +14,11 @@ extern TypeWithStorage typeNull; extern TypeWithStorage typeBool; extern TypeWithStorage typeByte; extern TypeWithStorage typeInt; -extern TypeWithStorage typeSizeType; extern TypeWithStorage typeStringRef; extern TypeWithStorage typeRefType; extern TypeWithStorage typeRefByte; extern TypeWithStorage typeRefInt; -extern TypeWithStorage typeSizeTypeCt; extern Node* clsType; extern Node* clsNull; diff --git a/src/SparrowFrontend/IntMods.cpp b/src/SparrowFrontend/IntMods.cpp index c32396f9..bdee0708 100644 --- a/src/SparrowFrontend/IntMods.cpp +++ b/src/SparrowFrontend/IntMods.cpp @@ -22,6 +22,12 @@ namespace { const int generatedOverloadPrio = -100; const int defaultOverloadPrio = 0; +//! Checks if the given field indicates a true reference type (without cat) +bool fieldIsRef(Node* field) { + auto t = Feather::removeCategoryIfPresent(Type(field->type)); + return t.numReferences() > 0; +} + // Add to a local space an operator call void addOperatorCall(Node* dest, bool reverse, Node* operand1, const string& op, Node* operand2) { Node* call = mkOperatorCall(dest->location, operand1, StringRef(op), operand2); @@ -106,7 +112,7 @@ Node* generateAssociatedFun( : nullptr); string oper = op; - if (field->type->numReferences > 0) { + if (fieldIsRef(field)) { if (op == "=" || op == "ctor") { oper = ":="; // Transform into ref assignment if (!rhs) @@ -159,7 +165,7 @@ bool generateInitCtor(Node* parent) { // Left-hand side: field-ref to the current field Node* lhs = Feather_mkFieldRef(loc, Feather_mkMemLoad(loc, thisRef), field); - string oper = t.numReferences() > 0 ? ":=" : "ctor"; + string oper = fieldIsRef(field) ? ":=" : "ctor"; addOperatorCall(body, false, lhs, oper, init); } @@ -183,7 +189,7 @@ Node* generateEqualityCheckFun(Node* parent) { Node* otherFieldRef = Feather_mkFieldRef( loc, Feather_mkMemLoad(loc, mkIdentifier(loc, StringRef("other"))), field); - const char* op = (field->type->numReferences == 0) ? "==" : "==="; + const char* op = fieldIsRef(field) ? "===" : "=="; Node* curExp = mkOperatorCall(loc, fieldRef, StringRef(op), otherFieldRef); if (!exp) exp = curExp; @@ -237,7 +243,9 @@ bool canHaveCtorDtor(Node* field) { /// /// It will search only the instructions directly inside the given local space, or in a child local /// space It will not search inside conditionals, or other instructions -bool hasCtorCall(Node* inSpace, bool checkThis, Node* forField) { +/// +/// Can also be applied to finding destructors +bool hasCtorCall(Node* inSpace, bool checkThis, Node* forField, StringRef funName = "ctor") { // Check all the items in the local space for (Node* n : inSpace->children) { if (!Nest_computeType(n)) @@ -257,7 +265,7 @@ bool hasCtorCall(Node* inSpace, bool checkThis, Node* forField) { if (n->nodeKind != nkFeatherExpFunCall) continue; Node* funDecl = at(n->referredNodes, 0); - if (Feather_getName(funDecl) != StringRef("ctor")) + if (Feather_getName(funDecl) != funName) continue; if (Nest_nodeArraySize(n->children) == 0) continue; @@ -330,7 +338,7 @@ void _IntModClassMembers_afterComputeType(Nest_Modifier*, Node* node) { } void IntModCtorMembers_beforeSemanticCheck(Nest_Modifier*, Node* fun) { - /// Check to apply only to non-static constructors + // Check to apply only to non-static constructors if (fun->nodeKind != nkSparrowDeclSprFunction || Feather_getName(fun) != StringRef("ctor")) REP_INTERNAL( fun->location, "IntModCtorMembers modifier can be applied only to constructors"); @@ -365,7 +373,7 @@ void IntModCtorMembers_beforeSemanticCheck(Nest_Modifier*, Node* fun) { Node* base = mkCompoundExp( loc, mkIdentifier(loc, StringRef("this")), Feather_getName(field)); Node* call = nullptr; - if (field->type->numReferences == 0) { + if (!fieldIsRef(field)) { call = mkOperatorCall(loc, base, StringRef("ctor"), nullptr); } else { call = mkOperatorCall(loc, base, StringRef(":="), buildNullLiteral(loc)); @@ -406,7 +414,9 @@ void IntModDtorMembers_beforeSemanticCheck(Nest_Modifier*, Node* fun) { if (!canHaveCtorDtor(field)) continue; - if (field->type->numReferences == 0) { + if (hasCtorCall(body, false, field, "dtor")) + continue; + if (!fieldIsRef(field)) { Node* base = mkCompoundExp( loc, mkIdentifier(loc, StringRef("this")), Feather_getName(field)); Node* call = mkOperatorCall(loc, base, StringRef("dtor"), nullptr); diff --git a/src/SparrowFrontend/Nodes/Builder.cpp b/src/SparrowFrontend/Nodes/Builder.cpp index e071bef5..13df32d4 100644 --- a/src/SparrowFrontend/Nodes/Builder.cpp +++ b/src/SparrowFrontend/Nodes/Builder.cpp @@ -56,23 +56,23 @@ Node* SprFrontend::buildIntLiteral(const Location& loc, int value) { } Node* SprFrontend::buildUIntLiteral(const Location& loc, unsigned int value) { - return mkLiteral(loc, StringRef("UInt"), toStrData(value)); + return mkLiteral(loc, StringRef("UInt32"), toStrData(value)); } Node* SprFrontend::buildLongLiteral(const Location& loc, long value) { - return mkLiteral(loc, StringRef("Long"), toStrData(value)); + return mkLiteral(loc, StringRef("Int64"), toStrData(value)); } Node* SprFrontend::buildULongLiteral(const Location& loc, unsigned long value) { - return mkLiteral(loc, StringRef("ULong"), toStrData(value)); + return mkLiteral(loc, StringRef("UInt64"), toStrData(value)); } Node* SprFrontend::buildFloatLiteral(const Location& loc, float value) { - return mkLiteral(loc, StringRef("Float"), toStrData(value)); + return mkLiteral(loc, StringRef("Float32"), toStrData(value)); } Node* SprFrontend::buildDoubleLiteral(const Location& loc, double value) { - return mkLiteral(loc, StringRef("Double"), toStrData(value)); + return mkLiteral(loc, StringRef("Float"), toStrData(value)); } Node* SprFrontend::buildCharLiteral(const Location& loc, char value) { diff --git a/src/SparrowFrontend/Nodes/Decl.cpp b/src/SparrowFrontend/Nodes/Decl.cpp index 90b2e0fd..a3f26052 100644 --- a/src/SparrowFrontend/Nodes/Decl.cpp +++ b/src/SparrowFrontend/Nodes/Decl.cpp @@ -145,8 +145,6 @@ Type computeVarType( TypeWithStorage tt = TypeWithStorage(t); if (parent.hasProperty("addConst")) t = Feather::ConstType::get(tt); - // else - // t = Feather::MutableType::get(tt); } if (!t) return {}; @@ -536,10 +534,15 @@ Type VariableDecl::computeTypeImpl(VariableDecl node) { // Create a var-ref object to refer to the variable to be initialized/destructed. NodeHandle varRef = Feather::VarRefExp::create(loc, resultingVar); - // If the variable is const, cast the constness away for initialization & destruction - if (resultingVar.type().kind() == Feather_getConstTypeKind()) { - TypeWithStorage t = Feather::ConstType(resultingVar.type()).base(); - t = Feather::MutableType::get(t); + // If the variable is const/temp, convert to mutable for initialization & destruction + auto varType = resultingVar.type(); + if (varType.kind() == typeKindConst || varType.kind() == typeKindTemp) { + TypeWithStorage base; + if (varType.kind() == typeKindConst) + base = Feather::ConstType(varType).base(); + else if (varType.kind() == typeKindTemp) + base = Feather::TempType(varType).base(); + auto t = Feather::MutableType::get(base); auto typeNode = Feather::TypeNode::create(loc, t); varRef = Feather::BitcastExp::create(loc, typeNode, varRef); } @@ -762,6 +765,12 @@ Type FieldDecl::computeTypeImpl(FieldDecl node) { if (!t) return {}; + int origTypeKind = -1; + if (Feather::isCategoryType(t)) { + origTypeKind = t.kind(); + t = Feather::removeCategoryIfPresent(t); + } + // If the type of the variable indicates a variable that can only be CT, change the evalMode if (t.mode() == modeCt) node.setMode(modeCt); @@ -772,6 +781,8 @@ Type FieldDecl::computeTypeImpl(FieldDecl node) { resultingVar.setMode(node.effectiveMode()); Feather_setShouldAddToSymTab(resultingVar, 0); node.setProperty(propResultingDecl, resultingVar); + if (origTypeKind >= 0) + resultingVar.setProperty(propSprOrigCat, origTypeKind); // Set the context and compute the type for the resulting var resultingVar.setContext(node.childrenContext()); diff --git a/src/SparrowFrontend/Nodes/Exp.cpp b/src/SparrowFrontend/Nodes/Exp.cpp index fc449ad7..cec5e947 100644 --- a/src/SparrowFrontend/Nodes/Exp.cpp +++ b/src/SparrowFrontend/Nodes/Exp.cpp @@ -32,6 +32,91 @@ bool isField(NodeHandle node) { return nullptr != Feather_getParentClass(node.context()); } +//! Combine type categories for field refs; the inputs and output are type kinds +int combineCatForFieldRef(int baseCat, int fieldCat) { + if (fieldCat == typeKindConst) + return typeKindConst; + else if (fieldCat == typeKindMutable) + return typeKindMutable; + else + return baseCat; +} + +//! Check for special case in which we should ignore a const in field-ref: +//! Whenever we are in a ctor, and the field-ref is based of 'this' +bool shouldIgnoreConst(NodeHandle baseExp) { + // Check that the base expression is 'this' identifier + Identifier baseId = baseExp.kindCast(); + if (!baseId || baseId.name() != "this") + return false; + + // Check that we are in a function named 'ctor' or 'dtor' + Feather::DeclNode fun = Feather_getParentFun(baseId.context()); + if (!fun || (fun.name() != "ctor" && fun.name() != "dtor")) + return false; + + return true; +} + +//! Create a field ref expression following Sparrow frontend rules +Feather::FieldRefExp createFieldRef(const Location& loc, NodeHandle baseExp, Feather::VarDecl var) { + // First, the base expression needs to be valid + if (!baseExp) + REP_INTERNAL(loc, "No base expression to refer to a field"); + ASSERT(baseExp); + + // Make sure the base is a reference + if (baseExp.type().numReferences() == 0) { + ConversionResult res = g_ConvertService->checkConversion( + baseExp, Feather::addRef(TypeWithStorage(baseExp.type()))); + if (!res) + REP_INTERNAL(loc, "Cannot add reference to base of field access"); + baseExp = res.apply(baseExp); + if (!baseExp.computeType()) + return {}; + } + auto origBaseExp = baseExp; + + Type t = baseExp.type(); + if (!t.hasStorage()) + REP_INTERNAL(loc, "Invalid type for base of field expression: %1%") % baseExp; + assert(t.hasStorage()); + + int origTypeCat = t.kind(); + + // Dereference to have just a cat type to the field + if (t.numReferences() > 1) { + // If we have N references apply N-1 dereferencing operations + for (size_t i = 1; i < t.numReferences(); ++i) { + baseExp = Feather::MemLoadExp::create(loc, baseExp); + } + t = Feather::DataType::get(t.referredNode(), 0, t.mode()); // Zero references + } + + // Compute the desired category of the base expression type + int desiredTypeCat = origTypeCat; + const int* fieldCat = var.getPropertyInt(propSprOrigCat); + if (fieldCat) { + desiredTypeCat = combineCatForFieldRef(origTypeCat, *fieldCat); + } + + // If the desired category is const, but we are initializing a filed in the ctor, transform it + // into mutable + if (desiredTypeCat == typeKindConst && origTypeCat != typeKindConst) { + if (shouldIgnoreConst(origBaseExp)) + desiredTypeCat = origTypeCat; + } + + // Do we need to change the type of the base expression? + if (desiredTypeCat != origTypeCat) { + t = Feather::changeCat(TypeWithStorage(t), desiredTypeCat); + auto typeNode = Feather::TypeNode::create(loc, t); + baseExp = Feather::BitcastExp::create(loc, typeNode, baseExp); + } + + return Feather::FieldRefExp::create(loc, baseExp, var); +} + NodeHandle getIdentifierResult( NodeHandle node, NodeRange decls, NodeHandle baseExp, bool allowDeclExp) { const Location& loc = node.location(); @@ -44,26 +129,10 @@ NodeHandle getIdentifierResult( // Check if we can refer to a variable Feather::VarDecl resDeclVar = resDecl.kindCast(); if (resDeclVar) { - if (isField(resDecl)) { - if (!baseExp) - REP_INTERNAL(loc, "No base expression to refer to a field"); - ASSERT(baseExp); - - // Make sure the base is a reference - if (baseExp.type().numReferences() == 0) { - ConversionResult res = g_ConvertService->checkConversion( - baseExp, Feather::addRef(TypeWithStorage(baseExp.type()))); - if (!res) - REP_INTERNAL(loc, "Cannot add reference to base of field access"); - baseExp = res.apply(baseExp); - if (!baseExp.computeType()) - return {}; - } - doDereference1(baseExp, baseExp); // ... but no more than one reference - - return Feather::FieldRefExp::create(loc, baseExp, resDeclVar); - } - return Feather::VarRefExp::create(loc, resDeclVar); + if (isField(resDecl)) + return createFieldRef(loc, baseExp, resDeclVar); + else + return Feather::VarRefExp::create(loc, resDeclVar); } // If this is a using, get its value @@ -236,10 +305,10 @@ NodeHandle checkSizeOf(NodeHandle node) { t = Feather::removeCategoryIfPresent(t); // Get the size of the type of the argument - uint64_t size = Nest_sizeOf(t); + int size = Nest_sizeOf(t); // Create a CtValue to hold the size - return Feather_mkCtValueT(node.location(), StdDef::typeSizeType, &size); + return Feather_mkCtValueT(node.location(), StdDef::typeInt, &size); } NodeHandle checkTypeOf(NodeHandle node) { diff --git a/src/SparrowFrontend/Nodes/SprProperties.h b/src/SparrowFrontend/Nodes/SprProperties.h index 254fbb33..6821d006 100644 --- a/src/SparrowFrontend/Nodes/SprProperties.h +++ b/src/SparrowFrontend/Nodes/SprProperties.h @@ -17,6 +17,7 @@ extern const char* propOverloadPrio; constexpr const char* propVarInit = "spr.varInit"; constexpr const char* propSprGivenType = "spr.givenType"; +constexpr const char* propSprOrigCat = "spr.origCat"; constexpr const char* propSprLiteralType = "spr.literalType"; constexpr const char* propSprLiteralData = "spr.literalData"; constexpr const char* propSprOperation = "spr.operation"; diff --git a/src/SparrowFrontend/Services/Callable/FunctionCallable.cpp b/src/SparrowFrontend/Services/Callable/FunctionCallable.cpp index ae79ceb1..f81ac939 100644 --- a/src/SparrowFrontend/Services/Callable/FunctionCallable.cpp +++ b/src/SparrowFrontend/Services/Callable/FunctionCallable.cpp @@ -7,6 +7,7 @@ #include "SparrowFrontend/Helpers/CommonCode.h" #include "SparrowFrontend/Helpers/Impl/Intrinsics.h" #include "SparrowFrontend/Nodes/Exp.hpp" +#include "SparrowFrontend/SprDebug.h" #include "Nest/Utils/cppif/SmallVector.hpp" @@ -183,7 +184,7 @@ NodeHandle FunctionCallable::generateCall(const CCLoc& ccloc) { res = createFunctionCall(ccloc.loc_, ccloc.context_, decl_, argsRange); // If this callable is a class-ctor, wrap the exiting result in a temp-var construct - if (tmpVar_) + if (res && tmpVar_) res = createTempVarConstruct(ccloc.loc_, ccloc.context_, res, tmpVar_); return res; diff --git a/src/SparrowFrontend/Services/Callable/GenericFunctionCallable.cpp b/src/SparrowFrontend/Services/Callable/GenericFunctionCallable.cpp index 42bffe6f..9fe72e30 100644 --- a/src/SparrowFrontend/Services/Callable/GenericFunctionCallable.cpp +++ b/src/SparrowFrontend/Services/Callable/GenericFunctionCallable.cpp @@ -343,7 +343,7 @@ NodeHandle GenericFunctionCallable::generateCall(const CCLoc& ccloc) { ccloc.loc_, ccloc.context_, resultingFun, NodeRangeT(finalArgs)); if (!res) - REP_INTERNAL(ccloc.loc_, "Cannot create code that calls generic function"); + return nullptr; res.setContext(ccloc.context_); // If this callable is a class-ctor, wrap the exiting result in a temp-var construct diff --git a/src/SparrowFrontend/Services/Convert/ConvertServiceImpl.cpp b/src/SparrowFrontend/Services/Convert/ConvertServiceImpl.cpp index f0c22a5b..8da6c447 100644 --- a/src/SparrowFrontend/Services/Convert/ConvertServiceImpl.cpp +++ b/src/SparrowFrontend/Services/Convert/ConvertServiceImpl.cpp @@ -331,13 +331,15 @@ bool ConvertServiceImpl::adjustReferences(ConversionResult& res, TypeWithStorage removeCat, // category -> plain }; + // clang-format off constexpr ConvType conversions[4][4] = { - {direct, addCat, none, none}, // from plain - {removeCat, direct, none, none}, // from const - {removeCat, catCast, direct, none}, // from mutable - {removeCat, catCast, catCast, direct} // from temp + {direct, addCat, none, addCat}, // from plain + {removeCat, direct, none, none}, // from const + {removeCat, catCast, direct, none}, // from mutable + {removeCat, catCast, none, direct} // from temp }; - // to: plain, const, mutable, temp + // to: plain, const, mutable, temp + // clang-format on int srcIdx = typeKindToIndex(src.kind()); int destIdx = typeKindToIndex(destKind); diff --git a/tests/Basic/Auto.spr b/tests/Basic/Auto.spr index e7fefa8a..cb8a4a38 100644 --- a/tests/Basic/Auto.spr +++ b/tests/Basic/Auto.spr @@ -1,13 +1,13 @@ //!! -t "SparrowImplicitLib.spr" -fno-main -// Test purpose: Test anyType +// Test purpose: Test AnyType as parameter concept AnyType(x) // Always true // Takes a non-reference as a parameter fun f1(x: AnyType) if typeOf(x) == Int writeLn('non-ref') - x = 10 + //x = 10 // Takes a reference as a parameter fun f2(x: !AnyType) if typeOf(x) == !Int diff --git a/tests/Basic/Convert.spr b/tests/Basic/Convert.spr deleted file mode 100644 index 73fd1785..00000000 --- a/tests/Basic/Convert.spr +++ /dev/null @@ -1,109 +0,0 @@ -//!! -t "SparrowImplicitLib.spr" -fno-main - -fun printByte(x: Byte) - write(" B: ") - writeLn(x) - -fun printUByte(x: UByte) - write("UB: ") - writeLn(x) - -fun printInt(x: Int) - write(" I: ") - writeLn(x) - -fun printUInt(x: UInt) - write("UI: ") - writeLn(x) - -[native("test")] fun test(n: Int) - let sb: Byte = 1 - let ub: UByte = 2 - let ss: Short = 3 - let us: UShort = 4 - let si: Int = 5 - let ui: UInt = 6 - let sl: Long = 7 - let ul: ULong = 8 - let f: Float = 9 - let d: Double = 10 - - writeLn(sb) - writeLn(ub) - writeLn(ss) - writeLn(us) - writeLn(si) - writeLn(ui) - writeLn(sl) - writeLn(ul) - writeLn(Int(f)) // For some weird reason, floats are not printed ok - writeLn(d) - - writeLn("---") - - writeLn(Byte(-1)) - writeLn(UByte(-2)) - writeLn(Short(-3)) - writeLn(UShort(-4)) - writeLn(Int(-5)) - writeLn(UInt(-6)) - writeLn(Long(-7)) - writeLn(ULong(-8)) - writeLn(Double(Float(-9))) - writeLn(Double(-10)) - - writeLn("---") - - printByte(Byte(1)) - //printByte(UByte(2)); - //printByte(Int(3)); - //printByte(UInt(4)); - - //printUByte(Byte(11)); - printUByte(UByte(12)) - // printUByte(Int(13)); - // printUByte(UInt(14)); - - printInt(Byte(21)) - printInt(UByte(22)) - printInt(Int(23)) - //printInt(UInt(24)); - - printUInt(Byte(31)) - printUInt(UByte(32)) - printUInt(Int(33)) - printUInt(UInt(34)) - -/*<<>>*/ diff --git a/tests/Basic/CtFun.spr b/tests/Basic/CtFun.spr index 6df64ca1..35ea8005 100644 --- a/tests/Basic/CtFun.spr +++ b/tests/Basic/CtFun.spr @@ -1,6 +1,6 @@ //!! -t "SparrowImplicitLib.spr" -fno-main -[rt] fun pow1(x: Double, n: Int): Double +[rt] fun pow1(x: Float, n: Int): Float if ( equal(n, 0) ) return 1.0 else if ( equal(n, 1) ) @@ -9,7 +9,7 @@ //return mul(x, pow1(x, sub(n,1))); return mul(pow1(mul(x,x), div(n,2)), pow1(x, mod(n,2))) -[ct] fun pow2(x: Double, n: Int): Double +[ct] fun pow2(x: Float, n: Int): Float if ( equal(n, 0) ) return 1.0 else if ( equal(n, 1) ) @@ -17,35 +17,35 @@ else return mul(pow2(mul(x,x), div(n,2)), pow2(x, mod(n,2))) -[autoCt] fun pow3(x: Double, n: Int): Double +[autoCt] fun pow3(x: Float, n: Int): Float if ( equal(n, 0) ) return 1.0 else return mul(x, pow3(x, sub(n,1))) return x -[native("writeLnDouble"), autoCt] fun writeLnDoubleCt(x: Double) +[native("writeLnFloat64"), autoCt] fun writeLnFloatCt(x: Float) // Function that can be called only with compile-time arguments -[ct] fun ctTest(x: Double) - writeLnDoubleCt(x) +[ct] fun ctTest(x: Float) + writeLnFloatCt(x) [native("test")] fun test(n: Int) - writeLnDouble(pow1(2.0, 0)) - writeLnDouble(pow1(2.0, 1)) - writeLnDouble(pow1(2.0, 2)) - writeLnDouble(pow1(2.0, 3)) - writeLnDouble(pow1(2.0, 4)) - writeLnDouble(pow1(2.0, 5)) - writeLnDouble(pow1(2.0, 6)) - writeLnDouble(pow1(2.0, 7)) - writeLnDouble(pow1(2.0, 8)) + writeLnFloat(pow1(2.0, 0)) + writeLnFloat(pow1(2.0, 1)) + writeLnFloat(pow1(2.0, 2)) + writeLnFloat(pow1(2.0, 3)) + writeLnFloat(pow1(2.0, 4)) + writeLnFloat(pow1(2.0, 5)) + writeLnFloat(pow1(2.0, 6)) + writeLnFloat(pow1(2.0, 7)) + writeLnFloat(pow1(2.0, 8)) - writeLnDouble(mathPow(3.0, 4.0)) - writeLnDouble(pow1(3.0, 4)) - writeLnDouble(pow2(3.0, 4)) + writeLnFloat(mathPow(3.0, 4.0)) + writeLnFloat(pow1(3.0, 4)) + writeLnFloat(pow2(3.0, 4)) pow3(3.0, 4) - writeLnDouble(pow3(3.0, 4)) + writeLnFloat(pow3(3.0, 4)) //ctTest(pow1(4.0, 4)); ctTest(pow2(4.0, 4)) diff --git a/tests/Basic/CtIf.spr b/tests/Basic/CtIf.spr index add4de73..97654793 100644 --- a/tests/Basic/CtIf.spr +++ b/tests/Basic/CtIf.spr @@ -1,10 +1,10 @@ //!! -t "SparrowImplicitLib.spr" -fno-main -[native("writeLnDouble"), autoCt] fun writeLnDoubleCt(x: Double) +[native("writeLnFloat64"), autoCt] fun writeLnFloatCt(x: Float) // Function that can be called only with compile-time arguments -[ct] fun ctTest(x: Double) - writeLnDoubleCt(x) +[ct] fun ctTest(x: Float) + writeLnFloatCt(x) [ct] if ( true ) fun my_f { writeLn("f.1"); } diff --git a/tests/Basic/DependentTypes.spr b/tests/Basic/DependentTypes.spr index 66cd36e9..e042c006 100644 --- a/tests/Basic/DependentTypes.spr +++ b/tests/Basic/DependentTypes.spr @@ -4,10 +4,10 @@ concept AnyType(x) fun writeType(a: AnyType) if typeOf(a) == Int write('Int') -fun writeType(a: AnyType) if typeOf(a) == Byte - write('Byte') -fun writeType(a: AnyType) if typeOf(a) == Double - write('Double') +fun writeType(a: AnyType) if typeOf(a) == Int8 + write('Int8') +fun writeType(a: AnyType) if typeOf(a) == Float + write('Float') fun writeTypes(a, b: AnyType) writeType(a) @@ -39,12 +39,9 @@ fun pushBack2(this: !Vec, val: this.ValueType) [native("test")] fun test(n: Int) normal(1, 2) - normal(1, Byte(2)) writeLn('---') - any(3.14, Byte(2)) - anyIf(3.14, Double(Byte(2))) - writeLn('---') - deduced(3.14, Byte(2)) + any(3.14, Int8(2)) + anyIf(3.14, Float(Int8(2))) writeLn('---') var v: Vec(Int) @@ -54,17 +51,14 @@ fun pushBack2(this: !Vec, val: this.ValueType) writeLn(v.data) pushBack2(v, 3) writeLn(v.data) - pushBack2(v, Byte(4)) + pushBack2(v, Int(Int8(4))) writeLn(v.data) /*<<sizeOf(Double) - write('B') - write(':') - write(' ') +fun f(x: AnyType) if sizeOf(x)>sizeOf(Float) + write('B: ') writeLn(sizeOf(x)) fun f(x: AnyType) if false - write('X') - write(':') - write(' ') + write('X: ') writeLn(sizeOf(x)) fun tst(x: AnyType) if typeOf(x) == Int - write('I') - write('n') - writeLn('t') - -fun tst(x: AnyType) if typeOf(x) == Double - write('D') - write('o') - write('u') - write('b') - write('l') - writeLn('e') + writeLn('Int') + +fun tst(x: AnyType) if typeOf(x) == Float + writeLn('Float') fun tst(x: AnyType) if isValid(x.second) - write('P') - write('a') - write('i') - writeLn('r') + writeLn('Pair') fun tst2(x: AnyType) if typeOf(x) == Int - write('I') - write('n') - writeLn('t') - -fun tst2(x: AnyType) if typeOf(x) == Double - write('D') - write('o') - write('u') - write('b') - write('l') - writeLn('e') + writeLn('Int') + +fun tst2(x: AnyType) if typeOf(x) == Float + writeLn('Float') fun tst2(x: AnyType) if isValid(x.second) - write('P') - write('a') - write('i') - writeLn('r') + writeLn('Pair') fun tst3(x: AnyType) if typeOf(x) == Int - write('I') - write('n') - writeLn('t') - -fun tst3(x: AnyType) if typeOf(x) == Double - write('D') - write('o') - write('u') - write('b') - write('l') - writeLn('e') - -fun tst3(x: AnyType) if typeOf(x.second) == Double - write('P') - write('a') - write('i') - write('r') - write(' ') - writeLn('D') - -fun tst3(x: AnyType) if typeOf(x.second) != Double - write('P') - write('a') - write('i') - writeLn('r') + writeLn('Int') + +fun tst3(x: AnyType) if typeOf(x) == Float + writeLn('Float') + +fun tst3(x: AnyType) if typeOf(x.second) == Float + writeLn('Pair D') + +fun tst3(x: AnyType) if typeOf(x.second) != Float + writeLn('Pair') fun ok() - write('O') - writeLn('K') + writeLn('OK') fun fail() - write('F') - write('A') - write('I') - writeLn('L') + writeLn('FAIL') fun separ() - write('-') - write('-') - writeLn('-') + writeLn('---') [native("test")] fun test(n: Int) let a: Pair(Int, Int) - let b: Pair(Double, Double) + let b: Pair(Float, Float) let c: Pair(Int, Pair(Int, Int)) - let d: Pair(Pair(Double, Double), Pair(Double, Double)) + let d: Pair(Pair(Float, Float), Pair(Float, Float)) f(1) f(3.14) @@ -156,21 +109,21 @@ B: 12 B: 32 --- Int -Double +Float Pair Pair Pair Pair --- Int -Double +Float Pair Pair Pair Pair --- Int -Double +Float Pair Pair D Pair diff --git a/tests/Basic/SparrowImplicitLib.spr b/tests/Basic/SparrowImplicitLib.spr index 5072be73..9506784b 100644 --- a/tests/Basic/SparrowImplicitLib.spr +++ b/tests/Basic/SparrowImplicitLib.spr @@ -532,149 +532,149 @@ define i1 @_Bool_opEQ(i1 %x, i1 %y) {\n %1 = icmp eq i1 %x, %y\n r define i1 @_Bool_opNE(i1 %x, i1 %y) {\n %1 = icmp ne i1 %x, %y\n ret i1 %1\n} define i1 @_Bool_opNeg(i1 %x) {\n %1 = xor i1 %x, 1\n ret i1 %1\n} -define i8 @_Byte_opAssign(i8* %x, i8 %y) {\n store i8 %y, i8* %x\n ret i8 %y\n} -define i1 @_Byte_opEQ(i8 %x, i8 %y) {\n %1 = icmp eq i8 %x, %y\n ret i1 %1\n} -define i1 @_Byte_opNE(i8 %x, i8 %y) {\n %1 = icmp ne i8 %x, %y\n ret i1 %1\n} -define i1 @_Byte_opLT(i8 %x, i8 %y) {\n %1 = icmp slt i8 %x, %y\n ret i1 %1\n} -define i1 @_Byte_opGT(i8 %x, i8 %y) {\n %1 = icmp sgt i8 %x, %y\n ret i1 %1\n} -define i1 @_Byte_opLE(i8 %x, i8 %y) {\n %1 = icmp sle i8 %x, %y\n ret i1 %1\n} -define i1 @_Byte_opGE(i8 %x, i8 %y) {\n %1 = icmp sge i8 %x, %y\n ret i1 %1\n} -define i8 @_Byte_opPlus(i8 %x, i8 %y) {\n %1 = add i8 %x, %y\n ret i8 %1\n} -define i8 @_Byte_opMinus(i8 %x, i8 %y) {\n %1 = sub i8 %x, %y\n ret i8 %1\n} -define i8 @_Byte_opMul(i8 %x, i8 %y) {\n %1 = mul i8 %x, %y\n ret i8 %1\n} -define i8 @_Byte_opDiv(i8 %x, i8 %y) {\n %1 = sdiv i8 %x, %y\n ret i8 %1\n} -define i8 @_Byte_opMod(i8 %x, i8 %y) {\n %1 = srem i8 %x, %y\n ret i8 %1\n} -define i8 @_Byte_opPlus1(i8 %x) {\n ret i8 %x\n} -define i8 @_Byte_opMinus1(i8 %x) {\n %1 = sub i8 0, %x\n ret i8 %1\n} - -define i8 @_UByte_opAssign(i8* %x, i8 %y) {\n store i8 %y, i8* %x\n ret i8 %y\n} -define i1 @_UByte_opEQ(i8 %x, i8 %y) {\n %1 = icmp eq i8 %x, %y\n ret i1 %1\n} -define i1 @_UByte_opNE(i8 %x, i8 %y) {\n %1 = icmp ne i8 %x, %y\n ret i1 %1\n} -define i1 @_UByte_opLT(i8 %x, i8 %y) {\n %1 = icmp ult i8 %x, %y\n ret i1 %1\n} -define i1 @_UByte_opGT(i8 %x, i8 %y) {\n %1 = icmp ugt i8 %x, %y\n ret i1 %1\n} -define i1 @_UByte_opLE(i8 %x, i8 %y) {\n %1 = icmp ule i8 %x, %y\n ret i1 %1\n} -define i1 @_UByte_opGE(i8 %x, i8 %y) {\n %1 = icmp uge i8 %x, %y\n ret i1 %1\n} -define i8 @_UByte_opPlus(i8 %x, i8 %y) {\n %1 = add i8 %x, %y\n ret i8 %1\n} -define i8 @_UByte_opMinus(i8 %x, i8 %y) {\n %1 = sub i8 %x, %y\n ret i8 %1\n} -define i8 @_UByte_opMul(i8 %x, i8 %y) {\n %1 = mul i8 %x, %y\n ret i8 %1\n} -define i8 @_UByte_opDiv(i8 %x, i8 %y) {\n %1 = sdiv i8 %x, %y\n ret i8 %1\n} -define i8 @_UByte_opMod(i8 %x, i8 %y) {\n %1 = srem i8 %x, %y\n ret i8 %1\n} -define i8 @_UByte_opPlus1(i8 %x) {\n ret i8 %x\n} - -define i16 @_Short_opAssign(i16* %x, i16 %y) {\n store i16 %y, i16* %x\n ret i16 %y\n} -define i1 @_Short_opEQ(i16 %x, i16 %y) {\n %1 = icmp eq i16 %x, %y\n ret i1 %1\n} -define i1 @_Short_opNE(i16 %x, i16 %y) {\n %1 = icmp ne i16 %x, %y\n ret i1 %1\n} -define i1 @_Short_opLT(i16 %x, i16 %y) {\n %1 = icmp slt i16 %x, %y\n ret i1 %1\n} -define i1 @_Short_opGT(i16 %x, i16 %y) {\n %1 = icmp sgt i16 %x, %y\n ret i1 %1\n} -define i1 @_Short_opLE(i16 %x, i16 %y) {\n %1 = icmp sle i16 %x, %y\n ret i1 %1\n} -define i1 @_Short_opGE(i16 %x, i16 %y) {\n %1 = icmp sge i16 %x, %y\n ret i1 %1\n} -define i16 @_Short_opPlus(i16 %x, i16 %y) {\n %1 = add i16 %x, %y\n ret i16 %1\n} -define i16 @_Short_opMinus(i16 %x, i16 %y) {\n %1 = sub i16 %x, %y\n ret i16 %1\n} -define i16 @_Short_opMul(i16 %x, i16 %y) {\n %1 = mul i16 %x, %y\n ret i16 %1\n} -define i16 @_Short_opDiv(i16 %x, i16 %y) {\n %1 = sdiv i16 %x, %y\n ret i16 %1\n} -define i16 @_Short_opMod(i16 %x, i16 %y) {\n %1 = srem i16 %x, %y\n ret i16 %1\n} -define i16 @_Short_opPlus1(i16 %x) {\n ret i16 %x\n} -define i16 @_Short_opMinus1(i16 %x) {\n %1 = sub i16 0, %x\n ret i16 %1\n} - -define i16 @_UShort_opAssign(i16* %x, i16 %y) {\n store i16 %y, i16* %x\n ret i16 %y\n} -define i1 @_UShort_opEQ(i16 %x, i16 %y) {\n %1 = icmp eq i16 %x, %y\n ret i1 %1\n} -define i1 @_UShort_opNE(i16 %x, i16 %y) {\n %1 = icmp ne i16 %x, %y\n ret i1 %1\n} -define i1 @_UShort_opLT(i16 %x, i16 %y) {\n %1 = icmp ult i16 %x, %y\n ret i1 %1\n} -define i1 @_UShort_opGT(i16 %x, i16 %y) {\n %1 = icmp ugt i16 %x, %y\n ret i1 %1\n} -define i1 @_UShort_opLE(i16 %x, i16 %y) {\n %1 = icmp ule i16 %x, %y\n ret i1 %1\n} -define i1 @_UShort_opGE(i16 %x, i16 %y) {\n %1 = icmp uge i16 %x, %y\n ret i1 %1\n} -define i16 @_UShort_opPlus(i16 %x, i16 %y) {\n %1 = add i16 %x, %y\n ret i16 %1\n} -define i16 @_UShort_opMinus(i16 %x, i16 %y) {\n %1 = sub i16 %x, %y\n ret i16 %1\n} -define i16 @_UShort_opMul(i16 %x, i16 %y) {\n %1 = mul i16 %x, %y\n ret i16 %1\n} -define i16 @_UShort_opDiv(i16 %x, i16 %y) {\n %1 = sdiv i16 %x, %y\n ret i16 %1\n} -define i16 @_UShort_opMod(i16 %x, i16 %y) {\n %1 = srem i16 %x, %y\n ret i16 %1\n} -define i16 @_UShort_opPlus1(i16 %x) {\n ret i16 %x\n} - -define i32 @_Int_opAssign(i32* %x, i32 %y) {\n store i32 %y, i32* %x\n ret i32 %y\n} -define i1 @_Int_opEQ(i32 %x, i32 %y) {\n %1 = icmp eq i32 %x, %y\n ret i1 %1\n} -define i1 @_Int_opNE(i32 %x, i32 %y) {\n %1 = icmp ne i32 %x, %y\n ret i1 %1\n} -define i1 @_Int_opLT(i32 %x, i32 %y) {\n %1 = icmp slt i32 %x, %y\n ret i1 %1\n} -define i1 @_Int_opGT(i32 %x, i32 %y) {\n %1 = icmp sgt i32 %x, %y\n ret i1 %1\n} -define i1 @_Int_opLE(i32 %x, i32 %y) {\n %1 = icmp sle i32 %x, %y\n ret i1 %1\n} -define i1 @_Int_opGE(i32 %x, i32 %y) {\n %1 = icmp sge i32 %x, %y\n ret i1 %1\n} -define i32 @_Int_opPlus(i32 %x, i32 %y) {\n %1 = add i32 %x, %y\n ret i32 %1\n} -define i32 @_Int_opMinus(i32 %x, i32 %y) {\n %1 = sub i32 %x, %y\n ret i32 %1\n} -define i32 @_Int_opMul(i32 %x, i32 %y) {\n %1 = mul i32 %x, %y\n ret i32 %1\n} -define i32 @_Int_opDiv(i32 %x, i32 %y) {\n %1 = sdiv i32 %x, %y\n ret i32 %1\n} -define i32 @_Int_opMod(i32 %x, i32 %y) {\n %1 = srem i32 %x, %y\n ret i32 %1\n} -define i32 @_Int_opPlus1(i32 %x) {\n ret i32 %x\n} -define i32 @_Int_opMinus1(i32 %x) {\n %1 = sub i32 0, %x\n ret i32 %1\n} - -define i32 @_UInt_opAssign(i32* %x, i32 %y) {\n store i32 %y, i32* %x\n ret i32 %y\n} -define i1 @_UInt_opEQ(i32 %x, i32 %y) {\n %1 = icmp eq i32 %x, %y\n ret i1 %1\n} -define i1 @_UInt_opNE(i32 %x, i32 %y) {\n %1 = icmp ne i32 %x, %y\n ret i1 %1\n} -define i1 @_UInt_opLT(i32 %x, i32 %y) {\n %1 = icmp ult i32 %x, %y\n ret i1 %1\n} -define i1 @_UInt_opGT(i32 %x, i32 %y) {\n %1 = icmp ugt i32 %x, %y\n ret i1 %1\n} -define i1 @_UInt_opLE(i32 %x, i32 %y) {\n %1 = icmp ule i32 %x, %y\n ret i1 %1\n} -define i1 @_UInt_opGE(i32 %x, i32 %y) {\n %1 = icmp uge i32 %x, %y\n ret i1 %1\n} -define i32 @_UInt_opPlus(i32 %x, i32 %y) {\n %1 = add i32 %x, %y\n ret i32 %1\n} -define i32 @_UInt_opMinus(i32 %x, i32 %y) {\n %1 = sub i32 %x, %y\n ret i32 %1\n} -define i32 @_UInt_opMul(i32 %x, i32 %y) {\n %1 = mul i32 %x, %y\n ret i32 %1\n} -define i32 @_UInt_opDiv(i32 %x, i32 %y) {\n %1 = sdiv i32 %x, %y\n ret i32 %1\n} -define i32 @_UInt_opMod(i32 %x, i32 %y) {\n %1 = srem i32 %x, %y\n ret i32 %1\n} -define i32 @_UInt_opPlus1(i32 %x) {\n ret i32 %x\n} - -define i64 @_Long_opAssign(i64* %x, i64 %y) {\n store i64 %y, i64* %x\n ret i64 %y\n} -define i1 @_Long_opEQ(i64 %x, i64 %y) {\n %1 = icmp eq i64 %x, %y\n ret i1 %1\n} -define i1 @_Long_opNE(i64 %x, i64 %y) {\n %1 = icmp ne i64 %x, %y\n ret i1 %1\n} -define i1 @_Long_opLT(i64 %x, i64 %y) {\n %1 = icmp slt i64 %x, %y\n ret i1 %1\n} -define i1 @_Long_opGT(i64 %x, i64 %y) {\n %1 = icmp sgt i64 %x, %y\n ret i1 %1\n} -define i1 @_Long_opLE(i64 %x, i64 %y) {\n %1 = icmp sle i64 %x, %y\n ret i1 %1\n} -define i1 @_Long_opGE(i64 %x, i64 %y) {\n %1 = icmp sge i64 %x, %y\n ret i1 %1\n} -define i64 @_Long_opPlus(i64 %x, i64 %y) {\n %1 = add i64 %x, %y\n ret i64 %1\n} -define i64 @_Long_opMinus(i64 %x, i64 %y) {\n %1 = sub i64 %x, %y\n ret i64 %1\n} -define i64 @_Long_opMul(i64 %x, i64 %y) {\n %1 = mul i64 %x, %y\n ret i64 %1\n} -define i64 @_Long_opDiv(i64 %x, i64 %y) {\n %1 = sdiv i64 %x, %y\n ret i64 %1\n} -define i64 @_Long_opMod(i64 %x, i64 %y) {\n %1 = srem i64 %x, %y\n ret i64 %1\n} -define i64 @_Long_opPlus1(i64 %x) {\n ret i64 %x\n} -define i64 @_Long_opMinus1(i64 %x) {\n %1 = sub i64 0, %x\n ret i64 %1\n} - -define i64 @_ULong_opAssign(i64* %x, i64 %y) {\n store i64 %y, i64* %x\n ret i64 %y\n} -define i1 @_ULong_opEQ(i64 %x, i64 %y) {\n %1 = icmp eq i64 %x, %y\n ret i1 %1\n} -define i1 @_ULong_opNE(i64 %x, i64 %y) {\n %1 = icmp ne i64 %x, %y\n ret i1 %1\n} -define i1 @_ULong_opLT(i64 %x, i64 %y) {\n %1 = icmp ult i64 %x, %y\n ret i1 %1\n} -define i1 @_ULong_opGT(i64 %x, i64 %y) {\n %1 = icmp ugt i64 %x, %y\n ret i1 %1\n} -define i1 @_ULong_opLE(i64 %x, i64 %y) {\n %1 = icmp ule i64 %x, %y\n ret i1 %1\n} -define i1 @_ULong_opGE(i64 %x, i64 %y) {\n %1 = icmp uge i64 %x, %y\n ret i1 %1\n} -define i64 @_ULong_opPlus(i64 %x, i64 %y) {\n %1 = add i64 %x, %y\n ret i64 %1\n} -define i64 @_ULong_opMinus(i64 %x, i64 %y) {\n %1 = sub i64 %x, %y\n ret i64 %1\n} -define i64 @_ULong_opMul(i64 %x, i64 %y) {\n %1 = mul i64 %x, %y\n ret i64 %1\n} -define i64 @_ULong_opDiv(i64 %x, i64 %y) {\n %1 = sdiv i64 %x, %y\n ret i64 %1\n} -define i64 @_ULong_opMod(i64 %x, i64 %y) {\n %1 = srem i64 %x, %y\n ret i64 %1\n} -define i64 @_ULong_opPlus1(i64 %x) {\n ret i64 %x\n} - -define float @_Float_opAssign(float* %x, float %y) {\n store float %y, float* %x\n ret float %y\n} -define i1 @_Float_opEQ(float %x, float %y) {\n %1 = fcmp oeq float %x, %y\n ret i1 %1\n} -define i1 @_Float_opNE(float %x, float %y) {\n %1 = fcmp one float %x, %y\n ret i1 %1\n} -define i1 @_Float_opLT(float %x, float %y) {\n %1 = fcmp olt float %x, %y\n ret i1 %1\n} -define i1 @_Float_opGT(float %x, float %y) {\n %1 = fcmp ogt float %x, %y\n ret i1 %1\n} -define i1 @_Float_opLE(float %x, float %y) {\n %1 = fcmp ole float %x, %y\n ret i1 %1\n} -define i1 @_Float_opGE(float %x, float %y) {\n %1 = fcmp oge float %x, %y\n ret i1 %1\n} -define float @_Float_opPlus(float %x, float %y) {\n %1 = fadd float %x, %y\n ret float %1\n} -define float @_Float_opMinus(float %x, float %y) {\n %1 = fsub float %x, %y\n ret float %1\n} -define float @_Float_opMul(float %x, float %y) {\n %1 = fmul float %x, %y\n ret float %1\n} -define float @_Float_opDiv(float %x, float %y) {\n %1 = fdiv float %x, %y\n ret float %1\n} -define float @_Float_opPlus1(float %x) {\n ret float %x\n} -define float @_Float_opMinus1(float %x) {\n %1 = fsub float 0.0, %x\n ret float %1\n} - -define double @_Double_opAssign(double* %x, double %y) {\n store double %y, double* %x\n ret double %y\n} -define i1 @_Double_opEQ(double %x, double %y) {\n %1 = fcmp oeq double %x, %y\n ret i1 %1\n} -define i1 @_Double_opNE(double %x, double %y) {\n %1 = fcmp one double %x, %y\n ret i1 %1\n} -define i1 @_Double_opLT(double %x, double %y) {\n %1 = fcmp olt double %x, %y\n ret i1 %1\n} -define i1 @_Double_opGT(double %x, double %y) {\n %1 = fcmp ogt double %x, %y\n ret i1 %1\n} -define i1 @_Double_opLE(double %x, double %y) {\n %1 = fcmp ole double %x, %y\n ret i1 %1\n} -define i1 @_Double_opGE(double %x, double %y) {\n %1 = fcmp oge double %x, %y\n ret i1 %1\n} -define double @_Double_opPlus(double %x, double %y) {\n %1 = fadd double %x, %y\n ret double %1\n} -define double @_Double_opMinus(double %x, double %y) {\n %1 = fsub double %x, %y\n ret double %1\n} -define double @_Double_opMul(double %x, double %y) {\n %1 = fmul double %x, %y\n ret double %1\n} -define double @_Double_opDiv(double %x, double %y) {\n %1 = fdiv double %x, %y\n ret double %1\n} -define double @_Double_opPlus1(double %x) {\n ret double %x\n} -define double @_Double_opMinus1(double %x) {\n %1 = fsub double 0.0, %x\n ret double %1\n} +define i8 @_Int8_opAssign(i8* %x, i8 %y) {\n store i8 %y, i8* %x\n ret i8 %y\n} +define i1 @_Int8_opEQ(i8 %x, i8 %y) {\n %1 = icmp eq i8 %x, %y\n ret i1 %1\n} +define i1 @_Int8_opNE(i8 %x, i8 %y) {\n %1 = icmp ne i8 %x, %y\n ret i1 %1\n} +define i1 @_Int8_opLT(i8 %x, i8 %y) {\n %1 = icmp slt i8 %x, %y\n ret i1 %1\n} +define i1 @_Int8_opGT(i8 %x, i8 %y) {\n %1 = icmp sgt i8 %x, %y\n ret i1 %1\n} +define i1 @_Int8_opLE(i8 %x, i8 %y) {\n %1 = icmp sle i8 %x, %y\n ret i1 %1\n} +define i1 @_Int8_opGE(i8 %x, i8 %y) {\n %1 = icmp sge i8 %x, %y\n ret i1 %1\n} +define i8 @_Int8_opPlus(i8 %x, i8 %y) {\n %1 = add i8 %x, %y\n ret i8 %1\n} +define i8 @_Int8_opMinus(i8 %x, i8 %y) {\n %1 = sub i8 %x, %y\n ret i8 %1\n} +define i8 @_Int8_opMul(i8 %x, i8 %y) {\n %1 = mul i8 %x, %y\n ret i8 %1\n} +define i8 @_Int8_opDiv(i8 %x, i8 %y) {\n %1 = sdiv i8 %x, %y\n ret i8 %1\n} +define i8 @_Int8_opMod(i8 %x, i8 %y) {\n %1 = srem i8 %x, %y\n ret i8 %1\n} +define i8 @_Int8_opPlus1(i8 %x) {\n ret i8 %x\n} +define i8 @_Int8_opMinus1(i8 %x) {\n %1 = sub i8 0, %x\n ret i8 %1\n} + +define i8 @_UInt8_opAssign(i8* %x, i8 %y) {\n store i8 %y, i8* %x\n ret i8 %y\n} +define i1 @_UInt8_opEQ(i8 %x, i8 %y) {\n %1 = icmp eq i8 %x, %y\n ret i1 %1\n} +define i1 @_UInt8_opNE(i8 %x, i8 %y) {\n %1 = icmp ne i8 %x, %y\n ret i1 %1\n} +define i1 @_UInt8_opLT(i8 %x, i8 %y) {\n %1 = icmp ult i8 %x, %y\n ret i1 %1\n} +define i1 @_UInt8_opGT(i8 %x, i8 %y) {\n %1 = icmp ugt i8 %x, %y\n ret i1 %1\n} +define i1 @_UInt8_opLE(i8 %x, i8 %y) {\n %1 = icmp ule i8 %x, %y\n ret i1 %1\n} +define i1 @_UInt8_opGE(i8 %x, i8 %y) {\n %1 = icmp uge i8 %x, %y\n ret i1 %1\n} +define i8 @_UInt8_opPlus(i8 %x, i8 %y) {\n %1 = add i8 %x, %y\n ret i8 %1\n} +define i8 @_UInt8_opMinus(i8 %x, i8 %y) {\n %1 = sub i8 %x, %y\n ret i8 %1\n} +define i8 @_UInt8_opMul(i8 %x, i8 %y) {\n %1 = mul i8 %x, %y\n ret i8 %1\n} +define i8 @_UInt8_opDiv(i8 %x, i8 %y) {\n %1 = sdiv i8 %x, %y\n ret i8 %1\n} +define i8 @_UInt8_opMod(i8 %x, i8 %y) {\n %1 = srem i8 %x, %y\n ret i8 %1\n} +define i8 @_UInt8_opPlus1(i8 %x) {\n ret i8 %x\n} + +define i16 @_Int16_opAssign(i16* %x, i16 %y) {\n store i16 %y, i16* %x\n ret i16 %y\n} +define i1 @_Int16_opEQ(i16 %x, i16 %y) {\n %1 = icmp eq i16 %x, %y\n ret i1 %1\n} +define i1 @_Int16_opNE(i16 %x, i16 %y) {\n %1 = icmp ne i16 %x, %y\n ret i1 %1\n} +define i1 @_Int16_opLT(i16 %x, i16 %y) {\n %1 = icmp slt i16 %x, %y\n ret i1 %1\n} +define i1 @_Int16_opGT(i16 %x, i16 %y) {\n %1 = icmp sgt i16 %x, %y\n ret i1 %1\n} +define i1 @_Int16_opLE(i16 %x, i16 %y) {\n %1 = icmp sle i16 %x, %y\n ret i1 %1\n} +define i1 @_Int16_opGE(i16 %x, i16 %y) {\n %1 = icmp sge i16 %x, %y\n ret i1 %1\n} +define i16 @_Int16_opPlus(i16 %x, i16 %y) {\n %1 = add i16 %x, %y\n ret i16 %1\n} +define i16 @_Int16_opMinus(i16 %x, i16 %y) {\n %1 = sub i16 %x, %y\n ret i16 %1\n} +define i16 @_Int16_opMul(i16 %x, i16 %y) {\n %1 = mul i16 %x, %y\n ret i16 %1\n} +define i16 @_Int16_opDiv(i16 %x, i16 %y) {\n %1 = sdiv i16 %x, %y\n ret i16 %1\n} +define i16 @_Int16_opMod(i16 %x, i16 %y) {\n %1 = srem i16 %x, %y\n ret i16 %1\n} +define i16 @_Int16_opPlus1(i16 %x) {\n ret i16 %x\n} +define i16 @_Int16_opMinus1(i16 %x) {\n %1 = sub i16 0, %x\n ret i16 %1\n} + +define i16 @_UInt16_opAssign(i16* %x, i16 %y) {\n store i16 %y, i16* %x\n ret i16 %y\n} +define i1 @_UInt16_opEQ(i16 %x, i16 %y) {\n %1 = icmp eq i16 %x, %y\n ret i1 %1\n} +define i1 @_UInt16_opNE(i16 %x, i16 %y) {\n %1 = icmp ne i16 %x, %y\n ret i1 %1\n} +define i1 @_UInt16_opLT(i16 %x, i16 %y) {\n %1 = icmp ult i16 %x, %y\n ret i1 %1\n} +define i1 @_UInt16_opGT(i16 %x, i16 %y) {\n %1 = icmp ugt i16 %x, %y\n ret i1 %1\n} +define i1 @_UInt16_opLE(i16 %x, i16 %y) {\n %1 = icmp ule i16 %x, %y\n ret i1 %1\n} +define i1 @_UInt16_opGE(i16 %x, i16 %y) {\n %1 = icmp uge i16 %x, %y\n ret i1 %1\n} +define i16 @_UInt16_opPlus(i16 %x, i16 %y) {\n %1 = add i16 %x, %y\n ret i16 %1\n} +define i16 @_UInt16_opMinus(i16 %x, i16 %y) {\n %1 = sub i16 %x, %y\n ret i16 %1\n} +define i16 @_UInt16_opMul(i16 %x, i16 %y) {\n %1 = mul i16 %x, %y\n ret i16 %1\n} +define i16 @_UInt16_opDiv(i16 %x, i16 %y) {\n %1 = sdiv i16 %x, %y\n ret i16 %1\n} +define i16 @_UInt16_opMod(i16 %x, i16 %y) {\n %1 = srem i16 %x, %y\n ret i16 %1\n} +define i16 @_UInt16_opPlus1(i16 %x) {\n ret i16 %x\n} + +define i32 @_Int32_opAssign(i32* %x, i32 %y) {\n store i32 %y, i32* %x\n ret i32 %y\n} +define i1 @_Int32_opEQ(i32 %x, i32 %y) {\n %1 = icmp eq i32 %x, %y\n ret i1 %1\n} +define i1 @_Int32_opNE(i32 %x, i32 %y) {\n %1 = icmp ne i32 %x, %y\n ret i1 %1\n} +define i1 @_Int32_opLT(i32 %x, i32 %y) {\n %1 = icmp slt i32 %x, %y\n ret i1 %1\n} +define i1 @_Int32_opGT(i32 %x, i32 %y) {\n %1 = icmp sgt i32 %x, %y\n ret i1 %1\n} +define i1 @_Int32_opLE(i32 %x, i32 %y) {\n %1 = icmp sle i32 %x, %y\n ret i1 %1\n} +define i1 @_Int32_opGE(i32 %x, i32 %y) {\n %1 = icmp sge i32 %x, %y\n ret i1 %1\n} +define i32 @_Int32_opPlus(i32 %x, i32 %y) {\n %1 = add i32 %x, %y\n ret i32 %1\n} +define i32 @_Int32_opMinus(i32 %x, i32 %y) {\n %1 = sub i32 %x, %y\n ret i32 %1\n} +define i32 @_Int32_opMul(i32 %x, i32 %y) {\n %1 = mul i32 %x, %y\n ret i32 %1\n} +define i32 @_Int32_opDiv(i32 %x, i32 %y) {\n %1 = sdiv i32 %x, %y\n ret i32 %1\n} +define i32 @_Int32_opMod(i32 %x, i32 %y) {\n %1 = srem i32 %x, %y\n ret i32 %1\n} +define i32 @_Int32_opPlus1(i32 %x) {\n ret i32 %x\n} +define i32 @_Int32_opMinus1(i32 %x) {\n %1 = sub i32 0, %x\n ret i32 %1\n} + +define i32 @_UInt32_opAssign(i32* %x, i32 %y) {\n store i32 %y, i32* %x\n ret i32 %y\n} +define i1 @_UInt32_opEQ(i32 %x, i32 %y) {\n %1 = icmp eq i32 %x, %y\n ret i1 %1\n} +define i1 @_UInt32_opNE(i32 %x, i32 %y) {\n %1 = icmp ne i32 %x, %y\n ret i1 %1\n} +define i1 @_UInt32_opLT(i32 %x, i32 %y) {\n %1 = icmp ult i32 %x, %y\n ret i1 %1\n} +define i1 @_UInt32_opGT(i32 %x, i32 %y) {\n %1 = icmp ugt i32 %x, %y\n ret i1 %1\n} +define i1 @_UInt32_opLE(i32 %x, i32 %y) {\n %1 = icmp ule i32 %x, %y\n ret i1 %1\n} +define i1 @_UInt32_opGE(i32 %x, i32 %y) {\n %1 = icmp uge i32 %x, %y\n ret i1 %1\n} +define i32 @_UInt32_opPlus(i32 %x, i32 %y) {\n %1 = add i32 %x, %y\n ret i32 %1\n} +define i32 @_UInt32_opMinus(i32 %x, i32 %y) {\n %1 = sub i32 %x, %y\n ret i32 %1\n} +define i32 @_UInt32_opMul(i32 %x, i32 %y) {\n %1 = mul i32 %x, %y\n ret i32 %1\n} +define i32 @_UInt32_opDiv(i32 %x, i32 %y) {\n %1 = sdiv i32 %x, %y\n ret i32 %1\n} +define i32 @_UInt32_opMod(i32 %x, i32 %y) {\n %1 = srem i32 %x, %y\n ret i32 %1\n} +define i32 @_UInt32_opPlus1(i32 %x) {\n ret i32 %x\n} + +define i64 @_Int64_opAssign(i64* %x, i64 %y) {\n store i64 %y, i64* %x\n ret i64 %y\n} +define i1 @_Int64_opEQ(i64 %x, i64 %y) {\n %1 = icmp eq i64 %x, %y\n ret i1 %1\n} +define i1 @_Int64_opNE(i64 %x, i64 %y) {\n %1 = icmp ne i64 %x, %y\n ret i1 %1\n} +define i1 @_Int64_opLT(i64 %x, i64 %y) {\n %1 = icmp slt i64 %x, %y\n ret i1 %1\n} +define i1 @_Int64_opGT(i64 %x, i64 %y) {\n %1 = icmp sgt i64 %x, %y\n ret i1 %1\n} +define i1 @_Int64_opLE(i64 %x, i64 %y) {\n %1 = icmp sle i64 %x, %y\n ret i1 %1\n} +define i1 @_Int64_opGE(i64 %x, i64 %y) {\n %1 = icmp sge i64 %x, %y\n ret i1 %1\n} +define i64 @_Int64_opPlus(i64 %x, i64 %y) {\n %1 = add i64 %x, %y\n ret i64 %1\n} +define i64 @_Int64_opMinus(i64 %x, i64 %y) {\n %1 = sub i64 %x, %y\n ret i64 %1\n} +define i64 @_Int64_opMul(i64 %x, i64 %y) {\n %1 = mul i64 %x, %y\n ret i64 %1\n} +define i64 @_Int64_opDiv(i64 %x, i64 %y) {\n %1 = sdiv i64 %x, %y\n ret i64 %1\n} +define i64 @_Int64_opMod(i64 %x, i64 %y) {\n %1 = srem i64 %x, %y\n ret i64 %1\n} +define i64 @_Int64_opPlus1(i64 %x) {\n ret i64 %x\n} +define i64 @_Int64_opMinus1(i64 %x) {\n %1 = sub i64 0, %x\n ret i64 %1\n} + +define i64 @_UInt64_opAssign(i64* %x, i64 %y) {\n store i64 %y, i64* %x\n ret i64 %y\n} +define i1 @_UInt64_opEQ(i64 %x, i64 %y) {\n %1 = icmp eq i64 %x, %y\n ret i1 %1\n} +define i1 @_UInt64_opNE(i64 %x, i64 %y) {\n %1 = icmp ne i64 %x, %y\n ret i1 %1\n} +define i1 @_UInt64_opLT(i64 %x, i64 %y) {\n %1 = icmp ult i64 %x, %y\n ret i1 %1\n} +define i1 @_UInt64_opGT(i64 %x, i64 %y) {\n %1 = icmp ugt i64 %x, %y\n ret i1 %1\n} +define i1 @_UInt64_opLE(i64 %x, i64 %y) {\n %1 = icmp ule i64 %x, %y\n ret i1 %1\n} +define i1 @_UInt64_opGE(i64 %x, i64 %y) {\n %1 = icmp uge i64 %x, %y\n ret i1 %1\n} +define i64 @_UInt64_opPlus(i64 %x, i64 %y) {\n %1 = add i64 %x, %y\n ret i64 %1\n} +define i64 @_UInt64_opMinus(i64 %x, i64 %y) {\n %1 = sub i64 %x, %y\n ret i64 %1\n} +define i64 @_UInt64_opMul(i64 %x, i64 %y) {\n %1 = mul i64 %x, %y\n ret i64 %1\n} +define i64 @_UInt64_opDiv(i64 %x, i64 %y) {\n %1 = sdiv i64 %x, %y\n ret i64 %1\n} +define i64 @_UInt64_opMod(i64 %x, i64 %y) {\n %1 = srem i64 %x, %y\n ret i64 %1\n} +define i64 @_UInt64_opPlus1(i64 %x) {\n ret i64 %x\n} + +define float @_Float32_opAssign(float* %x, float %y) {\n store float %y, float* %x\n ret float %y\n} +define i1 @_Float32_opEQ(float %x, float %y) {\n %1 = fcmp oeq float %x, %y\n ret i1 %1\n} +define i1 @_Float32_opNE(float %x, float %y) {\n %1 = fcmp one float %x, %y\n ret i1 %1\n} +define i1 @_Float32_opLT(float %x, float %y) {\n %1 = fcmp olt float %x, %y\n ret i1 %1\n} +define i1 @_Float32_opGT(float %x, float %y) {\n %1 = fcmp ogt float %x, %y\n ret i1 %1\n} +define i1 @_Float32_opLE(float %x, float %y) {\n %1 = fcmp ole float %x, %y\n ret i1 %1\n} +define i1 @_Float32_opGE(float %x, float %y) {\n %1 = fcmp oge float %x, %y\n ret i1 %1\n} +define float @_Float32_opPlus(float %x, float %y) {\n %1 = fadd float %x, %y\n ret float %1\n} +define float @_Float32_opMinus(float %x, float %y) {\n %1 = fsub float %x, %y\n ret float %1\n} +define float @_Float32_opMul(float %x, float %y) {\n %1 = fmul float %x, %y\n ret float %1\n} +define float @_Float32_opDiv(float %x, float %y) {\n %1 = fdiv float %x, %y\n ret float %1\n} +define float @_Float32_opPlus1(float %x) {\n ret float %x\n} +define float @_Float32_opMinus1(float %x) {\n %1 = fsub float 0.0, %x\n ret float %1\n} + +define double @_Float64_opAssign(double* %x, double %y) {\n store double %y, double* %x\n ret double %y\n} +define i1 @_Float64_opEQ(double %x, double %y) {\n %1 = fcmp oeq double %x, %y\n ret i1 %1\n} +define i1 @_Float64_opNE(double %x, double %y) {\n %1 = fcmp one double %x, %y\n ret i1 %1\n} +define i1 @_Float64_opLT(double %x, double %y) {\n %1 = fcmp olt double %x, %y\n ret i1 %1\n} +define i1 @_Float64_opGT(double %x, double %y) {\n %1 = fcmp ogt double %x, %y\n ret i1 %1\n} +define i1 @_Float64_opLE(double %x, double %y) {\n %1 = fcmp ole double %x, %y\n ret i1 %1\n} +define i1 @_Float64_opGE(double %x, double %y) {\n %1 = fcmp oge double %x, %y\n ret i1 %1\n} +define double @_Float64_opPlus(double %x, double %y) {\n %1 = fadd double %x, %y\n ret double %1\n} +define double @_Float64_opMinus(double %x, double %y) {\n %1 = fsub double %x, %y\n ret double %1\n} +define double @_Float64_opMul(double %x, double %y) {\n %1 = fmul double %x, %y\n ret double %1\n} +define double @_Float64_opDiv(double %x, double %y) {\n %1 = fdiv double %x, %y\n ret double %1\n} +define double @_Float64_opPlus1(double %x) {\n ret double %x\n} +define double @_Float64_opMinus1(double %x) {\n %1 = fsub double 0.0, %x\n ret double %1\n} define i8 @_Char_opAssign(i8* %x, i8 %y) {\n store i8 %y, i8* %x\n ret i8 %y\n} define i1 @_Char_opEQ(i8 %x, i8 %y) {\n %1 = icmp eq i8 %x, %y\n ret i1 %1\n} @@ -687,32 +687,6 @@ define i1 @_Char_opGE(i8 %x, i8 %y) {\n %1 = icmp sge i8 %x, %y\n define i1 @implOpRefEQ(i8* %x, i8* %y) {\n %1 = icmp eq i8* %x, %y\n ret i1 %1\n} define i1 @implOpRefNE(i8* %x, i8* %y) {\n %1 = icmp ne i8* %x, %y\n ret i1 %1\n} -define i64 @_SizeType_opAssign(i64* %x, i64 %y) {\n store i64 %y, i64* %x\n ret i64 %y\n} -define i1 @_SizeType_opEQ(i64 %x, i64 %y) {\n %1 = icmp eq i64 %x, %y\n ret i1 %1\n} -define i1 @_SizeType_opNE(i64 %x, i64 %y) {\n %1 = icmp ne i64 %x, %y\n ret i1 %1\n} -define i1 @_SizeType_opLT(i64 %x, i64 %y) {\n %1 = icmp ult i64 %x, %y\n ret i1 %1\n} -define i1 @_SizeType_opGT(i64 %x, i64 %y) {\n %1 = icmp ugt i64 %x, %y\n ret i1 %1\n} -define i1 @_SizeType_opLE(i64 %x, i64 %y) {\n %1 = icmp ule i64 %x, %y\n ret i1 %1\n} -define i1 @_SizeType_opGE(i64 %x, i64 %y) {\n %1 = icmp uge i64 %x, %y\n ret i1 %1\n} -define i64 @_SizeType_opPlus(i64 %x, i64 %y) {\n %1 = add i64 %x, %y\n ret i64 %1\n} -define i64 @_SizeType_opMinus(i64 %x, i64 %y) {\n %1 = sub i64 %x, %y\n ret i64 %1\n} -define i64 @_SizeType_opMul(i64 %x, i64 %y) {\n %1 = mul i64 %x, %y\n ret i64 %1\n} -define i64 @_SizeType_opDiv(i64 %x, i64 %y) {\n %1 = sdiv i64 %x, %y\n ret i64 %1\n} -define i64 @_SizeType_opMod(i64 %x, i64 %y) {\n %1 = srem i64 %x, %y\n ret i64 %1\n} -define i64 @_SizeType_opPlus1(i64 %x) {\n ret i64 %x\n} - - -define i64 @intToSizeType(i32 %n) { - %1 = sext i32 %n to i64 - ret i64 %1 -} - -define i8 @intToByte(i32 %n) { - %1 = trunc i32 %n to i8 - ret i8 %1 -} - - define void @writeLnByte(i8 %val) { %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.fmtIntN, i32 0, i32 0), i8 %val) ret void @@ -738,12 +712,12 @@ define void @writeLnSizeType(i64 %val) { ret void } -define void @writeLnFloat(float %val) { +define void @writeLnFloat32(float %val) { %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.fmtDoubleN, i32 0, i32 0), float %val) ret void } -define void @writeLnDouble(double %val) { +define void @writeLnFloat64(double %val) { %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.fmtDoubleN, i32 0, i32 0), double %val) ret void } @@ -778,7 +752,7 @@ define void @writeInt(i32 %val) { ret void } -define void @writeSizeType(i64 %val) { +define void @writeLong(i64 %val) { %1 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.fmtInt, i32 0, i32 0), i64 %val) ret void } @@ -824,27 +798,30 @@ define void @_Type_copy_ctor(i8** %$this, i8* %other) [ct, protected] [native("_Type_ctor")] fun ctor(this: !Type) [native("_Type_copy_ctor")] fun ctor(this: !Type, other: Type) - //fun dtor(this: !Type) {} - -[noDefault] - datatype Uninitialized {} - - [bitcopiable, native("Null")] datatype Null {} - - [bitcopiable, native("i1")] datatype Bool {} - [bitcopiable, native("i8")] datatype Byte {} - [bitcopiable, convert, native("u8")] datatype UByte {} - [bitcopiable, convert, native("i16")] datatype Short {} - [bitcopiable, convert, native("u16")] datatype UShort {} - [bitcopiable, convert, native("i32")] datatype Int {} - [bitcopiable, convert, native("u32")] datatype UInt {} - [bitcopiable, convert, native("i64")] datatype Long {} - [bitcopiable, convert, native("u64")] datatype ULong {} - [bitcopiable, convert, native("u64")] datatype SizeType {} - [bitcopiable, convert, native("i64")] datatype DiffType {} - [bitcopiable, convert, native("float")] datatype Float {} - [bitcopiable, convert, native("double")] datatype Double {} - [bitcopiable, native("i8")] datatype Char {} + +[noDefault, bitcopiable] + datatype Uninitialized + + [native("Null")] datatype Null + + [native("i1")] datatype Bool + + [native("i8")] datatype Int8 + [native("u8")] datatype UInt8 + [native("i16")] datatype Int16 + [native("u16")] datatype UInt16 + [native("i32")] datatype Int + [native("u32")] datatype UInt32 + [native("i64")] datatype Int64 + [native("u64")] datatype UInt64 + + [native("float")] datatype Float32 + [native("double")] datatype Float + + [native("i8")] datatype Char + +using Int32 = Int +using Float64 = Float [protected] fun ctor(this: Uninitialized) {} @@ -861,244 +838,184 @@ define void @_Type_copy_ctor(i8** %$this, i8* %other) fun dtor(this: !Bool) {} [autoCt, native("_ass_1_1")] fun = (this: !Bool, other: Bool): Bool - [native("_zero_init_8")] fun ctor(this: !Byte) - [native("_ass_8_8")] fun ctor(this: !Byte, src: Byte) - [native("_ass_8_8")] fun ctor(this: !Byte, src: Char) - [native("_ass_8_8")] fun ctor(this: !Byte, src: UByte) - [native("_ass_8_16")] fun ctor(this: !Byte, src: Short) - [native("_ass_8_16")] fun ctor(this: !Byte, src: UShort) - [native("_ass_8_32")] fun ctor(this: !Byte, src: Int) - [native("_ass_8_32")] fun ctor(this: !Byte, src: UInt) - [native("_ass_8_64")] fun ctor(this: !Byte, src: Long) - [native("_ass_8_64")] fun ctor(this: !Byte, src: ULong) - [native("_ass_8_64")] fun ctor(this: !Byte, src: SizeType) - [native("_ass_8_64")] fun ctor(this: !Byte, src: DiffType) - [native("_ass_i8_f")] fun ctor(this: !Byte, src: Float) - [native("_ass_i8_d")] fun ctor(this: !Byte, src: Double) - fun dtor(this: Byte) {} - [native("_ass_8_8")] fun = (this: !Byte, other: Byte) - - [native("_zero_init_8")] fun ctor(this: !UByte) - [native("_ass_8_8"), convert] fun ctor(this: !UByte, src: Byte) - [native("_ass_8_8")] fun ctor(this: !UByte, src: UByte) - [native("_ass_8_16")] fun ctor(this: !UByte, src: Short) - [native("_ass_8_16")] fun ctor(this: !UByte, src: UShort) - [native("_ass_8_32")] fun ctor(this: !UByte, src: Int) - [native("_ass_8_32")] fun ctor(this: !UByte, src: UInt) - [native("_ass_8_64")] fun ctor(this: !UByte, src: Long) - [native("_ass_8_64")] fun ctor(this: !UByte, src: ULong) - [native("_ass_8_64")] fun ctor(this: !UByte, src: SizeType) - [native("_ass_8_64")] fun ctor(this: !UByte, src: DiffType) - [native("_ass_u8_f")] fun ctor(this: !UByte, src: Float) - [native("_ass_u8_d")] fun ctor(this: !UByte, src: Double) - fun dtor(this: UByte) {} - [native("_ass_8_8")] fun = (this: !UByte, other: UByte) - - [native("_zero_init_16")] fun ctor(this: !Short) - [native("_ass_16_8s"), convert] fun ctor(this: !Short, src: Byte) - [native("_ass_16_8z"), convert] fun ctor(this: !Short, src: UByte) - [native("_ass_16_16")] fun ctor(this: !Short, src: Short) - [native("_ass_16_16")] fun ctor(this: !Short, src: UShort) - [native("_ass_16_32")] fun ctor(this: !Short, src: Int) - [native("_ass_16_32")] fun ctor(this: !Short, src: UInt) - [native("_ass_16_64")] fun ctor(this: !Short, src: Long) - [native("_ass_16_64")] fun ctor(this: !Short, src: ULong) - [native("_ass_16_64")] fun ctor(this: !Short, src: SizeType) - [native("_ass_16_64")] fun ctor(this: !Short, src: DiffType) - [native("_ass_i16_f")] fun ctor(this: !Short, src: Float) - [native("_ass_i16_d")] fun ctor(this: !Short, src: Double) - fun dtor(this: Short) {} - [native("_ass_16_16")] fun = (this: !Short, other: Short) - - [native("_zero_init_16")] fun ctor(this: !UShort) - [native("_ass_16_8z"), convert] fun ctor(this: !UShort, src: Byte) - [native("_ass_16_8z"), convert] fun ctor(this: !UShort, src: UByte) - [native("_ass_16_16"), convert] fun ctor(this: !UShort, src: Short) - [native("_ass_16_16")] fun ctor(this: !UShort, src: UShort) - [native("_ass_16_32")] fun ctor(this: !UShort, src: Int) - [native("_ass_16_32")] fun ctor(this: !UShort, src: UInt) - [native("_ass_16_64")] fun ctor(this: !UShort, src: Long) - [native("_ass_16_64")] fun ctor(this: !UShort, src: ULong) - [native("_ass_16_64")] fun ctor(this: !UShort, src: SizeType) - [native("_ass_16_64")] fun ctor(this: !UShort, src: DiffType) - [native("_ass_u16_f")] fun ctor(this: !UShort, src: Float) - [native("_ass_u16_d")] fun ctor(this: !UShort, src: Double) - fun dtor(this: UShort) {} - [native("_ass_16_16")] fun = (this: !UShort, other: UShort) - - [native("_zero_init_32")] fun ctor(this: !Int) - [native("_ass_32_8s"), convert] fun ctor(this: !Int, src: Byte) - [native("_ass_32_8z"), convert] fun ctor(this: !Int, src: UByte) - [native("_ass_32_16s"), convert] fun ctor(this: !Int, src: Short) - [native("_ass_32_16z"), convert] fun ctor(this: !Int, src: UShort) - [native("_ass_32_32")] fun ctor(this: !Int, src: Int) - [native("_ass_32_32")] fun ctor(this: !Int, src: UInt) - [native("_ass_32_64")] fun ctor(this: !Int, src: Long) - [native("_ass_32_64")] fun ctor(this: !Int, src: ULong) - [native("_ass_32_64")] fun ctor(this: !Int, src: SizeType) - [native("_ass_32_64")] fun ctor(this: !Int, src: DiffType) - [native("_ass_i32_f")] fun ctor(this: !Int, src: Float) - [native("_ass_i32_d")] fun ctor(this: !Int, src: Double) - [native("_ass_32_8z")] fun ctor(this: !Int, src: Char) - fun dtor(this: Int) {} - [native("_ass_32_32")] fun = (this: !Int, other: Int) - - [native("_zero_init_32")] fun ctor(this: !UInt) - [native("_ass_32_8z"), convert] fun ctor(this: !UInt, src: Byte) - [native("_ass_32_8z"), convert] fun ctor(this: !UInt, src: UByte) - [native("_ass_32_16z"), convert] fun ctor(this: !UInt, src: Short) - [native("_ass_32_16z"), convert] fun ctor(this: !UInt, src: UShort) - [native("_ass_32_32"), convert] fun ctor(this: !UInt, src: Int) - [native("_ass_32_32")] fun ctor(this: !UInt, src: UInt) - [native("_ass_32_64")] fun ctor(this: !UInt, src: Long) - [native("_ass_32_64")] fun ctor(this: !UInt, src: ULong) - [native("_ass_32_64")] fun ctor(this: !UInt, src: SizeType) - [native("_ass_32_64")] fun ctor(this: !UInt, src: DiffType) - [native("_ass_u32_f")] fun ctor(this: !UInt, src: Float) - [native("_ass_u32_d")] fun ctor(this: !UInt, src: Double) - fun dtor(this: UInt) {} - [native("_ass_32_32")] fun = (this: !UInt, other: UInt) - - [native("_zero_init_64")] fun ctor(this: !Long) - [native("_ass_64_8s"), convert] fun ctor(this: !Long, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !Long, src: UByte) - [native("_ass_64_16s"), convert] fun ctor(this: !Long, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !Long, src: UShort) - [native("_ass_64_32s"), convert] fun ctor(this: !Long, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !Long, src: UInt) - [native("_ass_64_64")] fun ctor(this: !Long, src: Long) - [native("_ass_64_64")] fun ctor(this: !Long, src: ULong) - [native("_ass_64_64"), convert] fun ctor(this: !Long, src: SizeType) - [native("_ass_64_64"), convert] fun ctor(this: !Long, src: DiffType) - [native("_ass_i64_f")] fun ctor(this: !Long, src: Float) - [native("_ass_i64_d")] fun ctor(this: !Long, src: Double) - fun dtor(this: Long) {} - [native("_ass_64_64")] fun = (this: !Long, other: Long) - - [native("_zero_init_64")] fun ctor(this: !ULong) - [native("_ass_64_8z"), convert] fun ctor(this: !ULong, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !ULong, src: UByte) - [native("_ass_64_16z"), convert] fun ctor(this: !ULong, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !ULong, src: UShort) - [native("_ass_64_32z"), convert] fun ctor(this: !ULong, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !ULong, src: UInt) - [native("_ass_64_64"), convert] fun ctor(this: !ULong, src: Long) - [native("_ass_64_64")] fun ctor(this: !ULong, src: ULong) - [native("_ass_64_64"), convert] fun ctor(this: !ULong, src: SizeType) - [native("_ass_64_64"), convert] fun ctor(this: !ULong, src: DiffType) - [native("_ass_u64_f")] fun ctor(this: !ULong, src: Float) - [native("_ass_u64_d")] fun ctor(this: !ULong, src: Double) - fun dtor(this: !ULong) {} - [native("_ass_64_64")] fun = (this: !ULong, other: ULong) - - [native("_zero_init_64")] fun ctor(this: !SizeType) - [native("_ass_64_8z"), convert] fun ctor(this: !SizeType, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !SizeType, src: UByte) - [native("_ass_64_16z"), convert] fun ctor(this: !SizeType, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !SizeType, src: UShort) - [native("_ass_64_32z"), convert] fun ctor(this: !SizeType, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !SizeType, src: UInt) - [native("_ass_64_64")] fun ctor(this: !SizeType, src: Long) - [native("_ass_64_64")] fun ctor(this: !SizeType, src: ULong) - [native("_ass_64_64")] fun ctor(this: !SizeType, src: SizeType) - [native("_ass_64_64"), convert] fun ctor(this: !SizeType, src: DiffType) - [native("_ass_u64_f")] fun ctor(this: !SizeType, src: Float) - [native("_ass_u64_d")] fun ctor(this: !SizeType, src: Double) - fun dtor(this: SizeType) {} - [native("_ass_64_64")] fun = (this: !SizeType, other: SizeType) - - [native("_zero_init_64")] fun ctor(this: !DiffType) - [native("_ass_64_8s"), convert] fun ctor(this: !DiffType, src: Byte) - [native("_ass_64_8z"), convert] fun ctor(this: !DiffType, src: UByte) - [native("_ass_64_16s"), convert] fun ctor(this: !DiffType, src: Short) - [native("_ass_64_16z"), convert] fun ctor(this: !DiffType, src: UShort) - [native("_ass_64_32s"), convert] fun ctor(this: !DiffType, src: Int) - [native("_ass_64_32z"), convert] fun ctor(this: !DiffType, src: UInt) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: Long) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: ULong) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: SizeType) - [native("_ass_64_64")] fun ctor(this: !DiffType, src: DiffType) - [native("_ass_i64_f")] fun ctor(this: !DiffType, src: Float) - [native("_ass_i64_d")] fun ctor(this: !DiffType, src: Double) - fun dtor(this: DiffType) {} - [native("_ass_64_64")] fun = (this: !DiffType, other: DiffType) - - [native("_zero_init_f")] fun ctor(this: !Float) - [native("_ass_f_i8"), convert] fun ctor(this: !Float, src: Byte) - [native("_ass_f_u8"), convert] fun ctor(this: !Float, src: UByte) - [native("_ass_f_i16"), convert] fun ctor(this: !Float, src: Short) - [native("_ass_f_u16"), convert] fun ctor(this: !Float, src: UShort) - [native("_ass_f_i32"), convert] fun ctor(this: !Float, src: Int) - [native("_ass_f_u32"), convert] fun ctor(this: !Float, src: UInt) - [native("_ass_f_i64"), convert] fun ctor(this: !Float, src: Long) - [native("_ass_f_u64"), convert] fun ctor(this: !Float, src: ULong) - [native("_ass_f_i64"), convert] fun ctor(this: !Float, src: SizeType) - [native("_ass_f_u64"), convert] fun ctor(this: !Float, src: DiffType) - [native("_ass_f_f")] fun ctor(this: !Float, src: Float) - [native("_ass_f_d")] fun ctor(this: !Float, src: Double) - fun dtor(this: Float) {} - [native("_ass_f_f")] fun = (this: !Float, other: Float) - - [native("_zero_init_d")] fun ctor(this: !Double) - [native("_ass_d_i8"), convert] fun ctor(this: !Double, src: Byte) - [native("_ass_d_u8"), convert] fun ctor(this: !Double, src: UByte) - [native("_ass_d_i16"), convert] fun ctor(this: !Double, src: Short) - [native("_ass_d_u16"), convert] fun ctor(this: !Double, src: UShort) - [native("_ass_d_i32"), convert] fun ctor(this: !Double, src: Int) - [native("_ass_d_u32"), convert] fun ctor(this: !Double, src: UInt) - [native("_ass_d_i64"), convert] fun ctor(this: !Double, src: Long) - [native("_ass_d_u64"), convert] fun ctor(this: !Double, src: ULong) - [native("_ass_d_i64"), convert] fun ctor(this: !Double, src: SizeType) - [native("_ass_d_u64"), convert] fun ctor(this: !Double, src: DiffType) - [native("_ass_d_f"), convert] fun ctor(this: !Double, src: Float) - [native("_ass_d_d")] fun ctor(this: !Double, src: Double) - fun dtor(this: Double) {} - [native("_ass_d_d")] fun = (this: !Double, other: Double) + [native("_zero_init_8")] fun ctor(this: !Int8) + [native("_ass_8_8")] fun ctor(this: !Int8, src: Int8) + [native("_ass_8_8")] fun ctor(this: !Int8, src: Char) + [native("_ass_8_8")] fun ctor(this: !Int8, src: UInt8) + [native("_ass_8_16")] fun ctor(this: !Int8, src: Int16) + [native("_ass_8_16")] fun ctor(this: !Int8, src: UInt16) + [native("_ass_8_32")] fun ctor(this: !Int8, src: Int32) + [native("_ass_8_32")] fun ctor(this: !Int8, src: UInt32) + [native("_ass_8_64")] fun ctor(this: !Int8, src: Int64) + [native("_ass_8_64")] fun ctor(this: !Int8, src: UInt64) + [native("_ass_i8_f")] fun ctor(this: !Int8, src: Float32) + [native("_ass_i8_d")] fun ctor(this: !Int8, src: Float64) + fun dtor(this: Int8) {} + [native("_ass_8_8")] fun = (this: !Int8, other: Int8) + + [native("_zero_init_8")] fun ctor(this: !UInt8) + [native("_ass_8_8")] fun ctor(this: !UInt8, src: Int8) + [native("_ass_8_8")] fun ctor(this: !UInt8, src: UInt8) + [native("_ass_8_16")] fun ctor(this: !UInt8, src: Int16) + [native("_ass_8_16")] fun ctor(this: !UInt8, src: UInt16) + [native("_ass_8_32")] fun ctor(this: !UInt8, src: Int32) + [native("_ass_8_32")] fun ctor(this: !UInt8, src: UInt32) + [native("_ass_8_64")] fun ctor(this: !UInt8, src: Int64) + [native("_ass_8_64")] fun ctor(this: !UInt8, src: UInt64) + [native("_ass_u8_f")] fun ctor(this: !UInt8, src: Float32) + [native("_ass_u8_d")] fun ctor(this: !UInt8, src: Float64) + fun dtor(this: UInt8) {} + [native("_ass_8_8")] fun = (this: !UInt8, other: UInt8) + + [native("_zero_init_16")] fun ctor(this: !Int16) + [native("_ass_16_8s")] fun ctor(this: !Int16, src: Int8) + [native("_ass_16_8z")] fun ctor(this: !Int16, src: UInt8) + [native("_ass_16_16")] fun ctor(this: !Int16, src: Int16) + [native("_ass_16_16")] fun ctor(this: !Int16, src: UInt16) + [native("_ass_16_32")] fun ctor(this: !Int16, src: Int32) + [native("_ass_16_32")] fun ctor(this: !Int16, src: UInt32) + [native("_ass_16_64")] fun ctor(this: !Int16, src: Int64) + [native("_ass_16_64")] fun ctor(this: !Int16, src: UInt64) + [native("_ass_i16_f")] fun ctor(this: !Int16, src: Float32) + [native("_ass_i16_d")] fun ctor(this: !Int16, src: Float64) + fun dtor(this: Int16) {} + [native("_ass_16_16")] fun = (this: !Int16, other: Int16) + + [native("_zero_init_16")] fun ctor(this: !UInt16) + [native("_ass_16_8z")] fun ctor(this: !UInt16, src: Int8) + [native("_ass_16_8z")] fun ctor(this: !UInt16, src: UInt8) + [native("_ass_16_16")] fun ctor(this: !UInt16, src: Int16) + [native("_ass_16_16")] fun ctor(this: !UInt16, src: UInt16) + [native("_ass_16_32")] fun ctor(this: !UInt16, src: Int32) + [native("_ass_16_32")] fun ctor(this: !UInt16, src: UInt32) + [native("_ass_16_64")] fun ctor(this: !UInt16, src: Int64) + [native("_ass_16_64")] fun ctor(this: !UInt16, src: UInt64) + [native("_ass_u16_f")] fun ctor(this: !UInt16, src: Float32) + [native("_ass_u16_d")] fun ctor(this: !UInt16, src: Float64) + fun dtor(this: UInt16) {} + [native("_ass_16_16")] fun = (this: !UInt16, other: UInt16) + + [native("_zero_init_32")] fun ctor(this: !Int32) + [native("_ass_32_8s")] fun ctor(this: !Int32, src: Int8) + [native("_ass_32_8z")] fun ctor(this: !Int32, src: UInt8) + [native("_ass_32_16s")] fun ctor(this: !Int32, src: Int16) + [native("_ass_32_16z")] fun ctor(this: !Int32, src: UInt16) + [native("_ass_32_32")] fun ctor(this: !Int32, src: Int32) + [native("_ass_32_32")] fun ctor(this: !Int32, src: UInt32) + [native("_ass_32_64")] fun ctor(this: !Int32, src: Int64) + [native("_ass_32_64")] fun ctor(this: !Int32, src: UInt64) + [native("_ass_i32_f")] fun ctor(this: !Int32, src: Float32) + [native("_ass_i32_d")] fun ctor(this: !Int32, src: Float64) + [native("_ass_32_8z")] fun ctor(this: !Int32, src: Char) + fun dtor(this: Int32) {} + [native("_ass_32_32")] fun = (this: !Int32, other: Int32) + + [native("_zero_init_32")] fun ctor(this: !UInt32) + [native("_ass_32_8z")] fun ctor(this: !UInt32, src: Int8) + [native("_ass_32_8z")] fun ctor(this: !UInt32, src: UInt8) + [native("_ass_32_16z")] fun ctor(this: !UInt32, src: Int16) + [native("_ass_32_16z")] fun ctor(this: !UInt32, src: UInt16) + [native("_ass_32_32")] fun ctor(this: !UInt32, src: Int32) + [native("_ass_32_32")] fun ctor(this: !UInt32, src: UInt32) + [native("_ass_32_64")] fun ctor(this: !UInt32, src: Int64) + [native("_ass_32_64")] fun ctor(this: !UInt32, src: UInt64) + [native("_ass_u32_f")] fun ctor(this: !UInt32, src: Float32) + [native("_ass_u32_d")] fun ctor(this: !UInt32, src: Float64) + fun dtor(this: UInt32) {} + [native("_ass_32_32")] fun = (this: !UInt32, other: UInt32) + + [native("_zero_init_64")] fun ctor(this: !Int64) + [native("_ass_64_8s")] fun ctor(this: !Int64, src: Int8) + [native("_ass_64_8z")] fun ctor(this: !Int64, src: UInt8) + [native("_ass_64_16s")] fun ctor(this: !Int64, src: Int16) + [native("_ass_64_16z")] fun ctor(this: !Int64, src: UInt16) + [native("_ass_64_32s")] fun ctor(this: !Int64, src: Int32) + [native("_ass_64_32z")] fun ctor(this: !Int64, src: UInt32) + [native("_ass_64_64")] fun ctor(this: !Int64, src: Int64) + [native("_ass_64_64")] fun ctor(this: !Int64, src: UInt64) + [native("_ass_i64_f")] fun ctor(this: !Int64, src: Float32) + [native("_ass_i64_d")] fun ctor(this: !Int64, src: Float64) + fun dtor(this: Int64) {} + [native("_ass_64_64")] fun = (this: !Int64, other: Int64) + + [native("_zero_init_64")] fun ctor(this: !UInt64) + [native("_ass_64_8z")] fun ctor(this: !UInt64, src: Int8) + [native("_ass_64_8z")] fun ctor(this: !UInt64, src: UInt8) + [native("_ass_64_16z")] fun ctor(this: !UInt64, src: Int16) + [native("_ass_64_16z")] fun ctor(this: !UInt64, src: UInt16) + [native("_ass_64_32z")] fun ctor(this: !UInt64, src: Int32) + [native("_ass_64_32z")] fun ctor(this: !UInt64, src: UInt32) + [native("_ass_64_64")] fun ctor(this: !UInt64, src: Int64) + [native("_ass_64_64")] fun ctor(this: !UInt64, src: UInt64) + [native("_ass_u64_f")] fun ctor(this: !UInt64, src: Float32) + [native("_ass_u64_d")] fun ctor(this: !UInt64, src: Float64) + fun dtor(this: UInt64) {} + [native("_ass_64_64")] fun = (this: !UInt64, other: UInt64) + + [native("_zero_init_f")] fun ctor(this: !Float32) + [native("_ass_f_i8")] fun ctor(this: !Float32, src: Int8) + [native("_ass_f_u8")] fun ctor(this: !Float32, src: UInt8) + [native("_ass_f_i16")] fun ctor(this: !Float32, src: Int16) + [native("_ass_f_u16")] fun ctor(this: !Float32, src: UInt16) + [native("_ass_f_i32")] fun ctor(this: !Float32, src: Int32) + [native("_ass_f_u32")] fun ctor(this: !Float32, src: UInt32) + [native("_ass_f_i64")] fun ctor(this: !Float32, src: Int64) + [native("_ass_f_u64")] fun ctor(this: !Float32, src: UInt64) + [native("_ass_f_f")] fun ctor(this: !Float32, src: Float32) + [native("_ass_f_d")] fun ctor(this: !Float32, src: Float64) + fun dtor(this: Float32) {} + [native("_ass_f_f")] fun = (this: !Float32, other: Float32) + + [native("_zero_init_d")] fun ctor(this: !Float64) + [native("_ass_d_i8")] fun ctor(this: !Float64, src: Int8) + [native("_ass_d_u8")] fun ctor(this: !Float64, src: UInt8) + [native("_ass_d_i16")] fun ctor(this: !Float64, src: Int16) + [native("_ass_d_u16")] fun ctor(this: !Float64, src: UInt16) + [native("_ass_d_i32")] fun ctor(this: !Float64, src: Int32) + [native("_ass_d_u32")] fun ctor(this: !Float64, src: UInt32) + [native("_ass_d_i64")] fun ctor(this: !Float64, src: Int64) + [native("_ass_d_u64")] fun ctor(this: !Float64, src: UInt64) + [native("_ass_d_f")] fun ctor(this: !Float64, src: Float32) + [native("_ass_d_d")] fun ctor(this: !Float64, src: Float64) + fun dtor(this: Float64) {} + [native("_ass_d_d")] fun = (this: !Float64, other: Float64) [native("_zero_init_8")] fun ctor(this: !Char) [native("_ass_8_8")] fun ctor(this: !Char, src: Char) - [native("_ass_8_8")] fun ctor(this: !Char, src: Byte) - [native("_ass_8_8")] fun ctor(this: !Char, src: UByte) - [native("_ass_8_16")] fun ctor(this: !Char, src: Short) - [native("_ass_8_16")] fun ctor(this: !Char, src: UShort) - [native("_ass_8_32")] fun ctor(this: !Char, src: Int) - [native("_ass_8_32")] fun ctor(this: !Char, src: UInt) - [native("_ass_8_64")] fun ctor(this: !Char, src: Long) - [native("_ass_8_64")] fun ctor(this: !Char, src: ULong) - [native("_ass_8_64")] fun ctor(this: !Char, src: SizeType) - [native("_ass_8_64")] fun ctor(this: !Char, src: DiffType) + [native("_ass_8_8")] fun ctor(this: !Char, src: Int8) + [native("_ass_8_32")] fun ctor(this: !Char, src: Int32) fun dtor(this: Char) {} [native("_ass_8_8")] fun = (this: !Char, other: Char) [noDefault, bitcopiable, native("StringRef")] datatype StringRef - begin: @Byte - end: @Byte + begin: @Int8 + end: @Int8 [protected] fun ctor(this: !StringRef) begin := null end := null - fun ctor(this: !StringRef, size: SizeType) - begin := malloc(size + intToSizeType(1)) + fun ctor(this: !StringRef, size: Int) + begin := malloc(size + 1) end := ptrAdd(begin, size) - end = intToByte(0) + end = Int8(0) fun ctor(this: !StringRef, other: StringRef) begin := other.begin end := other.end fun dtor(this: StringRef) {} -fun size(this: StringRef): SizeType +fun size(this: StringRef): Int return ptrDiff(end, begin); -fun getChar(this: StringRef, i: SizeType): Char +fun getChar(this: StringRef, i: Int): Char return reinterpretCast(@Char, ptrAdd(begin, i)); fun == (this, other: StringRef): Bool let s = this.size() if ( s != other.size() ) return false - var i: SizeType = 0 - while i (x, y: Byte): Bool -[autoCt, native("_Byte_opLE")] fun <= (x, y: Byte): Bool -[autoCt, native("_Byte_opGE")] fun >= (x, y: Byte): Bool -[autoCt, native("_Byte_opPlus")] fun + (x, y: Byte): Byte -[autoCt, native("_Byte_opMinus")] fun - (x, y: Byte): Byte -[autoCt, native("_Byte_opMul")] fun * (x, y: Byte): Byte -[autoCt, native("_Byte_opDiv")] fun / (x, y: Byte): Byte -[autoCt, native("_Byte_opMod")] fun % (x, y: Byte): Byte -[autoCt, native("_Byte_opPlus1")] fun + (x: Byte): Byte -[autoCt, native("_Byte_opMinus1")] fun - (x: Byte): Byte - -[autoCt, native("_UByte_opEQ")] fun == (x, y: UByte): Bool -[autoCt, native("_UByte_opNE")] fun != (x, y: UByte): Bool -[autoCt, native("_UByte_opLT")] fun < (x, y: UByte): Bool -[autoCt, native("_UByte_opGT")] fun > (x, y: UByte): Bool -[autoCt, native("_UByte_opLE")] fun <= (x, y: UByte): Bool -[autoCt, native("_UByte_opGE")] fun >= (x, y: UByte): Bool -[autoCt, native("_UByte_opPlus")] fun + (x, y: UByte): UByte -[autoCt, native("_UByte_opMinus")] fun - (x, y: UByte): UByte -[autoCt, native("_UByte_opMul")] fun * (x, y: UByte): UByte -[autoCt, native("_UByte_opDiv")] fun / (x, y: UByte): UByte -[autoCt, native("_UByte_opMod")] fun % (x, y: UByte): UByte -[autoCt, native("_UByte_opPlus1")] fun + (x: UByte): UByte - -[autoCt, native("_Short_opEQ")] fun == (x, y: Short): Bool -[autoCt, native("_Short_opNE")] fun != (x, y: Short): Bool -[autoCt, native("_Short_opLT")] fun < (x, y: Short): Bool -[autoCt, native("_Short_opGT")] fun > (x, y: Short): Bool -[autoCt, native("_Short_opLE")] fun <= (x, y: Short): Bool -[autoCt, native("_Short_opGE")] fun >= (x, y: Short): Bool -[autoCt, native("_Short_opPlus")] fun + (x, y: Short): Short -[autoCt, native("_Short_opMinus")] fun - (x, y: Short): Short -[autoCt, native("_Short_opMul")] fun * (x, y: Short): Short -[autoCt, native("_Short_opDiv")] fun / (x, y: Short): Short -[autoCt, native("_Short_opMod")] fun % (x, y: Short): Short -[autoCt, native("_Short_opPlus1")] fun + (x: Short): Short -[autoCt, native("_Short_opMinus1")] fun - (x: Short): Short - -[autoCt, native("_UShort_opEQ")] fun == (x, y: UShort): Bool -[autoCt, native("_UShort_opNE")] fun != (x, y: UShort): Bool -[autoCt, native("_UShort_opLT")] fun < (x, y: UShort): Bool -[autoCt, native("_UShort_opGT")] fun > (x, y: UShort): Bool -[autoCt, native("_UShort_opLE")] fun <= (x, y: UShort): Bool -[autoCt, native("_UShort_opGE")] fun >= (x, y: UShort): Bool -[autoCt, native("_UShort_opPlus")] fun + (x, y: UShort): UShort -[autoCt, native("_UShort_opMinus")] fun - (x, y: UShort): UShort -[autoCt, native("_UShort_opMul")] fun * (x, y: UShort): UShort -[autoCt, native("_UShort_opDiv")] fun / (x, y: UShort): UShort -[autoCt, native("_UShort_opMod")] fun % (x, y: UShort): UShort -[autoCt, native("_UShort_opPlus1")] fun + (x: UShort): UShort - -[autoCt, native("_Int_opEQ")] fun == (x, y: Int): Bool -[autoCt, native("_Int_opNE")] fun != (x, y: Int): Bool -[autoCt, native("_Int_opLT")] fun < (x, y: Int): Bool -[autoCt, native("_Int_opGT")] fun > (x, y: Int): Bool -[autoCt, native("_Int_opLE")] fun <= (x, y: Int): Bool -[autoCt, native("_Int_opGE")] fun >= (x, y: Int): Bool -[autoCt, native("_Int_opPlus")] fun + (x, y: Int): Int -[autoCt, native("_Int_opMinus")] fun - (x, y: Int): Int -[autoCt, native("_Int_opMul")] fun * (x, y: Int): Int -[autoCt, native("_Int_opDiv")] fun / (x, y: Int): Int -[autoCt, native("_Int_opMod")] fun % (x, y: Int): Int -[autoCt, native("_Int_opPlus1")] fun + (x: Int): Int -[autoCt, native("_Int_opMinus1")] fun - (x: Int): Int - -[autoCt, native("_UInt_opEQ")] fun == (x, y: UInt): Bool -[autoCt, native("_UInt_opNE")] fun != (x, y: UInt): Bool -[autoCt, native("_UInt_opLT")] fun < (x, y: UInt): Bool -[autoCt, native("_UInt_opGT")] fun > (x, y: UInt): Bool -[autoCt, native("_UInt_opLE")] fun <= (x, y: UInt): Bool -[autoCt, native("_UInt_opGE")] fun >= (x, y: UInt): Bool -[autoCt, native("_UInt_opPlus")] fun + (x, y: UInt): UInt -[autoCt, native("_UInt_opMinus")] fun - (x, y: UInt): UInt -[autoCt, native("_UInt_opMul")] fun * (x, y: UInt): UInt -[autoCt, native("_UInt_opDiv")] fun / (x, y: UInt): UInt -[autoCt, native("_UInt_opMod")] fun % (x, y: UInt): UInt -[autoCt, native("_UInt_opPlus1")] fun + (x: UInt): UInt - -[autoCt, native("_Long_opEQ")] fun == (x, y: Long): Bool -[autoCt, native("_Long_opNE")] fun != (x, y: Long): Bool -[autoCt, native("_Long_opLT")] fun < (x, y: Long): Bool -[autoCt, native("_Long_opGT")] fun > (x, y: Long): Bool -[autoCt, native("_Long_opLE")] fun <= (x, y: Long): Bool -[autoCt, native("_Long_opGE")] fun >= (x, y: Long): Bool -[autoCt, native("_Long_opPlus")] fun + (x, y: Long): Long -[autoCt, native("_Long_opMinus")] fun - (x, y: Long): Long -[autoCt, native("_Long_opMul")] fun * (x, y: Long): Long -[autoCt, native("_Long_opDiv")] fun / (x, y: Long): Long -[autoCt, native("_Long_opMod")] fun % (x, y: Long): Long -[autoCt, native("_Long_opPlus1")] fun + (x: Long): Long -[autoCt, native("_Long_opMinus1")] fun - (x: Long): Long - -[autoCt, native("_ULong_opEQ")] fun == (x, y: ULong): Bool -[autoCt, native("_ULong_opNE")] fun != (x, y: ULong): Bool -[autoCt, native("_ULong_opLT")] fun < (x, y: ULong): Bool -[autoCt, native("_ULong_opGT")] fun > (x, y: ULong): Bool -[autoCt, native("_ULong_opLE")] fun <= (x, y: ULong): Bool -[autoCt, native("_ULong_opGE")] fun >= (x, y: ULong): Bool -[autoCt, native("_ULong_opPlus")] fun + (x, y: ULong): ULong -[autoCt, native("_ULong_opMinus")] fun - (x, y: ULong): ULong -[autoCt, native("_ULong_opMul")] fun * (x, y: ULong): ULong -[autoCt, native("_ULong_opDiv")] fun / (x, y: ULong): ULong -[autoCt, native("_ULong_opMod")] fun % (x, y: ULong): ULong -[autoCt, native("_ULong_opPlus1")] fun + (x: ULong): ULong - -[autoCt, native("_Float_opEQ")] fun == (x, y: Float): Bool -[autoCt, native("_Float_opNE")] fun != (x, y: Float): Bool -[autoCt, native("_Float_opLT")] fun < (x, y: Float): Bool -[autoCt, native("_Float_opGT")] fun > (x, y: Float): Bool -[autoCt, native("_Float_opLE")] fun <= (x, y: Float): Bool -[autoCt, native("_Float_opGE")] fun >= (x, y: Float): Bool -[autoCt, native("_Float_opPlus")] fun + (x, y: Float): Float -[autoCt, native("_Float_opMinus")] fun - (x, y: Float): Float -[autoCt, native("_Float_opMul")] fun * (x, y: Float): Float -[autoCt, native("_Float_opDiv")] fun / (x, y: Float): Float -[autoCt, native("_Float_opPlus1")] fun + (x: Float): Float -[autoCt, native("_Float_opMinus1")] fun - (x: Float): Float - -[autoCt, native("_Double_opEQ")] fun == (x, y: Double): Bool -[autoCt, native("_Double_opNE")] fun != (x, y: Double): Bool -[autoCt, native("_Double_opLT")] fun < (x, y: Double): Bool -[autoCt, native("_Double_opGT")] fun > (x, y: Double): Bool -[autoCt, native("_Double_opLE")] fun <= (x, y: Double): Bool -[autoCt, native("_Double_opGE")] fun >= (x, y: Double): Bool -[autoCt, native("_Double_opPlus")] fun + (x, y: Double): Double -[autoCt, native("_Double_opMinus")] fun - (x, y: Double): Double -[autoCt, native("_Double_opMul")] fun * (x, y: Double): Double -[autoCt, native("_Double_opDiv")] fun / (x, y: Double): Double -[autoCt, native("_Double_opPlus1")] fun + (x: Double): Double -[autoCt, native("_Double_opMinus1")] fun - (x: Double): Double - -[autoCt, native("_Char_opEQ")] fun == (x, y: Char): Bool -[autoCt, native("_Char_opNE")] fun != (x, y: Char): Bool -[autoCt, native("_Char_opLT")] fun < (x, y: Char): Bool -[autoCt, native("_Char_opGT")] fun > (x, y: Char): Bool -[autoCt, native("_Char_opLE")] fun <= (x, y: Char): Bool -[autoCt, native("_Char_opGE")] fun >= (x, y: Char): Bool - -[autoCt, native("_SizeType_opEQ")] fun == (x, y: SizeType): Bool -[autoCt, native("_SizeType_opNE")] fun != (x, y: SizeType): Bool -[autoCt, native("_SizeType_opLT")] fun < (x, y: SizeType): Bool -[autoCt, native("_SizeType_opGT")] fun > (x, y: SizeType): Bool -[autoCt, native("_SizeType_opLE")] fun <= (x, y: SizeType): Bool -[autoCt, native("_SizeType_opGE")] fun >= (x, y: SizeType): Bool -[autoCt, native("_SizeType_opPlus")] fun + (x, y: SizeType): SizeType -[autoCt, native("_SizeType_opMinus")] fun - (x, y: SizeType): SizeType -[autoCt, native("_SizeType_opMul")] fun * (x, y: SizeType): SizeType -[autoCt, native("_SizeType_opDiv")] fun / (x, y: SizeType): SizeType -[autoCt, native("_SizeType_opMod")] fun % (x, y: SizeType): SizeType -[autoCt, native("_SizeType_opPlus1")] fun + (x: SizeType): SizeType +[autoCt, protected] + [native("$logicalOr")] fun || (x, y: Bool): Bool + [native("$logicalAnd")] fun && (x, y: Bool): Bool + [native("_Bool_opXor")] fun ^^ (x, y: Bool): Bool + [native("_Bool_opEQ")] fun == (x, y: Bool): Bool + [native("_Bool_opNE")] fun != (x, y: Bool): Bool + [native("_Bool_opNeg")] fun ! (x: Bool): Bool + + [native("_Char_opEQ")] fun == (x, y: Char): Bool + [native("_Char_opNE")] fun != (x, y: Char): Bool + [native("_Char_opLT")] fun < (x, y: Char): Bool + [native("_Char_opGT")] fun > (x, y: Char): Bool + [native("_Char_opLE")] fun <= (x, y: Char): Bool + [native("_Char_opGE")] fun >= (x, y: Char): Bool + +[autoCt, protected] + [native("_Int8_opEQ")] fun == (x, y: Int8): Bool + [native("_UInt8_opEQ")] fun == (x, y: UInt8): Bool + [native("_Int16_opEQ")] fun == (x, y: Int16): Bool + [native("_UInt16_opEQ")] fun == (x, y: UInt16): Bool + [native("_Int32_opEQ")] fun == (x, y: Int32): Bool + [native("_UInt32_opEQ")] fun == (x, y: UInt32): Bool + [native("_Int64_opEQ")] fun == (x, y: Int64): Bool + [native("_UInt64_opEQ")] fun == (x, y: UInt64): Bool + [native("_Float32_opEQ")] fun == (x, y: Float32): Bool + [native("_Float64_opEQ")] fun == (x, y: Float64): Bool + + [native("_Int8_opNE")] fun != (x, y: Int8): Bool + [native("_UInt8_opNE")] fun != (x, y: UInt8): Bool + [native("_Int16_opNE")] fun != (x, y: Int16): Bool + [native("_UInt16_opNE")] fun != (x, y: UInt16): Bool + [native("_Int32_opNE")] fun != (x, y: Int32): Bool + [native("_UInt32_opNE")] fun != (x, y: UInt32): Bool + [native("_Int64_opNE")] fun != (x, y: Int64): Bool + [native("_UInt64_opNE")] fun != (x, y: UInt64): Bool + [native("_Float32_opNE")] fun != (x, y: Float32): Bool + [native("_Float64_opNE")] fun != (x, y: Float64): Bool + + [native("_Int8_opLT")] fun < (x, y: Int8): Bool + [native("_UInt8_opLT")] fun < (x, y: UInt8): Bool + [native("_Int16_opLT")] fun < (x, y: Int16): Bool + [native("_UInt16_opLT")] fun < (x, y: UInt16): Bool + [native("_Int32_opLT")] fun < (x, y: Int32): Bool + [native("_UInt32_opLT")] fun < (x, y: UInt32): Bool + [native("_Int64_opLT")] fun < (x, y: Int64): Bool + [native("_UInt64_opLT")] fun < (x, y: UInt64): Bool + [native("_Float32_opLT")] fun < (x, y: Float32): Bool + [native("_Float64_opLT")] fun < (x, y: Float64): Bool + + [native("_Int8_opGT")] fun > (x, y: Int8): Bool + [native("_UInt8_opGT")] fun > (x, y: UInt8): Bool + [native("_Int16_opGT")] fun > (x, y: Int16): Bool + [native("_UInt16_opGT")] fun > (x, y: UInt16): Bool + [native("_Int32_opGT")] fun > (x, y: Int32): Bool + [native("_UInt32_opGT")] fun > (x, y: UInt32): Bool + [native("_Int64_opGT")] fun > (x, y: Int64): Bool + [native("_UInt64_opGT")] fun > (x, y: UInt64): Bool + [native("_Float32_opGT")] fun > (x, y: Float32): Bool + [native("_Float64_opGT")] fun > (x, y: Float64): Bool + + [native("_Int8_opLE")] fun <= (x, y: Int8): Bool + [native("_UInt8_opLE")] fun <= (x, y: UInt8): Bool + [native("_Int16_opLE")] fun <= (x, y: Int16): Bool + [native("_UInt16_opLE")] fun <= (x, y: UInt16): Bool + [native("_Int32_opLE")] fun <= (x, y: Int32): Bool + [native("_UInt32_opLE")] fun <= (x, y: UInt32): Bool + [native("_Int64_opLE")] fun <= (x, y: Int64): Bool + [native("_UInt64_opLE")] fun <= (x, y: UInt64): Bool + [native("_Float32_opLE")] fun <= (x, y: Float32): Bool + [native("_Float64_opLE")] fun <= (x, y: Float64): Bool + + [native("_Int8_opGE")] fun >= (x, y: Int8): Bool + [native("_UInt8_opGE")] fun >= (x, y: UInt8): Bool + [native("_Int16_opGE")] fun >= (x, y: Int16): Bool + [native("_UInt16_opGE")] fun >= (x, y: UInt16): Bool + [native("_Int32_opGE")] fun >= (x, y: Int32): Bool + [native("_UInt32_opGE")] fun >= (x, y: UInt32): Bool + [native("_Int64_opGE")] fun >= (x, y: Int64): Bool + [native("_UInt64_opGE")] fun >= (x, y: UInt64): Bool + [native("_Float32_opGE")] fun >= (x, y: Float32): Bool + [native("_Float64_opGE")] fun >= (x, y: Float64): Bool + + [native("_Int8_opPlus")] fun + (x, y: Int8): Int8 + [native("_UInt8_opPlus")] fun + (x, y: UInt8): UInt8 + [native("_Int16_opPlus")] fun + (x, y: Int16): Int16 + [native("_UInt16_opPlus")] fun + (x, y: UInt16): UInt16 + [native("_Int32_opPlus")] fun + (x, y: Int32): Int32 + [native("_UInt32_opPlus")] fun + (x, y: UInt32): UInt32 + [native("_Int64_opPlus")] fun + (x, y: Int64): Int64 + [native("_UInt64_opPlus")] fun + (x, y: UInt64): UInt64 + [native("_Float32_opPlus")] fun + (x, y: Float32): Float32 + [native("_Float64_opPlus")] fun + (x, y: Float64): Float64 + + [native("_Int8_opMinus")] fun - (x, y: Int8): Int8 + [native("_UInt8_opMinus")] fun - (x, y: UInt8): UInt8 + [native("_Int16_opMinus")] fun - (x, y: Int16): Int16 + [native("_UInt16_opMinus")] fun - (x, y: UInt16): UInt16 + [native("_Int32_opMinus")] fun - (x, y: Int32): Int32 + [native("_UInt32_opMinus")] fun - (x, y: UInt32): UInt32 + [native("_Int64_opMinus")] fun - (x, y: Int64): Int64 + [native("_UInt64_opMinus")] fun - (x, y: UInt64): UInt64 + [native("_Float32_opMinus")] fun - (x, y: Float32): Float32 + [native("_Float64_opMinus")] fun - (x, y: Float64): Float64 + + [native("_Int8_opMul")] fun * (x, y: Int8): Int8 + [native("_UInt8_opMul")] fun * (x, y: UInt8): UInt8 + [native("_Int16_opMul")] fun * (x, y: Int16): Int16 + [native("_UInt16_opMul")] fun * (x, y: UInt16): UInt16 + [native("_Int32_opMul")] fun * (x, y: Int32): Int32 + [native("_UInt32_opMul")] fun * (x, y: UInt32): UInt32 + [native("_Int64_opMul")] fun * (x, y: Int64): Int64 + [native("_UInt64_opMul")] fun * (x, y: UInt64): UInt64 + [native("_Float32_opMul")] fun * (x, y: Float32): Float32 + [native("_Float64_opMul")] fun * (x, y: Float64): Float64 + + [native("_Int8_opDiv")] fun / (x, y: Int8): Int8 + [native("_UInt8_opDiv")] fun / (x, y: UInt8): UInt8 + [native("_Int16_opDiv")] fun / (x, y: Int16): Int16 + [native("_UInt16_opDiv")] fun / (x, y: UInt16): UInt16 + [native("_Int32_opDiv")] fun / (x, y: Int32): Int32 + [native("_UInt32_opDiv")] fun / (x, y: UInt32): UInt32 + [native("_Int64_opDiv")] fun / (x, y: Int64): Int64 + [native("_UInt64_opDiv")] fun / (x, y: UInt64): UInt64 + [native("_Float32_opDiv")] fun / (x, y: Float32): Float32 + [native("_Float64_opDiv")] fun / (x, y: Float64): Float64 + + [native("_Int8_opMod")] fun % (x, y: Int8): Int8 + [native("_UInt8_opMod")] fun % (x, y: UInt8): UInt8 + [native("_Int16_opMod")] fun % (x, y: Int16): Int16 + [native("_UInt16_opMod")] fun % (x, y: UInt16): UInt16 + [native("_Int32_opMod")] fun % (x, y: Int32): Int32 + [native("_UInt32_opMod")] fun % (x, y: UInt32): UInt32 + [native("_Int64_opMod")] fun % (x, y: Int64): Int64 + [native("_UInt64_opMod")] fun % (x, y: UInt64): UInt64 + [native("_Float32_opMod")] fun % (x, y: Float32): Float32 + [native("_Float64_opMod")] fun % (x, y: Float64): Float64 + + // Unary + + [native("_Int8_opPlus1")] fun + (x: Int8): Int8 + [native("_UInt8_opPlus1")] fun + (x: UInt8): UInt8 + [native("_Int16_opPlus1")] fun + (x: Int16): Int16 + [native("_UInt16_opPlus1")] fun + (x: UInt16): UInt16 + [native("_Int32_opPlus1")] fun + (x: Int32): Int32 + [native("_UInt32_opPlus1")] fun + (x: UInt32): UInt32 + [native("_Int64_opPlus1")] fun + (x: Int64): Int64 + [native("_UInt64_opPlus1")] fun + (x: UInt64): UInt64 + [native("_Float32_opPlus1")] fun + (x: Float32): Float32 + [native("_Float64_opPlus1")] fun + (x: Float64): Float64 + + // Unary - (only for signed types) + [native("_Int8_opMinus1")] fun - (x: Int8): Int8 + [native("_Int16_opMinus1")] fun - (x: Int16): Int16 + [native("_Int32_opMinus1")] fun - (x: Int32): Int32 + [native("_Int64_opMinus1")] fun - (x: Int64): Int64 + [native("_Float32_opMinus1")] fun - (x: Float32): Float32 + [native("_Float64_opMinus1")] fun - (x: Float64): Float64 [ct, native("$ct")] fun ct(t: Type): Type [ct, native("$rt")] fun rt(t: Type): Type @@ -1284,88 +1197,83 @@ fun + (x,y: StringRef): StringRef [ct, native('$tmp')] fun tmp(t: Type): Type [ct, native('$mut')] fun pre_!(t: Type): Type -[autoCt, native("implOpRefEQ")] fun implOpRefEQ(x,y: @Byte): Bool -[autoCt, native("implOpRefNE")] fun implOpRefNE(x,y: @Byte): Bool +[autoCt, native("implOpRefEQ")] fun implOpRefEQ(x,y: @Int8): Bool +[autoCt, native("implOpRefNE")] fun implOpRefNE(x,y: @Int8): Bool [ct, native("$typeEQ")] fun == (x, y: Type): Bool [ct, native("$typeAddRef")] fun @ (t: Type): Type -[native("writeLnByte")] fun writeLn(x: Byte) -[native("writeLnByte")] fun writeLn(x: UByte) -[native("writeLnShort")] fun writeLn(x: Short) -[native("writeLnShort")] fun writeLn(x: UShort) -[native("writeLnInt")] fun writeLn(x: Int) -[native("writeLnUInt")] fun writeLn(x: UInt) -[native("writeLnSizeType")] fun writeLn(x: Long) -[native("writeLnSizeType")] fun writeLn(x: ULong) -[native("writeLnFloat")] fun writeLn(x: Float) -[native("writeLnDouble")] fun writeLn(x: Double) +[native("writeLnByte")] fun writeLn(x: Int8) +[native("writeLnByte")] fun writeLn(x: UInt8) +[native("writeLnShort")] fun writeLn(x: Int16) +[native("writeLnShort")] fun writeLn(x: UInt16) +[native("writeLnInt")] fun writeLn(x: Int32) +[native("writeLnUInt")] fun writeLn(x: UInt32) +[native("writeLnSizeType")] fun writeLn(x: Int64) +[native("writeLnSizeType")] fun writeLn(x: UInt64) +[native("writeLnFloat32")] fun writeLn(x: Float32) +[native("writeLnFloat64")] fun writeLn(x: Float64) [native("writeLnChar")] fun writeLn(x: Char) -[native("writeLnSizeType")] fun writeLn(x: SizeType) - -[native("writeByte")] fun write(x: Byte) -[native("writeByte")] fun write(x: UByte) -[native("writeShort")] fun write(x: Short) -[native("writeShort")] fun write(x: UShort) -[native("writeInt")] fun write(x: Int) -[native("writeUInt")] fun write(x: UInt) -[native("writeLong")] fun write(x: Long) -[native("writeULong")] fun write(x: ULong) -[native("writeFloat")] fun write(x: Float) -[native("writeDouble")] fun write(x: Double) + +[native("writeByte")] fun write(x: Int8) +[native("writeByte")] fun write(x: UInt8) +[native("writeShort")] fun write(x: Int16) +[native("writeShort")] fun write(x: UInt16) +[native("writeInt")] fun write(x: Int32) +[native("writeUInt")] fun write(x: UInt32) +[native("writeLong")] fun write(x: Int64) +[native("writeULong")] fun write(x: UInt64) +[native("writeFloat")] fun write(x: Float32) +[native("writeDouble")] fun write(x: Float64) [native("writeChar")] fun write(x: Char) -[native("writeSizeType")] fun write(x: SizeType) fun writeLn(x: StringRef) { writeLnStringImpl(reinterpretCast(@Char, x.begin)); } fun write(x: StringRef) { writeStringImpl(reinterpretCast(@Char, x.begin)); } [native("writeLnStringImpl")] fun writeLnStringImpl(x: @Char) [native("writeStringImpl")] fun writeStringImpl(x: @Char) -[native("writeLnPointer")] fun writeLnRef(x: @Byte) -[native("writePointer")] fun writeRef(x: @Byte) +[native("writeLnPointer")] fun writeLnRef(x: @Int8) +[native("writePointer")] fun writeRef(x: @Int8) [native("writeLnInt"), rt] fun writeLnInt(x: Int) -[native("writeLnDouble"), rt] fun writeLnDouble(x: Double) - -[native("intToSizeType"), autoCt] fun intToSizeType(n: Int): SizeType -[native("intToByte"), autoCt] fun intToByte(n: Int): Byte +[native("writeLnFloat64"), rt] fun writeLnFloat(x: Float) [native("mulInt"), autoCt] fun mul(x,y: Int): Int -[native("mulDouble"), autoCt] fun mul(x,y: Double): Double +[native("mulDouble"), autoCt] fun mul(x,y: Float): Float [native("divInt"), autoCt] fun div(x,y: Int): Int [native("modInt"), autoCt] fun mod(x,y: Int): Int [native("addInt"), autoCt] fun add(x,y: Int): Int [native("subInt"), autoCt] fun sub(x,y: Int): Int -[native("addDouble"), autoCt] fun add(x,y: Double): Double -[native("subDouble"), autoCt] fun sub(x,y: Double): Double +[native("addDouble"), autoCt] fun add(x,y: Float): Float +[native("subDouble"), autoCt] fun sub(x,y: Float): Float [native("equalInt"), autoCt] fun equal(x,y: Int): Bool [native("leInt"), autoCt] fun le(x,y: Int): Bool [native("assignInt"), autoCt] fun assignInt(x: !Int, y: Int) -[native("assignRefByte"), autoCt] fun assignRef(x: !(@Byte), y: @Byte) - -[native("llvm.pow.f64"), rt] fun mathPow(x,y: Double): Double - -[native("malloc")] fun malloc(size: SizeType): @Byte -[native("malloc")] fun mallocRt(size: SizeType): @Byte -[native("realloc")] fun realloc(p: @Byte, size: SizeType): @Byte -[native("free")] fun free(p: @Byte) -[native("ptrAdd"), autoCt] fun ptrAdd(p: @Byte, n: SizeType): @Byte -[native("ptrSub"), autoCt] fun ptrSub(p: @Byte, n: SizeType): @Byte -[native("ptrDiff"), autoCt] fun ptrDiff(p1, p2: @Byte): SizeType -[native("memcpyimpl"), autoCt] fun memcpy(dest, src: @Byte, size: SizeType) +[native("assignRefByte"), autoCt] fun assignRef(x: !(@Int8), y: @Int8) + +[native("llvm.pow.f64"), rt] fun mathPow(x,y: Float): Float + +[native("malloc")] fun malloc(size: Int): @Int8 +[native("malloc")] fun mallocRt(size: Int): @Int8 +[native("realloc")] fun realloc(p: @Int8, size: Int): @Int8 +[native("free")] fun free(p: @Int8) +[native("ptrAdd"), autoCt] fun ptrAdd(p: @Int8, n: Int): @Int8 +[native("ptrSub"), autoCt] fun ptrSub(p: @Int8, n: Int): @Int8 +[native("ptrDiff"), autoCt] fun ptrDiff(p1, p2: @Int8): Int +[native("memcpyimpl"), autoCt] fun memcpy(dest, src: @Int8, size: Int) [native("flushOutput")] fun flushOutput() [ct, native("$typeNumRef")] fun typeNumRef(t: Type): Int fun cast() fun reinterpretCast() -[ct] fun sizeOf(): SizeType +[ct] fun sizeOf(): Int [ct] fun typeOf(): Type [ct] fun isValid(): Bool fun construct() [ct, native("$convertsTo")] fun convertsTo(src, dest: Type): Bool -[ct, native("$staticBuffer")] fun static_buffer(n: SizeType): Type +[ct, native("$staticBuffer")] fun static_buffer(n: Int): Type [ct, native("$commonType")] fun commonType(t, u: Type): Type using oper_precedence_default = 100 @@ -1416,9 +1324,9 @@ datatype _CStr { cstr: @Char; } [initCtor, bitcopiable] datatype _CStrPtr { ptr: @_CStr; } -fun _fromBytePtr(p: @Byte): _CStrPtr = _CStrPtr(reinterpretCast(@_CStr, p)) -fun _toBytePtr(p: _CStrPtr): @Byte = reinterpretCast(@Byte, p.ptr) -fun _offset(p: _CStrPtr, n: Int): _CStrPtr = _fromBytePtr( ptrAdd(_toBytePtr(p), n*(sizeOf(_CStrPtr))) ) +fun _fromInt8Ptr(p: @Int8): _CStrPtr = _CStrPtr(reinterpretCast(@_CStr, p)) +fun _toBytePtr(p: _CStrPtr): @Int8 = reinterpretCast(@Int8, p.ptr) +fun _offset(p: _CStrPtr, n: Int): _CStrPtr = _fromInt8Ptr( ptrAdd(_toBytePtr(p), n*(sizeOf(_CStrPtr))) ) // To be defined by the application: fun test(n: Int) diff --git a/tests/Basic/String.spr b/tests/Basic/String.spr index e8d50ecb..1c2bbf2b 100644 --- a/tests/Basic/String.spr +++ b/tests/Basic/String.spr @@ -17,17 +17,17 @@ fun fassert(b: Bool) let s: StringRef = "abracadabra" writeLn(s) - write(s.getChar(intToSizeType(0))) - write(s.getChar(intToSizeType(1))) - write(s.getChar(intToSizeType(2))) - write(s.getChar(intToSizeType(3))) - write(s.getChar(intToSizeType(4))) - write(s.getChar(intToSizeType(5))) - write(s.getChar(intToSizeType(6))) - write(s.getChar(intToSizeType(7))) - write(s.getChar(intToSizeType(8))) - write(s.getChar(intToSizeType(9))) - writeLn(s.getChar(intToSizeType(10))) + write(s.getChar(0)) + write(s.getChar(1)) + write(s.getChar(2)) + write(s.getChar(3)) + write(s.getChar(4)) + write(s.getChar(5)) + write(s.getChar(6)) + write(s.getChar(7)) + write(s.getChar(8)) + write(s.getChar(9)) + writeLn(s.getChar(10)) writeLn("---") diff --git a/tests/Basic/Using.spr b/tests/Basic/Using.spr index af9ab78b..da4d458a 100644 --- a/tests/Basic/Using.spr +++ b/tests/Basic/Using.spr @@ -7,25 +7,25 @@ using my_f0 = f0 fun f1(a: Int) writeLn('f1(Int)') -fun f1(a: Double) - writeLn('f1(Double)') +fun f1(a: Float) + writeLn('f1(Float)') using my_f1 = f1 package Inner fun g1(a: Int) writeLn('Inner.g1(Int)') - fun g1(a: Double) - writeLn('Inner.g1(Double)') + fun g1(a: Float) + writeLn('Inner.g1(Float)') using my_g1 = Inner.g1 using MyInt = Int package Inner2 - using MyDouble = Double + using MyFloat = Float -using MyDouble = Inner2.MyDouble +using MyFloat = Inner2.MyFloat package Inner3 datatype Gen(t: Type) @@ -33,9 +33,9 @@ package Inner3 fun print(this: Gen) if this.MyType == Int writeLn('Gen(Int)') - fun print(this: Gen) if this.MyType == Double - writeLn('Gen(Double)') - fun print(this: Gen) if this.MyType != Int && this.MyType != Double + fun print(this: Gen) if this.MyType == Float + writeLn('Gen(Float)') + fun print(this: Gen) if this.MyType != Int && this.MyType != Float writeLn('Gen(?)') using MyGen = Inner3.Gen @@ -71,13 +71,13 @@ fun test(n: Int) writeLn('---') let a: MyInt = 2 - let b: MyDouble = 3.14 + let b: MyFloat = 3.14 my_f1(a) my_f1(b) writeLn('---') let g1: MyGen(Int) - let g2: MyGen(Double) + let g2: MyGen(Float) let g3: MyGen(Char) g1.print g2.print @@ -85,27 +85,27 @@ fun test(n: Int) writeLn('---') let gg1: MyG(Int) - let gg2: MyG(Int, Double) + let gg2: MyG(Int, Float) gg1.print gg2.print /*<<>>*/ diff --git a/tests/Basic/ValueToRef.spr b/tests/Basic/ValueToRef.spr index 8c5847a2..b7142208 100644 --- a/tests/Basic/ValueToRef.spr +++ b/tests/Basic/ValueToRef.spr @@ -40,9 +40,9 @@ fun getValue(x: Int): MyVal writeLn("---") - write("abc".getChar(intToSizeType(0))) - write("abc".getChar(intToSizeType(1))) - write("abc".getChar(intToSizeType(2))) + write("abc".getChar(0)) + write("abc".getChar(1)) + write("abc".getChar(2)) writeLn("abc".size()) /*<<>>*/ \ No newline at end of file diff --git a/tests/Basic/datatype/funApi.spr b/tests/Basic/datatype/funApi.spr index 9a3eeecb..636a5645 100644 --- a/tests/Basic/datatype/funApi.spr +++ b/tests/Basic/datatype/funApi.spr @@ -4,7 +4,7 @@ datatype WrapperType val: Int - d: Double + d: Float b: Bool p: @WrapperType = null @@ -24,7 +24,7 @@ fun ctor(this: !WrapperType, other: WrapperType) [bitcopiable] datatype BCWrapperType val: Int - d: Double + d: Float b: Bool p: @BCWrapperType = null diff --git a/tests/Basic/datatype/generic.spr b/tests/Basic/datatype/generic.spr index 1868c58f..3b2cad15 100644 --- a/tests/Basic/datatype/generic.spr +++ b/tests/Basic/datatype/generic.spr @@ -46,7 +46,7 @@ fun Pair2(first, second: AnyType): Pair2(typeOf(first)) writeLn(pi.first) writeLn(pi.second) writeLn("---") - let pd = Pair(Double, 1.1, 2.2) + let pd = Pair(Float, 1.1, 2.2) writeLn(pd.first) writeLn(pd.second) writeLn("---") diff --git a/tests/Basic/datatype/interaction.spr b/tests/Basic/datatype/interaction.spr index c8760629..2c8b8f9c 100644 --- a/tests/Basic/datatype/interaction.spr +++ b/tests/Basic/datatype/interaction.spr @@ -12,7 +12,7 @@ datatype Book2 = StringRef * StringRef datatype Book3 { author, name, isbn: StringRef} datatype Book4 = Book -datatype Opaque = @Byte +datatype Opaque = @Int8 fun Book(author, name, isbn: StringRef): Book var res: Book = Uninitialized() @@ -81,7 +81,7 @@ fun CollectionBook(author, name, isbn, collection: StringRef): CollectionBook let b4_1 = Book4(b) writeLn(b4_1.data.name) - let o: Opaque = reinterpretCast(@Byte, b) + let o: Opaque = reinterpretCast(@Int8, b) /*<<0 ; n=n-1 res = res * x; return res -fun pow4(x: Double, n: Int): Double - var res: Double +fun pow4(x: Float, n: Int): Float + var res: Float res = 1.0 while n>0 ; n-=1 res *= x; diff --git a/tests/Basic/Overload.spr b/tests/Basic/fun/overloadBasic.spr similarity index 65% rename from tests/Basic/Overload.spr rename to tests/Basic/fun/overloadBasic.spr index 6a2288de..08344b95 100644 --- a/tests/Basic/Overload.spr +++ b/tests/Basic/fun/overloadBasic.spr @@ -1,44 +1,44 @@ -//!! -t "SparrowImplicitLib.spr" -fno-main +//!! -t "../SparrowImplicitLib.spr" -fno-main concept AnyType(x) // Always true fun f1(x: Int) { writeLn("f1(Int)"); } -fun f1(x: Double) { writeLn("f1(Double)"); } +fun f1(x: Float) { writeLn("f1(Float)"); } fun f1(x: !Int) { writeLn("f1(!Int)"); } -fun f1(x: !Double) { writeLn("f1(!Double)"); } +fun f1(x: !Float) { writeLn("f1(!Float)"); } fun f1(x: @Int) { writeLn("f1(@Int)"); } -fun f1(x: @Double) { writeLn("f1(@Double)"); } +fun f1(x: @Float) { writeLn("f1(@Float)"); } //fun f1(x: AnyType) { writeLn("f1(AnyType)"); } fun f1(x: !AnyType) { writeLn("f1(!AnyType)"); } fun f1(x: @AnyType) { writeLn("f1(@AnyType)"); } fun f2(x: Int, y: Int) { writeLn("f2(Int, Int)"); } -fun f2(x: Double, y: Double) { writeLn("f2(Double, Double)"); } +fun f2(x: Float, y: Float) { writeLn("f2(Float, Float)"); } fun f2(x: AnyType, y: AnyType) { writeLn("f2(AnyType, AnyType)"); } fun f2(x: !Int, y: !Int) { writeLn("f2(!Int, !Int)"); } -fun f2(x: !Double, y: !Double) { writeLn("f2(!Double, !Double)"); } +fun f2(x: !Float, y: !Float) { writeLn("f2(!Float, !Float)"); } //fun f2(x: !AnyType, y: !AnyType) { writeLn("f2(!AnyType, !AnyType)"); } fun f3(x: Int, y: Int) { writeLn("f3(Int, Int)"); } -fun f3(x: Double, y: Double) { writeLn("f3(Double, Double)"); } +fun f3(x: Float, y: Float) { writeLn("f3(Float, Float)"); } //fun f3(x: AnyType, y: AnyType) if typeOf(x)==typeOf(y) { writeLn("f3(AnyType, AnyType)"); } fun f3(x: !Int, y: !Int) { writeLn("f3(!Int, !Int)"); } -fun f3(x: !Double, y: !Double) { writeLn("f3(!Double, !Double)"); } +fun f3(x: !Float, y: !Float) { writeLn("f3(!Float, !Float)"); } fun f3(x: !AnyType, y: !AnyType) if typeOf(x)==typeOf(y){ writeLn("f3(!AnyType, !AnyType)"); } -let a = Short(1) +let a = Int16(1) let b = 10 let c = 3.14 -let ra: !Short = a +let ra: !Int16 = a let rb: !Int = b -let rc: !Double = c +let rc: !Float = c -fun getShort(): Short { return Short(1); } +fun getShort(): Int16 { return Int16(1); } fun getInt(): Int { return 10; } -fun getDouble(): Double { return 3.14; } -fun getShortRef(): !Short { return ra; } +fun getFloat(): Float { return 3.14; } +fun getShortRef(): !Int16 { return ra; } fun getIntRef(): !Int { return rb; } -fun getDoubleRef(): !Double { return rc; } +fun getFloatRef(): !Float { return rc; } [native("test")] fun test(n: Int) f1(a) @@ -54,10 +54,10 @@ fun getDoubleRef(): !Double { return rc; } f1(getShort()) f1(getInt()) - f1(getDouble()) + f1(getFloat()) f1(getShortRef()) f1(getIntRef()) - f1(getDoubleRef()) + f1(getFloatRef()) writeLn("---") f2(a,a) @@ -78,34 +78,34 @@ fun getDoubleRef(): !Double { return rc; } //f3(c,10); writeLn("---") - f3(a,Short(1)) - //f3(b,Short(1)); - //f3(c,Short(1)); + //f3(a,Int16(1)) + //f3(b,Int16(1)); + //f3(c,Int16(1)); /*<<>>*/ \ No newline at end of file diff --git a/tests/Basic/fun/overloadCat.spr b/tests/Basic/fun/overloadCat.spr new file mode 100644 index 00000000..4a39cfa8 --- /dev/null +++ b/tests/Basic/fun/overloadCat.spr @@ -0,0 +1,41 @@ +//!! -t "../SparrowImplicitLib.spr" -fno-main + +fun f1(x: Int const) { writeLn('f1(Int const)'); } +fun f1(x: Int mut) { writeLn('f1(Int mut)'); } +fun f1(x: Int tmp) { writeLn('f1(Int tmp)'); } + +datatype MyData = Int + +fun method(this: MyData) { writeLn('method(const)'); } +fun method(this: !MyData) { writeLn('method(mut)'); } +fun method(this: MyData tmp) { writeLn('method(tmp)'); } + + +[native("test")] fun test(n: Int) + let a: Int const + let b: Int mut + let c: Int tmp + + f1(a) + f1(b) + f1(c) + + writeLn('---') + + let o1: MyData + let o2: !MyData + let o3: MyData tmp + + o1 method + o2 method + o3 method + +/*<<>>*/ \ No newline at end of file diff --git a/tests/Basic/types/returnsTemp.spr b/tests/Basic/types/returnsTemp.spr new file mode 100644 index 00000000..a9a24f7e --- /dev/null +++ b/tests/Basic/types/returnsTemp.spr @@ -0,0 +1,73 @@ +//!! -t "../SparrowImplicitLib.spr" -fno-main + +// Test purpose: checks that types returned by functions have 'temp' category + +datatype MyObj = Int + +concept AnyType(x) +fun move(x: !AnyType): typeOf(x) tmp = reinterpretCast(typeOf(x) tmp, x) + + +fun create1: MyObj = MyObj(1) + +fun create2: MyObj tmp = MyObj(2) + +fun takesPlain(this: MyObj) + write(data) + writeLn(' plain') +fun takesConst(this: MyObj const) + write(data) + writeLn(' const') +fun takesMut(this: MyObj mut) + write(data) + writeLn(' mut') +fun takesTmp(this: MyObj tmp) + write(data) + writeLn(' temp') + +fun takesPlain(this: Int) + write(this) + writeLn(' plain') +fun takesConst(this: Int const) + write(this) + writeLn(' const') +fun takesMut(this: Int mut) + write(this) + writeLn(' mut') +fun takesTmp(this: Int tmp) + write(this) + writeLn(' temp') + + +[native("test")] +fun test(n: Int) + // Just to establish the baseline + 0 takesPlain + 0 takesConst + //0 takesMut + 0 takesTmp + + // Regular function + create1() takesPlain + create1() takesConst + create1() takesMut // TODO: this should not be possible + move(create1()) takesTmp + + // Function forced to return tmp + create2() takesPlain + create2() takesConst + //create2() takesMut + create2() takesTmp + +/*<<>>*/ \ No newline at end of file diff --git a/tests/Basic/types/temp.spr b/tests/Basic/types/temp.spr new file mode 100644 index 00000000..37c4ce10 --- /dev/null +++ b/tests/Basic/types/temp.spr @@ -0,0 +1,103 @@ +//!! -t "../SparrowImplicitLib.spr" -fno-main + +// Test purpose: checks that 'temp' types are working ok in various contexts + +concept AnyType(x) +fun move(x: !AnyType): typeOf(x) tmp = reinterpretCast(typeOf(x) tmp, x) +[ct, native("$meta.ife")] fun ife() + + +fun createTmp(x: Int): Int tmp = move(x) + +fun takesPlain(this: Int) + write(this) + writeLn(' plain') +fun takesConst(this: Int const) + write(this) + writeLn(' const') +fun takesMut(this: Int mut) + write(this) + writeLn(' mut') +fun takesTmp(this: Int tmp) + write(this) + writeLn(' temp') + +fun takesPlainGen(this: AnyType) + write(this) + writeLn(' plain (concept)') +fun takesConstGen(this: AnyType const) + write(this) + writeLn(' const (concept)') +fun takesMutGen(this: AnyType mut) + write(this) + writeLn(' mut (concept)') +fun takesTmpGen(this: AnyType tmp) + write(this) + writeLn(' temp (concept)') + +fun takesPlainGen2(this: AnyType) if typeOf(this) == Int + write(this) + writeLn(' plain (concept2)') +fun takesConstGen2(this: AnyType const) if typeOf(this) == Int + write(this) + writeLn(' const (concept2)') +fun takesMutGen2(this: AnyType mut) if typeOf(this) == Int + write(this) + writeLn(' mut (concept2)') +fun takesTmpGen2(this: AnyType tmp) if typeOf(this) == Int + write(this) + writeLn(' temp (concept2)') + +fun testConstants + 0 takesPlain + 0 takesConst + //0 takesMut + 0 takesTmp + +fun testFunRet + createTmp(1) takesPlain + createTmp(1) takesConst + //createTmp(1) takesMut + createTmp(1) takesTmp + +fun testWithGeneric + createTmp(2) takesPlainGen + createTmp(2) takesConstGen + //createTmp(2) takesMutGen + createTmp(2) takesTmpGen + createTmp(3) takesPlainGen2 + createTmp(3) takesConstGen2 + //createTmp(3) takesMutGen2 + createTmp(3) takesTmpGen2 + +fun testIfe + let x = 10 + let r1 = ife(false, x, createTmp(4)) + let r2 = ife(true, x, createTmp(4)) + write(r1) + write(' ') + writeLn(r2) + + +[native("test")] +fun test(n: Int) + testConstants + testFunRet + testWithGeneric + testIfe + +/*<<>>*/ \ No newline at end of file diff --git a/tests/Basic/TypeTraits.spr b/tests/Basic/types/typeTraits.spr similarity index 87% rename from tests/Basic/TypeTraits.spr rename to tests/Basic/types/typeTraits.spr index 55b274cd..be50bf13 100644 --- a/tests/Basic/TypeTraits.spr +++ b/tests/Basic/types/typeTraits.spr @@ -1,4 +1,6 @@ -//!! -t "SparrowImplicitLib.spr" -fno-main +//!! -t "../SparrowImplicitLib.spr" -fno-main + +// Test purpose: Ensure we can detect the difference between types concept AnyType(x) // Always true @@ -8,8 +10,8 @@ fun typeTest(x: AnyType) if typeOf(x) == Char fun typeTest(x: AnyType) if typeOf(x) == Int writeLn("Int passed"); -fun typeTest(x: AnyType) if typeOf(x) == Double - writeLn("Double passed"); +fun typeTest(x: AnyType) if typeOf(x) == Float + writeLn("Float passed"); fun typeTest(x: @AnyType) if typeOf(x) == @Char writeLn("@Char passed"); @@ -17,8 +19,8 @@ fun typeTest(x: @AnyType) if typeOf(x) == @Char fun typeTest(x: @AnyType) if typeOf(x) == @Int writeLn("Int@ passed"); -fun typeTest(x: @AnyType) if typeOf(x) == @Double - writeLn("Double@ passed"); +fun typeTest(x: @AnyType) if typeOf(x) == @Float + writeLn("Float@ passed"); fun testRef(x: AnyType) //if 0==typeNumRef(typeOf(x)) writeLn("non-ref"); @@ -32,7 +34,7 @@ fun testRef(x: @AnyType) //if 0!=typeNumRef(typeOf(x)) let c = 3.14 let ra: @Char = a let rb: Int@ = b - let rc: Double@ = c + let rc: Float@ = c writeLn(sizeOf('a'.getChar(0))) writeLn(sizeOf(10)) @@ -121,11 +123,11 @@ ref --- Char passed Int passed -Double passed +Float passed Char passed Int passed -Double passed +Float passed @Char passed Int@ passed -Double@ passed +Float@ passed >>>*/ \ No newline at end of file diff --git a/tests/Basic/vars/typeCatFieldsErr.spr b/tests/Basic/vars/typeCatFieldsErr.spr index 0214960a..5f3c0f15 100644 --- a/tests/Basic/vars/typeCatFieldsErr.spr +++ b/tests/Basic/vars/typeCatFieldsErr.spr @@ -17,7 +17,7 @@ fun access assign(a.x, 3) // ERROR assign(b.x, 5) - assign(c.x, 7) + assign(c.x, 7) // ERROR [native("test")] fun test(n: Int) diff --git a/tests/Basic/vars/typeCatVarsErr.spr b/tests/Basic/vars/typeCatVarsErr.spr index e93420c5..6a860772 100644 --- a/tests/Basic/vars/typeCatVarsErr.spr +++ b/tests/Basic/vars/typeCatVarsErr.spr @@ -23,7 +23,7 @@ fun decls a = 9 b = 9 c = 9 // ERROR - d = 9 + d = 9 // ERROR b1 = 9 fun declsInit @@ -36,7 +36,7 @@ fun declsInit a = 9 b = 9 c = 9 // ERROR - d = 9 + d = 9 // ERROR b1 = 9 fun funCall @@ -58,7 +58,7 @@ fun funCall takesMut(plainObj) takesMut(constObj) // ERROR takesMut(mutObj) - takesMut(tmpObj) + takesMut(tmpObj) // ERROR takesTmp(plainObj) // ERROR takesTmp(constObj) // ERROR @@ -72,10 +72,10 @@ fun letDecls a = 9 // ERROR b = 9 - c = 9 + c = 9 // ERROR takesMut(a) // ERROR takesMut(b) - takesMut(c) + takesMut(c) // ERROR takesTmp(a) // ERROR takesTmp(b) // ERROR takesTmp(c) diff --git a/tests/Basic2/Axioms.spr b/tests/Basic2/Axioms.spr index cbe9ab73..31a407fa 100644 --- a/tests/Basic2/Axioms.spr +++ b/tests/Basic2/Axioms.spr @@ -48,7 +48,7 @@ fun sprMain testOrdered(o2) /*<<>>*/ diff --git a/tests/Basic2/ConceptSpecialization.spr b/tests/Basic2/ConceptSpecialization.spr index 1f53cb86..3bf8bc91 100644 --- a/tests/Basic2/ConceptSpecialization.spr +++ b/tests/Basic2/ConceptSpecialization.spr @@ -2,24 +2,24 @@ import std.ranges -fun getRangeSize(range: RandomAccessRange): SizeType +fun getRangeSize(range: RandomAccessRange): Int cout << "RandomAccessRange fun selected" << endl return range.size() -fun getRangeSize(range: Range): SizeType +fun getRangeSize(range: Range): Int cout << "Range fun selected" << endl - var n: SizeType = 0 + var n: Int = 0 while !range.isEmpty(); range.popFront() ++n return n -fun getRangeSize2(range: RandomAccessRange): SizeType +fun getRangeSize2(range: RandomAccessRange): Int cout << "RandomAccessRange fun selected" << endl return range.size() -fun getRangeSize2(range: Range): SizeType +fun getRangeSize2(range: Range): Int cout << "Range fun selected" << endl - var n: SizeType = 0 + var n: Int = 0 while !range.isEmpty(); range.popFront() ++n return n diff --git a/tests/Basic2/Conditional.spr b/tests/Basic2/Conditional.spr index 53b60ec8..22f42f48 100644 --- a/tests/Basic2/Conditional.spr +++ b/tests/Basic2/Conditional.spr @@ -32,22 +32,6 @@ fun test4(b: Bool) ife(b, MyObj(41), MyObj(42)).print() cout << "after" << endl -fun testDifferentTypes1(cond: Bool) - let s: Short = 11 - let b: Byte = 13 - cout << ife(cond, s, b) << endl - [ct] if ( typeOf(ife(cond, s, b)) != Int ) - cout << "FAIL 1" << endl; - - [ct] if ( typeOf(ife(cond, 1.0, 1)) != Double ) - cout << "FAIL 2" << endl; - - [ct] if ( typeOf(ife(cond, 1.0f, 1)) != Float ) - cout << "FAIL 3" << endl; - - [ct] if ( typeOf(ife(cond, ULong(1), Long(1))) != ULong ) - cout << "FAIL 4" << endl; - fun sprMain test1(true) test1(false) @@ -61,9 +45,6 @@ fun sprMain test4(true) test4(false) - cout << "===" << endl - testDifferentTypes1(true) - /*<<>>*/ \ No newline at end of file diff --git a/tests/Basic2/CustomOperators.spr b/tests/Basic2/CustomOperators.spr index 1cf894b8..47a3be13 100644 --- a/tests/Basic2/CustomOperators.spr +++ b/tests/Basic2/CustomOperators.spr @@ -4,7 +4,8 @@ import math = math import precedenceUtils(setOperPrecedence, getOperPrecedence, setOperRightAssociativity) package Pred - fun **(base, exp: Float) = math.pow(base, exp) + fun **(base, exp: Float32) = math.pow(base, exp) + fun **(base, exp: Int) = Int(math.pow(Float32(base), Float32(exp))) setOperPrecedence("**", getOperPrecedence("*") + 1) setOperRightAssociativity("**") diff --git a/tests/Basic2/For.spr b/tests/Basic2/For.spr index 71e984c4..c8c687de 100644 --- a/tests/Basic2/For.spr +++ b/tests/Basic2/For.spr @@ -21,7 +21,7 @@ fun sprMain for val: Int = r2 cout << ' ' << val; cout << endl - for val: Byte = r2 + for val: Int8 = r2 cout << ' ' << Int(val); cout << endl diff --git a/tests/Basic2/FunPtrTest.spr b/tests/Basic2/FunPtrTest.spr index 11c479e0..8e632c2b 100644 --- a/tests/Basic2/FunPtrTest.spr +++ b/tests/Basic2/FunPtrTest.spr @@ -14,8 +14,8 @@ fun f(arg: Int): Int cout << 'f(Int) called' return arg -fun f(arg: Double): Double - cout << 'f(Double) called' +fun f(arg: Float): Float + cout << 'f(Float) called' return arg fun sprMain @@ -65,7 +65,7 @@ fun test3 cout << ' => ' << r1 << '\n' /*<<< FunctionPtr applied to overloaded function(3) f(Int) called => 10 -f(Double) called => 2.71 +f(Float) called => 2.71 >>>*/ fun test4 @@ -78,6 +78,6 @@ fun test4 cout << ' => ' << r1 << '\n' /*<<< FunctionPtr applied to overloaded function - no parens(4) f(Int) called => 10 -f(Double) called => 2.71 +f(Float) called => 2.71 >>>*/ diff --git a/tests/Basic2/GenericPackage.spr b/tests/Basic2/GenericPackage.spr index ab0f3ce2..4010f883 100644 --- a/tests/Basic2/GenericPackage.spr +++ b/tests/Basic2/GenericPackage.spr @@ -22,7 +22,7 @@ package GenPackage(t: Type) fun sprMain // Instantiate two packages by calling functions from there GenPackage(Int).printLine - GenPackage(Double).printLine + GenPackage(Float).printLine // Instantiate another one with an using using MyCharPackage = GenPackage(Char) @@ -31,18 +31,18 @@ fun sprMain var f: FunctionPtr(StringRef rt) f = \(GenPackage(Int).getType) cout << f() << endl - f = \(GenPackage(Double).getType) + f = \(GenPackage(Float).getType) cout << f() << endl f = \(MyCharPackage.getType) cout << f() << endl /*<<>>*/ diff --git a/tests/Basic2/Regular.spr b/tests/Basic2/Regular.spr index 1ffc057b..b1c93eff 100644 --- a/tests/Basic2/Regular.spr +++ b/tests/Basic2/Regular.spr @@ -1,9 +1,9 @@ //!! concept Regular(x) if ( - isValid(TypeOp.removeCat(typeOf(x))()) // Default construction - && isValid(TypeOp.removeCat(typeOf(x))(x)) // Copy construction - && isValid(TypeOp.removeCat(typeOf(x))().dtor()) // Destruction + isValid(TypeOp.copyVal(x).ctor()) // Default construction + && isValid(TypeOp.copyVal(x).ctor(x)) // Copy construction + && isValid(TypeOp.copyVal(x).dtor()) // Destruction && typeOf(x == x) == Bool // Equality is defined ) @@ -44,7 +44,7 @@ fun sprMain testRegular(o2) /*<<>>*/ fun test3 - var x: Double - var xr: @Double = x - var xrr: @ @Double = xr + var x: Float + var xr: @Float = x + var xrr: @ @Float = xr printHeader() printType(typeOf(x)) @@ -119,19 +119,19 @@ fun test3 /*<<>>*/ fun test4 - var x: Double - var xr: @Double = x - var xrr: @ @Double = xr + var x: Float + var xr: @Float = x + var xrr: @ @Float = xr cout << ife(isRef(Int), "ref", "no ref") << endl cout << ife(isRef(@Int), "ref", "no ref") << endl diff --git a/tests/BenchmarkGame/fasta.spr b/tests/BenchmarkGame/fasta.spr index 189e8a27..184db06f 100644 --- a/tests/BenchmarkGame/fasta.spr +++ b/tests/BenchmarkGame/fasta.spr @@ -19,10 +19,10 @@ fun write(r: Range, length: Int) if isValid(Char(r.front)) ; var seed: Int = 42 -fun nextRandom: Double +fun nextRandom: Float using IM = 139968 seed = (seed * 3877 + 29573) % IM - return seed * 1.0/IM + return Float(seed) * 1.0/Float(IM) var randomRange = generate(\nextRandom) [initCtor] @@ -34,7 +34,7 @@ datatype RandomCharRange(distribValsRangeType: Type) fun isEmpty(this: !RandomCharRange) = false fun popFront(this: !RandomCharRange) {} fun front(this: RandomCharRange): Char - let randVal: Float = (randomRange++) + let randVal: Float32 = (randomRange++) var i = 0 var r = distribVals while !r.isEmpty; r.popFront() diff --git a/tests/BenchmarkGame/fastaredux.spr b/tests/BenchmarkGame/fastaredux.spr index 0da9c16b..750361a3 100644 --- a/tests/BenchmarkGame/fastaredux.spr +++ b/tests/BenchmarkGame/fastaredux.spr @@ -19,15 +19,15 @@ fun write(r: Range, length: Int) if isValid(Char(#$r.RetType)) ; var seed: Int = 42 -fun nextRandom: Double +fun nextRandom: Float using IM = 139968 seed = (seed * 3877 + 29573) % IM - return seed * 1.0/IM + return Float(seed) * 1.0/Float(IM) datatype RandTableRange using RetType = Char using numEntries = 4095 - lookup: Array((Float rt)*(Char rt)) + lookup: Array((Float32 rt)*(Char rt)) fun ctor(this: !RandTableRange, other: RandTableRange) this.lookup ctor other.lookup @@ -36,7 +36,7 @@ fun ctor(this: !RandTableRange, data: Range) var datac = data lookup.ctor(numEntries+1) for i = 0...numEntries - while i > datac.front().v1*numEntries + while i > Int(Float(datac.front().v1)*Float(numEntries)) datac.popFront() lookup(i) = datac.front @@ -44,9 +44,9 @@ fun isEmpty(this: !RandTableRange) = false fun popFront(this: !RandTableRange) {} fun front(this: !RandTableRange): Char let r = nextRandom - var idx: SizeType = r*numEntries - while lookup(idx).v1 < r - ++idx; + var idx = Int(r*Float(numEntries)) + while Float(lookup(idx).v1) < r + ++idx return lookup(idx).v2; fun sprMain diff --git a/tests/BenchmarkGame/meteor.spr b/tests/BenchmarkGame/meteor.spr index 769e8057..2fd4fab2 100644 --- a/tests/BenchmarkGame/meteor.spr +++ b/tests/BenchmarkGame/meteor.spr @@ -50,13 +50,13 @@ using nRotations = 12 // TODO: Finish this //package P11 //{ -//var pieces: StaticArray3d(ULong, nPieces, nPositions, nRotations); -//var nextCell: StaticArray3d(Byte, nPieces, nPositions, nRotations); +//var pieces: StaticArray3d(UInt64, nPieces, nPositions, nRotations); +//var nextCell: StaticArray3d(Int8, nPieces, nPositions, nRotations); //var pieceCounts: StaticArray2d(Int, nPieces, nPositions); //datatype Piece //{ -// using PosType = Byte * Byte; // y coord then x coord - used for sorting +// using PosType = Int8 * Int8; // y coord then x coord - used for sorting // using PosTypeArr = StaticArray(PosType, 5); // var pos: PosTypeArr; @@ -81,7 +81,7 @@ using nRotations = 12 //fun rotatePos(p: PosType) = (p._1 + p._2) ~ -p._2; //// fun posToNum(p: PosType) = p._1 + 5*p._2; -//// fun posFromNum(p: Byte): PosType = p%5 ~ p/5; +//// fun posFromNum(p: Int8): PosType = p%5 ~ p/5; //fun offsetToMin: Piece //{ @@ -128,289 +128,290 @@ using nRotations = 12 //} package P1 -{ - -datatype Direction - id: Int - - using E = Direction(0) - using ESE = Direction(1) - using SE = Direction(2) - using S = Direction(3) - using SW = Direction(4) - using WSW = Direction(5) - using W = Direction(6) - using WNW = Direction(7) - using NW = Direction(8) - using N = Direction(9) - using NE = Direction(10) - using ENE = Direction(11) - using numValues = 12 - -fun ctor(this: !Direction, id: Int) - this.id ctor id; - -var pieceDef: StaticArray2d(Direction, 10, 4) - -fun setPiece(p: !StaticArray(Direction, 4), a, b, c, d: Direction) - { p(0) = a; p(1) = b; p(2) = c; p(3) = d; } - -fun ctor - using Direction.* - setPiece(pieceDef(0), E, E, E, SE) - setPiece(pieceDef(1), SE, E, NE, E) - setPiece(pieceDef(2), E, E, SE, SW) - setPiece(pieceDef(3), E, E, SW, SE) - setPiece(pieceDef(4), SE, E, NE, S) - setPiece(pieceDef(5), E, E, SW, E) - setPiece(pieceDef(6), E, SE, SE, NE) - setPiece(pieceDef(7), E, SE, SE, W) - setPiece(pieceDef(8), E, SE, E, E) - setPiece(pieceDef(9), E, E, E, SW) - -/* To minimize the amount of work done in the recursive solve function below, - * I'm going to allocate enough space for all legal rotations of each piece - * at each position on the board. That's 10 pieces x 50 board positions x - * 12 rotations. However, not all 12 rotations will fit on every cell, so - * I'll have to keep count of the actual number that do. - * The pieces are going to be unsigned long long ints just like the board so - * they can be bitwise-anded with the board to determine if they fit. - * I'm also going to record the next possible open cell for each piece and - * location to reduce the burden on the solve function. - */ -// the next 3 variables are the result of the first stage - -// represents the mask of a given piece -var pieces: StaticArray3d(ULong, nPieces, nPositions, nRotations) -// represents the first empty spot after placing the piece -var nextCell: StaticArray3d(Byte, nPieces, nPositions, nRotations) -// represents the piece count for pieces (last dimension) -var pieceCounts: StaticArray2d(Int, nPieces, nPositions) - -/* Returns the direction rotated 60 degrees clockwise */ -fun rotate(dir: Direction) = Direction((dir.id+2) % Direction.numValues) - -/* Returns the direction flipped on the horizontal axis */ -fun flip(dir: Direction) = Direction((Direction.numValues-dir.id) % Direction.numValues) - -/* Returns the new cell index from the specified cell in the - * specified direction. The index is only valid if the - * starting cell and direction have been checked by the - * out_of_bounds function first. - */ -fun shift(cell: Byte, dir: Direction): Byte - let oddRow: Bool = (cell/5) % 2 != 0 - - using Direction.* - if ( dir == E ) return cell + Byte(1) - else if ( dir == ESE && oddRow ) return cell + Byte(7) - else if ( dir == ESE ) return cell + Byte(6) - else if ( dir == SE && oddRow ) return cell + Byte(6) - else if ( dir == SE ) return cell + Byte(5) - else if ( dir == S ) return cell + Byte(10) - else if ( dir == SW && oddRow ) return cell + Byte(5) - else if ( dir == SW ) return cell + Byte(4) - else if ( dir == WSW && oddRow ) return cell + Byte(4) - else if ( dir == WSW ) return cell + Byte(3) - else if ( dir == W ) return cell - Byte(1) - else if ( dir == WNW && oddRow ) return cell - Byte(6) - else if ( dir == WNW ) return cell - Byte(7) - else if ( dir == NW && oddRow ) return cell - Byte(5) - else if ( dir == NW ) return cell - Byte(6) - else if ( dir == N ) return cell - Byte(10) - else if ( dir == NE && oddRow ) return cell - Byte(4) - else if ( dir == NE ) return cell - Byte(5) - else if ( dir == ENE && oddRow ) return cell - Byte(3) - else if ( dir == ENE ) return cell - Byte(4) - else return cell - -/* Returns wether the specified cell and direction will land outside - * of the board. Used to determine if a piece is at a legal board - * location or not. - */ -fun outOfBounds(cell: Byte, dir: Direction): Bool - let col = cell % 5 - let colEx = cell % 10 - using Direction.* - if ( dir == E ) return col==4 - else if ( dir == ESE ) return colEx==4 || colEx==8 || colEx==9 || cell>=45 - else if ( dir == SE ) return colEx==9 || cell>=45 - else if ( dir == S ) return cell>=40 - else if ( dir == SW ) return colEx==0 || cell>=45 - else if ( dir == WSW ) return colEx==0 || colEx==1 || colEx==5 || cell>=45 - else if ( dir == W ) return col==0 - else if ( dir == WNW ) return colEx==0 || colEx==1 || colEx==5 || cell<5 - else if ( dir == NW ) return colEx==0 || cell<5 - else if ( dir == N ) return cell<10 - else if ( dir == NE ) return colEx==9 || cell<5 - else if ( dir == ENE ) return colEx==4 || colEx==8 || colEx==9 || cell<5 - else return false - -/* Rotate a piece 60 degrees clockwise */ -fun rotatePiece(piece: Int) - for p: @Direction = pieceDef(piece).all - p = rotate(p); - -/* Flip a piece along the horizontal axis */ -fun flipPiece(piece: Int) - for p: @Direction = pieceDef(piece).all - p = flip(p); - -/* Convenience function to quickly calculate all of the indices for a piece */ -fun calcCellIndices(cell: !StaticArray(Byte, 5), piece: Int, index: Byte) - var hasOddDir = false - //for i = 0..4 - //{ - // var dir = pieceDef(piece)(i); - // if ( dir.id % 2 == 1 ) - // hasOddDir = true; - //} - if ( hasOddDir ) - cout << "Piece: " << piece << ": " - for i = 0..4 - cout << ' ' << pieceDef(piece)(i).id; - cout << endl; - cell(0) = index - cell(1) = shift(cell(0), pieceDef(piece)(0)) - cell(2) = shift(cell(1), pieceDef(piece)(1)) - cell(3) = shift(cell(2), pieceDef(piece)(2)) - cell(4) = shift(cell(3), pieceDef(piece)(3)) - -/* Convenience function to quickly calculate if a piece fits on the board */ -fun cellsFitOnBoard(cell: !StaticArray(Byte, 5), piece: Int): Bool - return(!outOfBounds(cell(0), pieceDef(piece)(0)) - && !outOfBounds(cell(1), pieceDef(piece)(1)) - && !outOfBounds(cell(2), pieceDef(piece)(2)) - && !outOfBounds(cell(3), pieceDef(piece)(3)) - ); - -/* Returns the lowest index of the cells of a piece. - * I use the lowest index that a piece occupies as the index for looking up - * the piece in the solve function. - */ -fun minimumOfCells(cell: !StaticArray(Byte, 5)): Byte - // TODO: Use algo here - var minimum = cell(0) - minimum = Byte(ife(cell(1) < minimum, cell(1), minimum)) - minimum = Byte(ife(cell(2) < minimum, cell(2), minimum)) - minimum = Byte(ife(cell(3) < minimum, cell(3), minimum)) - minimum = Byte(ife(cell(4) < minimum, cell(4), minimum)) - return minimum - -/* Calculate the lowest possible open cell if the piece is placed on the board. - * Used to later reduce the amount of time searching for open cells in the - * solve function. - */ -fun firstEmptyCell(cell: !StaticArray(Byte, 5), min: Byte): Byte - while ( min == cell(0) || min == cell(1) || min == cell(2) - || min == cell(3) || min == cell(4) ) - ++min; - return min; - -/* Generate the unsigned long long int that will later be anded with the - * board to determine if it fits. - */ -fun bitmaskFromCells(cell: !StaticArray(Byte, 5)): ULong - var pieceMask: ULong - for c = cell.all - pieceMask !|!= (ULong(1L) !<=45 + else if ( dir == SE ) return colEx==9 || cellI>=45 + else if ( dir == S ) return cellI>=40 + else if ( dir == SW ) return colEx==0 || cellI>=45 + else if ( dir == WSW ) return colEx==0 || colEx==1 || colEx==5 || cellI>=45 + else if ( dir == W ) return col==0 + else if ( dir == WNW ) return colEx==0 || colEx==1 || colEx==5 || cellI<5 + else if ( dir == NW ) return colEx==0 || cellI<5 + else if ( dir == N ) return cellI<10 + else if ( dir == NE ) return colEx==9 || cellI<5 + else if ( dir == ENE ) return colEx==4 || colEx==8 || colEx==9 || cellI<5 + else return false + + /* Rotate a piece 60 degrees clockwise */ + fun rotatePiece(piece: Int) + for p: @Direction = pieceDef(piece).all + p = rotate(p); + + /* Flip a piece along the horizontal axis */ + fun flipPiece(piece: Int) + for p: @Direction = pieceDef(piece).all + p = flip(p); + + /* Convenience function to quickly calculate all of the indices for a piece */ + fun calcCellIndices(cell: !CellType, piece: Int, index: Int8) + var hasOddDir = false + //for i = 0..4 + // var dir = pieceDef(piece)(i); + // if ( dir.id % 2 == 1 ) + // hasOddDir = true; + if ( hasOddDir ) + cout << "Piece: " << piece << ": " + for i = 0..4 + cout << ' ' << pieceDef(piece)(i).id; + cout << endl; + cell(0) = index + cell(1) = shift(cell(0), pieceDef(piece)(0)) + cell(2) = shift(cell(1), pieceDef(piece)(1)) + cell(3) = shift(cell(2), pieceDef(piece)(2)) + cell(4) = shift(cell(3), pieceDef(piece)(3)) + + /* Convenience function to quickly calculate if a piece fits on the board */ + fun cellsFitOnBoard(cell: !CellType, piece: Int): Bool + return(!outOfBounds(cell(0), pieceDef(piece)(0)) + && !outOfBounds(cell(1), pieceDef(piece)(1)) + && !outOfBounds(cell(2), pieceDef(piece)(2)) + && !outOfBounds(cell(3), pieceDef(piece)(3)) + ); -/* Fill the entire board going cell by cell. If any cells are "trapped" - * they will be left alone. - */ -fun fillContiguousSpace(board: !StaticArray(Byte, nPositions), index: Byte) - if ( board(index) == 1 ) - return; - board(index) = Byte(1) - using Direction.* - if !outOfBounds(index, E) ; fillContiguousSpace(board, shift(index, E)) - if !outOfBounds(index, SE) ; fillContiguousSpace(board, shift(index, SE)) - if !outOfBounds(index, SW) ; fillContiguousSpace(board, shift(index, SW)) - if !outOfBounds(index, W) ; fillContiguousSpace(board, shift(index, W)) - if !outOfBounds(index, NW) ; fillContiguousSpace(board, shift(index, NW)) - if !outOfBounds(index, NE) ; fillContiguousSpace(board, shift(index, NE)) - -/* To thin the number of pieces, I calculate if any of them trap any empty - * cells at the edges. There are only a handful of exceptions where the - * the board can be solved with the trapped cells. For example: piece 8 can - * trap 5 cells in the corner, but piece 3 can fit in those cells, or piece 0 - * can split the board in half where both halves are viable. - */ -fun hasIsland(cell: !StaticArray(Byte, 5), piece: Int): Bool - var tempBoard: StaticArray(Byte, nPositions) - - for c = cell.all - tempBoard(c) = Byte(1); - var i: Byte = 49 - while tempBoard(i) == 1 - --i; - fillContiguousSpace(tempBoard, i) - var c: Byte = 0 - for i = 0..50 - if ( tempBoard(i) == 0) - ++c; - return c != 0 && !(c == 5 && piece == 8) && !(c == 40 && piece == 8) \ - && !(c % 5 == 0 && piece == 0); - -/* Calculate all six rotations of the specified piece at the specified index. - * We calculate only half of piece 3's rotations. This is because any solution - * found has an identical solution rotated 180 degrees. Thus we can reduce the - * number of attempted pieces in the solve algorithm by not including the 180- - * degree-rotated pieces of ONE of the pieces. I chose piece 3 because it gave - * me the best time ;) - */ -fun calcSixRotations(piece, index: Byte) - var cell: StaticArray(Byte, 5) - for rot = 0..6 - if ( piece != 3 || rot < 3 ) - calcCellIndices(cell, piece, index) - if ( cellsFitOnBoard(cell, piece) && !hasIsland(cell, piece) ) - let min = minimumOfCells(cell) - let firstEmpty = firstEmptyCell(cell, min) - let pieceMask = bitmaskFromCells(cell) - recordPiece(piece, min, firstEmpty, pieceMask) - ; - rotatePiece(piece) - ; + /* Returns the lowest index of the cells of a piece. + * I use the lowest index that a piece occupies as the index for looking up + * the piece in the solve function. + */ + fun minimumOfCells(cell: !CellType): Int8 + // TODO: Use algo here + var minimum = cell(0) + minimum = Int8(ife(cell(1) < minimum, cell(1) Int8, minimum)) + minimum = Int8(ife(cell(2) < minimum, cell(2) Int8, minimum)) + minimum = Int8(ife(cell(3) < minimum, cell(3) Int8, minimum)) + minimum = Int8(ife(cell(4) < minimum, cell(4) Int8, minimum)) + return minimum + + /* Calculate the lowest possible open cell if the piece is placed on the board. + * Used to later reduce the amount of time searching for open cells in the + * solve function. + */ + fun firstEmptyCell(cell: !CellType, min: Int8): Int8 + while ( min == cell(0) || min == cell(1) || min == cell(2) + || min == cell(3) || min == cell(4) ) + ++min; + return min; + + /* Generate the unsigned long long int that will later be anded with the + * board to determine if it fits. + */ + fun bitmaskFromCells(cell: !CellType): UInt64 + var pieceMask: UInt64 + for c = cell.all + pieceMask !|!= (UInt64(1L) !<>! Byte(1)) !|! Byte(0x10); + row2Shift = (row2 !>>! 1) !|! 0x10; let block = (row1 !^! row2) !&! row2 !&! ((row1 !^! row2Shift) !&! row2Shift) /* Test for groups of 0's */ var inZeroes = false @@ -435,7 +436,7 @@ fun rowsBad(row1, row2: Byte, even: Bool): Bool * positive. One scenario is when 5 cells may be surrounded where piece 5 * or 7 can fit. The other scenario is when piece 2 creates a hook shape. */ -fun tripleIsOkay(row1, row2, row3: Byte, even: Bool): Bool +fun tripleIsOkay(row1, row2, row3: Int, even: Bool): Bool let r1: Int = row1 let r2: Int = row2 let r3: Int = row3 @@ -461,13 +462,13 @@ fun tripleIsOkay(row1, row2, row3: Byte, even: Bool): Bool ; fun calcRows - for row1: Byte = 0..32 - for row2: Byte = 0..32 + for row1 = 0..32 + for row2 = 0..32 badEvenRows(row1)(row2) = rowsBad(row1, row2, true) badOddRows(row1)(row2) = rowsBad(row1, row2, false) - for row1: Byte = 0..32 - for row2: Byte = 0..32 - for row3: Byte = 0..32 + for row1 = 0..32 + for row2 = 0..32 + for row3 = 0..32 var res1 = badEvenRows(row1)(row2) var res2 = badOddRows(row2)(row3) if ( !res1 && res2 && tripleIsOkay(row1,row2,row3, true) ) @@ -482,16 +483,17 @@ fun calcRows else badOddTriple(row1+(row2*32)+(row3*1024)) = res1 || res2; -let board = ULong(0xFFFC000000000000L) +let board = UInt64(0xFFFC000000000000L) /* Calculate islands while solving the board. */ -fun boardHasIslands(cell: Byte): Bool +fun boardHasIslands(cell: Int8): Bool + var c: Int = cell /* Too low on board, don't bother checking */ - if ( cell >= 40 ) + if c >= 40 return false; - let currentTriple: Int = (board !>>! ((cell / 5) * 5)) !&! TRIPLE_MASK - if ( (cell / 5 % 2) != 0 ) + let currentTriple: Int = (board !>>! UInt64((c / 5) * 5)) !&! TRIPLE_MASK + if ( (c / 5 % 2) != 0 ) return badOddTriple(currentTriple); else return badEvenTriple(currentTriple); @@ -502,10 +504,10 @@ fun boardHasIslands(cell: Byte): Bool * at each successful piece placement. This data is used to create a 50 char * array if a solution is found. */ -var avail: Short = 0x03FF -var solNums: StaticArray(Byte, nPieces) -var solMasks: StaticArray(ULong, nPieces) -var solutions: StaticArray2d(Byte, 2100, nPositions) +var avail: Int16 = 0x03FF +var solNums: StaticArray(Int8, nPieces) +var solMasks: StaticArray(UInt64, nPieces) +var solutions: StaticArray2d(Int8, 2100, nPositions) var solutionCount = 0 let maxSolutions = 2100 @@ -513,11 +515,11 @@ fun recordSolution for solNo = 0..10 var solMask = solMasks(solNo) for index = 0..nPositions - if ( (solMask !&! 1) != 0 ) + if ( (solMask !&! 1UL) != 0UL ) solutions(solutionCount)(index) = solNums(solNo) /* Board rotated 180 degrees is a solution too! */ solutions(solutionCount+1)(49-index) = solNums(solNo) - solMask = solMask !>>! 1 + solMask = solMask !>>! 1UL ; solutionCount += 2 @@ -525,18 +527,18 @@ fun solve(depth, cell: Int) if ( solutionCount >= maxSolutions ) return; - while (board !&! (1L !<>>*/ \ No newline at end of file diff --git a/tests/Bugs/Overload.spr b/tests/Bugs/Overload.spr index 223cfdf4..3b507e03 100644 --- a/tests/Bugs/Overload.spr +++ b/tests/Bugs/Overload.spr @@ -4,7 +4,7 @@ import std.algorithms fun f(a: Int, b: Int) cout << "f a b " << a << " " << b << endl -fun f(x: Double) +fun f(x: Float) cout << "f x " << x << endl fun f(p: Int*Int) diff --git a/tests/Bugs/ParenInGeneric.spr b/tests/Bugs/ParenInGeneric.spr index 04d53c2e..9849411c 100644 --- a/tests/Bugs/ParenInGeneric.spr +++ b/tests/Bugs/ParenInGeneric.spr @@ -23,10 +23,10 @@ fun test(n: Int) v12.start = 4 v12.end = 4 - var v21: MyVector(Double) + var v21: MyVector(Float) v21.start = 10.0 v21.end = 15.2 - var v22: MyVector(Double) + var v22: MyVector(Float) v22.start = 10.0 v22.end = 11.2 diff --git a/tests/Bugs/test.spr b/tests/Bugs/test.spr new file mode 100644 index 00000000..39447433 --- /dev/null +++ b/tests/Bugs/test.spr @@ -0,0 +1,12 @@ +//!! + +// Test purpose: make sure we are not using files from std lib + +import std.ranges + +fun sprMain + cout << 'OK\n' + +/*<<>>*/ \ No newline at end of file diff --git a/tests/Examples/MinPerfHash.spr b/tests/Examples/MinPerfHash.spr index 76bf8c60..b3adb6d4 100644 --- a/tests/Examples/MinPerfHash.spr +++ b/tests/Examples/MinPerfHash.spr @@ -17,7 +17,7 @@ import os = os // - 3 = perf test [ct] let testType = 0 [ct] let keysFilename = "words-full" -[ct] let maxKeys: UInt = 1000 +[ct] let maxKeys: Int = 1000 [ct] let startKeysNum = 10000 [ct] let endKeysNum = 260000 @@ -30,38 +30,44 @@ import os = os // let numbers: Vector(Int) = enum(1,2,3,4,5,6,7); // TODO (Vlad): Use this hash function instead of what we're using -[native("rand")] fun rand(): UInt +[native("rand")] fun rand(): UInt32 package _Impl - [ct] let keysPerBucket: UInt = 4 + [ct] let keysPerBucket: Int = 4 - [ct] let hashSeed: UInt = -1 + [ct] let hashSeed: UInt32 = -1 - /// FNV hash generator - fun doHash(key: StringRef, start: UInt): UInt - var hash = start - for i = 0..key.size() - hash = (hash !^! Byte(key(i))) * 0x01000193; - //cout << "Hash(" << key << ", " << start << ")=" << hash << "\n"; - return hash; - fun doHash(value, start: UInt): UInt - return (start !^! value) * 0x01000193; +/// FNV hash generator +fun _doHash(key: StringRef, start: UInt32): UInt32 + var hash = start + for i = 0..key.size() + hash = (hash !^! UInt32(Int8(key(i)))) * 0x01000193U; + //cout << "Hash(" << key << ", " << start << ")=" << hash << "\n"; + return hash; +fun _doHash(value, start: UInt32): UInt32 + return (start !^! value) * 0x01000193U; + +fun _hashMod(key: StringRef, start: UInt32, numBuckets: Int): Int + return Int(_doHash(key, start) % UInt32(numBuckets)) + +fun _hashMod(value, start: UInt32, numBuckets: Int): Int + return Int(_doHash(value, start) % UInt32(numBuckets)) datatype MinPerfHash displacements: Array(Int) - numKeys: UInt - numValues: UInt + numKeys: Int + numValues: Int fun ctor(this: !MinPerfHash, keys: !Vector(String)) this.ctor(keys, defaultHashExtraSpace); -fun ctor(this: !MinPerfHash, keys: !Vector(String), extraSpace: Double) +fun ctor(this: !MinPerfHash, keys: !Vector(String), extraSpace: Float) this.numKeys ctor keys.size() - this.numValues ctor numKeys+UInt(numKeys*extraSpace) + this.numValues ctor numKeys+Int(Float(numKeys)*extraSpace) var keysPerBucket = _Impl.keysPerBucket while (keysPerBucket*keysPerBucket) > numKeys keysPerBucket /= 2; - let numBuckets = (numKeys-1)/keysPerBucket + UInt(1) + let numBuckets = (numKeys-1)/keysPerBucket + 1 this.displacements.ctor(numBuckets, 0) var numOp = 0 @@ -71,14 +77,14 @@ fun ctor(this: !MinPerfHash, keys: !Vector(String), extraSpace: Double) // Split the keys into buckets for key: @AnyType = keys.all() //cout << "Key: " << key.asStringRef() << "\n"; - let pos = _Impl.doHash(key.asStringRef(), _Impl.hashSeed) % numBuckets + let pos = _hashMod(key.asStringRef(), _Impl.hashSeed, numBuckets) keysToBuckets(pos).pushBack(key.asStringRef()) // Sort the buckets in failing order according to their size sort(keysToBuckets.all(), (fun (lhs, rhs: !Vector(StringRef)) = lhs.size() > rhs.size())) var placedKeys: Bitset = numValues // Bitset with the positions in the final array that are occupied - var slots: Vector(UInt) // Local - the slots (in the final array) to be occupied by iterating bucket + var slots: Vector(Int) // Local - the slots (in the final array) to be occupied by iterating bucket // Process the buckets; start with the ones that contain the most items // Here we process buckets that have at least 2 keys in them @@ -95,7 +101,7 @@ fun ctor(this: !MinPerfHash, keys: !Vector(String), extraSpace: Double) // keys in this bucket without conflicts with keys from previous buckets. var item = 0 while item < bucket.size() - let slot: UInt = _Impl.doHash(bucket(item), d) % numValues + let slot = _hashMod(bucket(item), UInt32(d), numValues) let slotAlreadyUsed = !find(slots.all(), slot).isEmpty() ++numOp if ( placedKeys.testBit(slot) || slotAlreadyUsed ) @@ -113,7 +119,7 @@ fun ctor(this: !MinPerfHash, keys: !Vector(String), extraSpace: Double) // This is guaranteed to finish quickly // We found a displacement that works for the current bucket (it doesn't yield overlaps with previous buckets) - displacements(_Impl.doHash(bucket(0), _Impl.hashSeed) % numBuckets) = d + displacements(_hashMod(bucket(0), _Impl.hashSeed, numBuckets)) = d for i=0..bucket.size() placedKeys.setBit(slots(i)); @@ -130,7 +136,7 @@ fun ctor(this: !MinPerfHash, keys: !Vector(String), extraSpace: Double) ++emptySlot; // We subtract one to ensure it's negative even if the zero-th slot was used. - displacements(_Impl.doHash(bucket(0), _Impl.hashSeed) % numBuckets) = -emptySlot-1 + displacements(_hashMod(bucket(0), _Impl.hashSeed, numBuckets)) = -emptySlot-1 placedKeys.setBit(emptySlot) //_dumpBuckets("buckets final, ", keysToBuckets); @@ -142,13 +148,13 @@ fun ctorFromCt(this: !MinPerfHash, src: MinPerfHash ct) [ct] let dispStrCt = StringRef(src.displacements.begin_.bytePtr(), src.displacements.end_.bytePtr()) let dispStr = dispStrCt - displacements ctor ContiguousMemoryRange(UInt)(RawPtr(UInt).fromBytePtr(dispStr.begin), RawPtr(UInt).fromBytePtr(dispStr.end)) + displacements ctor ContiguousMemoryRange(Int)(RawPtr(Int).fromBytePtr(dispStr.begin), RawPtr(Int).fromBytePtr(dispStr.end)) -fun search(this: !MinPerfHash, key: StringRef): UInt +fun search(this: !MinPerfHash, key: StringRef): Int // Get the displacement from the table... - let d = displacements(_Impl.doHash(key, _Impl.hashSeed) % displacements.size()) + let d = displacements(_hashMod(key, _Impl.hashSeed, displacements.size())) // If the displacement is negative, directly return; otherwise compute the final hash - return ife(d<0, Int(-d-1), Int(_Impl.doHash(key, d) % numValues)) + return ife(d<0, Int(-d-1), _hashMod(key, UInt32(d), numValues)) fun ()(this: !MinPerfHash, key: StringRef) = this.search(key) @@ -198,9 +204,9 @@ fun search(this: !MinPerfHashSet, str: StringRef): Int // Yields -1 if 'st return MinPerfHashSet(keys); fun readFileLines(filename: StringRef): Vector(String) - return readFileLines(filename, UInt(-1)); + return readFileLines(filename, -1) -fun readFileLines(filename: StringRef, maxLines: UInt): Vector(String) +fun readFileLines(filename: StringRef, maxLines: Int): Vector(String) var lines: Vector(String) var f = os.openFile(filename, "r") @@ -244,7 +250,7 @@ fun testRt(testRepCount, totalRepCount, keysToLoad: Int) checkHashIsOk(hash, keysRt); [ct] if ( testType == 1 ) -fun testCt(testRepCount, totalRepCount: Int, maxKeys: UInt ct) +fun testCt(testRepCount, totalRepCount: Int, maxKeys: Int ct) cout << "test CT\n" // Read the keys from the file diff --git a/tests/Examples/Power.spr b/tests/Examples/Power.spr index 34f40dfe..744a365a 100644 --- a/tests/Examples/Power.spr +++ b/tests/Examples/Power.spr @@ -2,7 +2,7 @@ import math = math -fun pow(x: Double, n: Int ct): Double +fun pow(x: Float, n: Int ct): Float if ( n == 0 ) return 1.0; else if ( n == 1 ) @@ -10,7 +10,7 @@ fun pow(x: Double, n: Int ct): Double else return pow(x*x, n/2) * pow(x, n%2); -fun pow(x: Double, n: Int): Double +fun pow(x: Float, n: Int): Float if ( n == 0 ) return 1.0; else if ( n == 1 ) @@ -18,7 +18,7 @@ fun pow(x: Double, n: Int): Double else return pow(x*x, n/2) * pow(x, n%2); -fun pow(x: Double, n: Double): Double +fun pow(x: Float, n: Float): Float return math.pow(x, n); fun sprMain diff --git a/tests/Examples/Regex.spr b/tests/Examples/Regex.spr index 6105d10d..400c0680 100644 --- a/tests/Examples/Regex.spr +++ b/tests/Examples/Regex.spr @@ -21,7 +21,7 @@ import precedenceUtils(getOperPrecedence, setOperPrecedence) [ct] let testType = 0 fun **(str: StringRef, count: Int): String - let sz: SizeType = str.size() + let sz = str.size() var res: String = sz*count for i = 0..count memcpy(UntypedPtr(res(i*sz)), UntypedPtr(str.begin), sz); @@ -181,7 +181,7 @@ datatype NfaFragment start: Ptr(NfaState) ///< Start state of the NFA frament outPtrChain: OutPtrList ///< Chain of out-pointers for this fragment that need to be set to the next state -fun ctor(this: !NfaFragment, start: Ptr(NfaState), outPtrChain: !OutPtrList) +fun ctor(this: !NfaFragment, start: Ptr(NfaState), outPtrChain: OutPtrList) this.start ctor start this.outPtrChain ctor outPtrChain diff --git a/tests/Frontend/Identifiers.spr b/tests/Frontend/Identifiers.spr index 6fda4fa4..78e383b9 100644 --- a/tests/Frontend/Identifiers.spr +++ b/tests/Frontend/Identifiers.spr @@ -1,11 +1,11 @@ module Ids -fun pow(x,y: Double) = 1 -fun **(x,y: Double) = 2 -fun !@#$%^&*(x,y: Double) = 3 -fun <>(x,y: Double) = 4 -fun ::(x,y: Double) = 5 -fun a_::(x,y: Double) = 6 +fun pow(x,y: Int) = 1 +fun **(x,y: Int) = 2 +fun !@#$%^&*(x,y: Int) = 3 +fun <>(x,y: Int) = 4 +fun ::(x,y: Int) = 5 +fun a_::(x,y: Int) = 6 fun sprMain cout << pow(1,2) << endl diff --git a/tests/Frontend/Numbers.spr b/tests/Frontend/Numbers.spr new file mode 100644 index 00000000..f4a418ef --- /dev/null +++ b/tests/Frontend/Numbers.spr @@ -0,0 +1,36 @@ +fun sprMain + cout << 1234 << '\n' + cout << 0xff << '\n' + cout << 0o777 << '\n' + cout << 0b11111111 << '\n' + cout << 3.14 << '\n' + cout << '---\n' + + cout << 1_234 << '\n' + cout << 0xf_f << '\n' + cout << 0o7_7_7 << '\n' + cout << 0b1111_1111 << '\n' + cout << 3.1_4 << '\n' + cout << '---\n' + + cout << 0.314e1 << '\n' + cout << 0.314e+1 << '\n' + cout << 314.e-2 << '\n' + +/*<<>>*/ diff --git a/tests/Frontend/Operators.spr b/tests/Frontend/Operators.spr index a1bfca8e..c100e729 100644 --- a/tests/Frontend/Operators.spr +++ b/tests/Frontend/Operators.spr @@ -1,10 +1,10 @@ -fun pow(x,y: Double) = 1 -fun **(x,y: Double) = 2 -fun !@#$%^&*(x,y: Double) = 3 -fun <>(x,y: Double) = 4 -fun ::(x,y: Double) = 5 -fun a_::(x,y: Double) = 6 +fun pow(x,y: Int) = 1 +fun **(x,y: Int) = 2 +fun !@#$%^&*(x,y: Int) = 3 +fun <>(x,y: Int) = 4 +fun ::(x,y: Int) = 5 +fun a_::(x,y: Int) = 6 fun ..(x,y: Int) = x+y diff --git a/tests/Frontend/parserTest.spr b/tests/Frontend/parserTest.spr index 56f4d1cd..f07a7701 100644 --- a/tests/Frontend/parserTest.spr +++ b/tests/Frontend/parserTest.spr @@ -117,16 +117,16 @@ fun mkBoolLiteral(this: !MyAstBuilder, loc: !Location, val: Bool) \ = createNode(loc, "boolLit") fun mkIntLiteral(this: !MyAstBuilder, loc: !Location, val: Int) \ = createNode(loc, "intLit") -fun mkUIntLiteral(this: !MyAstBuilder, loc: !Location, val: UInt) \ - = createNode(loc, "uintLit") -fun mkLongLiteral(this: !MyAstBuilder, loc: !Location, val: Long) \ - = createNode(loc, "longLit") -fun mkULongLiteral(this: !MyAstBuilder, loc: !Location, val: ULong) \ - = createNode(loc, "ulongLit") -fun mkFloatLiteral(this: !MyAstBuilder, loc: !Location, val: Float) \ - = createNode(loc, "floatLit") -fun mkDoubleLiteral(this: !MyAstBuilder, loc: !Location, val: Double) \ - = createNode(loc, "doubleLit") +fun mkUIntLiteral(this: !MyAstBuilder, loc: !Location, val: UInt32) \ + = createNode(loc, "uint32Lit") +fun mkLongLiteral(this: !MyAstBuilder, loc: !Location, val: Int64) \ + = createNode(loc, "int64Lit") +fun mkULongLiteral(this: !MyAstBuilder, loc: !Location, val: UInt64) \ + = createNode(loc, "uint64Lit") +fun mkFloatLiteral(this: !MyAstBuilder, loc: !Location, val: Float32) \ + = createNode(loc, "float32Lit") +fun mkDoubleLiteral(this: !MyAstBuilder, loc: !Location, val: Float) \ + = createNode(loc, "float64Lit") fun mkCharLiteral(this: !MyAstBuilder, loc: !Location, val: Char) \ = createNode(loc, "charLit") fun mkStringLiteral(this: !MyAstBuilder, loc: !Location, data: StringRef) \ @@ -152,8 +152,8 @@ fun sprMain return var n = programArgs(1) asInt - if n == 0 ; doScan(mkCharSource(FileCharSource(programArgs(2)))) - else if n == 1 ; doParse(mkCharSource(FileCharSource(programArgs(2)))) + if n == 0 ; doScan(mkCharSource(tmpToMut(FileCharSource(programArgs(2))))) + else if n == 1 ; doParse(mkCharSource(tmpToMut(FileCharSource(programArgs(2))))) else if n == 2 ; test2() else if n == 3 ; test3() else if n == 4 ; test4() @@ -186,7 +186,7 @@ fun doParse(charSource: CharSource) fun test2 var code = "1 2 3 4 5 0xff, 0b101, 0777, 0789, .123 0.123 1.123 12.34e2f 123_456 1_2.3_4" - doScan(mkCharSource(StringCharSource(code))) + doScan(mkCharSource(tmpToMut(StringCharSource(code)))) /*<<" - doScan(mkCharSource(StringCharSource(code))) + doScan(mkCharSource(tmpToMut(StringCharSource(code)))) /*<<) >>>*/ fun test7 var code = "import x.y.z, k, l(a,b,c);" - doParse(mkCharSource(StringCharSource(code))) + doParse(mkCharSource(tmpToMut(StringCharSource(code)))) /*<<, nodeList(nodeList(importName(compoundExpr(compoundExpr(x, y), z), ), importName(k, ), importName(l, nodeList(a, b, c))))) >>>*/ diff --git a/tests/Logic/LogicTest.spr b/tests/Logic/LogicTest.spr index 7ef43567..11e73a56 100644 --- a/tests/Logic/LogicTest.spr +++ b/tests/Logic/LogicTest.spr @@ -25,12 +25,12 @@ fun sprMain else if n == 5; test5 fun test1 - if ( male("zeus")() ) + if ( male(tmpToMut(LStr("zeus")))() ) cout << "Zeus is male\n"; else cout << "Zeus is not male\n"; - if ( female("zeus")() ) + if ( female(tmpToMut(LStr("zeus")))() ) cout << "Zeus is female\n"; else cout << "Zeus is not female\n"; diff --git a/tests/Par/AtomicTest.spr b/tests/Par/AtomicTest.spr index 68219054..76c880f3 100644 --- a/tests/Par/AtomicTest.spr +++ b/tests/Par/AtomicTest.spr @@ -11,15 +11,15 @@ import std.compilerInfo import test [native("rand")] fun rand(): Int - [native("srand")] fun srand(seed: UInt) + [native("srand")] fun srand(seed: Int) [native("time")] fun time(timer: !Int): Int datatype UserDefined - lo, hi: Short + lo, hi: Int16 fun ctor(this: !UserDefined, val: Int) - lo = Short(val % 0xffff) - hi = Short(val / 0xffff) + lo = Int16(val % 0xffff) + hi = Int16(val / 0xffff) fun >> (os: OutStream) os << "(" << hi << "," << lo << ")" fun testOneLoad(t: Type, val: AnyType) @@ -134,11 +134,11 @@ import std.compilerInfo fun testAll(count: Int) testAll(Int, count) - testAll(UInt, count) - testAll(Byte, count) - testAll(UShort, count) - testAll(SizeType, count) - testAll(Float, count) + testAll(UInt32, count) + testAll(Int8, count) + testAll(UInt16, count) + testAll(UInt64, count) + testAll(Float32, count) testAll(UserDefined, count) fun sprMain diff --git a/tests/Par/LocksTest.spr b/tests/Par/LocksTest.spr index 8f215d22..150a2991 100644 --- a/tests/Par/LocksTest.spr +++ b/tests/Par/LocksTest.spr @@ -18,7 +18,7 @@ import std.compilerInfo ++numUsers test.assertEq(numUsers load, 1, "numUsers should be 1") ++numLocks - sleep(waitTime) + sleepMs(waitTime) --numUsers fun doProtectedJob(mutex: !Lockable, useTryLock: Bool = false) @@ -59,7 +59,7 @@ import std.compilerInfo for t = threads.all t.get join t.release - sleep(100) + sleepMs(100) test.assertGe(numLocks load, amountOfWork*numWorkers, "numLocks should be greater equal to what normals workers did") test.assertLe(numLocks load, amountOfWork*(numWorkers+numTryWorkers), "numLocks should be less or equal to the total work") diff --git a/tests/Par/ParForTest.spr b/tests/Par/ParForTest.spr index f2681813..c9231885 100644 --- a/tests/Par/ParForTest.spr +++ b/tests/Par/ParForTest.spr @@ -16,7 +16,7 @@ import std.compilerInfo let curIdx = counter++ if ( curIdx != x ) outOfOrderCount++ - sleep(0) + sleepMs(0) fun sprMain if ( programArgs.size() < 2 ) diff --git a/tests/Par/SemaphoreTest.spr b/tests/Par/SemaphoreTest.spr index 23098ff2..131cacaa 100644 --- a/tests/Par/SemaphoreTest.spr +++ b/tests/Par/SemaphoreTest.spr @@ -19,7 +19,7 @@ import std.compilerInfo //cout << (numUsers load) << ' ' assertLe(numUsers load, numResources, "numUsers should be less or equal to the number of resources") ++numExecutions - sleep(waitTime) + sleepMs(waitTime) --numUsers sem release diff --git a/tests/Par/TaskTest.spr b/tests/Par/TaskTest.spr index df9328e4..548e337c 100644 --- a/tests/Par/TaskTest.spr +++ b/tests/Par/TaskTest.spr @@ -13,16 +13,16 @@ import std.compilerInfo using cutoff = 16 //using cutoff = 30 - fun serialFib(n: Long): Long - return ife(n<2, n, serialFib(n-1)+serialFib(n-2)) + fun serialFib(n: Int): Int64 + return ife(n<2, Int64(n), serialFib(n-1)+serialFib(n-2)) package StackSpawnStyle datatype FibTask prefix: TaskPrefix - n: Long - result: @Long + n: Int + result: @Int64 - fun ctor(this: !FibTask, n: Long, result: @Long) + fun ctor(this: !FibTask, n: Int, result: @Int64) this.n ctor n this.result := result [ct] if isValidAndTrue(useDescriptions) @@ -39,7 +39,7 @@ import std.compilerInfo task.result = serialFib(task.n) else // Create the children tasks - var x, y: Long + var x, y: Int64 let t1 = FibTask(task.n-1, x) let t2 = FibTask(task.n-2, y) @@ -48,18 +48,18 @@ import std.compilerInfo // Do the sum task.result = x + y - fun parFib(n: Long): Long - var res: Long - spawnRootAndWait(FibTask(n, res)) + fun parFib(n: Int): Int64 + var res: Int64 + spawnRootAndWait(tmpToMut(FibTask(n, res))) return res package DynSpawnStyle datatype FibTask prefix: TaskPrefix - n: Long - result: @Long + n: Int + result: @Int64 - fun ctor(this: !FibTask, n: Long, result: @Long) + fun ctor(this: !FibTask, n: Int, result: @Int64) this.n ctor n this.result := result @@ -74,7 +74,7 @@ import std.compilerInfo task.result = serialFib(task.n) else // Create the children tasks - var x, y: Long + var x, y: Int64 var t1: @FibTask = new(FibTask, task.n-1, x) var t2: @FibTask = new(FibTask, task.n-2, y) @@ -86,18 +86,18 @@ import std.compilerInfo // Do the sum task.result = x + y - fun parFib(n: Long): Long - var res: Long - spawnRootAndWait(FibTask(n, res)) + fun parFib(n: Int): Int64 + var res: Int64 + spawnRootAndWait(tmpToMut(FibTask(n, res))) return res package ContStyle datatype FibTask prefix: TaskPrefix - n: Long - result: Long Ptr + n: Int + result: Int64 Ptr - fun ctor(this: !FibTask, n: Long, result: Long Ptr) + fun ctor(this: !FibTask, n: Int, result: Int64 Ptr) this.n ctor n this.result ctor result @@ -114,17 +114,17 @@ import std.compilerInfo var cont: @FibContTask = new(FibContTask, task.n, task.result) setContinuation(task, cont) - var t1: @FibTask = new(FibTask, task.n-1, (Long Ptr)(cont.s1)) - var t2: @FibTask = new(FibTask, task.n-2, (Long Ptr)(cont.s2)) + var t1: @FibTask = new(FibTask, task.n-1, (Int64 Ptr)(cont.s1)) + var t2: @FibTask = new(FibTask, task.n-2, (Int64 Ptr)(cont.s2)) spawn(cont, t1, t2) datatype FibContTask prefix: TaskPrefix - n: Long - s1, s2: Long - result: Long Ptr + n: Int + s1, s2: Int64 + result: Int64 Ptr - fun ctor(this: !FibContTask, n: Long, result: Long Ptr) + fun ctor(this: !FibContTask, n: Int, result: Int64 Ptr) this.n ctor n this.result ctor result @@ -137,9 +137,9 @@ import std.compilerInfo fun execute(task: !FibContTask) task.result.get = task.s1 + task.s2 - fun parFib(n: Long): Long - var res: Long - spawnRootAndWait(FibTask(n, (Long Ptr)(res))) + fun parFib(n: Int): Int64 + var res: Int64 + spawnRootAndWait(tmpToMut(FibTask(n, (Int64 Ptr)(res)))) return res fun sprMain @@ -148,7 +148,7 @@ import std.compilerInfo var style = programArgs(1) asInt var n = programArgs(2) asInt - var res: Long + var res: Int64 if style == 0 res = serialFib(n) diff --git a/tests/Par/ThreadTest.spr b/tests/Par/ThreadTest.spr index 0dd7fb3c..f82466e0 100644 --- a/tests/Par/ThreadTest.spr +++ b/tests/Par/ThreadTest.spr @@ -43,7 +43,7 @@ import std.compilerInfo lastCounter = cnt if doPrint cout << message << ": i=" << i << "; cnt=" << cnt << endl - sleep(10) + sleepMs(10) fun test1 cout << getAvailableCoresNum() << endl @@ -58,7 +58,7 @@ import std.compilerInfo var cnt1, cnt2: Int var t1 = Thread(TwiddleThumbs("worker 1", count, cnt1, true)) var t2 = Thread(TwiddleThumbs("worker 2", count, cnt2, true)) - sleep(50) + sleepMs(50) cout << "After creating the threads" << endl t1 join t2 join @@ -69,7 +69,7 @@ import std.compilerInfo var cnt1, cnt2: Int var t1 = Thread(TwiddleThumbs("worker 1", count, cnt1)) var t2 = Thread(TwiddleThumbs("worker 2", count, cnt2)) - sleep(50) + sleepMs(50) t1 join t2 join diff --git a/tests/PerfTests/FibRanges/fib_op_base.spr b/tests/PerfTests/FibRanges/fib_op_base.spr index f8fb8541..6446a7f0 100644 --- a/tests/PerfTests/FibRanges/fib_op_base.spr +++ b/tests/PerfTests/FibRanges/fib_op_base.spr @@ -2,9 +2,9 @@ import std.algorithms -fun fib(n: UInt): UInt - var a: UInt = 0 - var b: UInt = 1 +fun fib(n: Int): Int + var a: Int = 0 + var b: Int = 1 for i = 0..n var aOld = a a = b @@ -16,7 +16,7 @@ fun sprMain return; let n = programArgs(1) asInt - var res: UInt = 0 + var res: Int = 0 for i = 1...n let f = fib(i) if ( f % 2 != 0 ) diff --git a/tests/PerfTests/ForPerf/spr_for.spr b/tests/PerfTests/ForPerf/spr_for.spr index d2311578..e6bd0db5 100644 --- a/tests/PerfTests/ForPerf/spr_for.spr +++ b/tests/PerfTests/ForPerf/spr_for.spr @@ -2,11 +2,11 @@ import std.ranges -[noInline] fun testAccumulate(n: UInt): ULong - var res: ULong = 0 +[noInline] fun testAccumulate(n: Int): UInt64 + var res: UInt64 = 0 for i = 0..n for j = 0..n - res += i*j; + res += UInt64(i*j); return res; fun sprMain diff --git a/tests/PerfTests/ForPerf/spr_while.spr b/tests/PerfTests/ForPerf/spr_while.spr index 1cf70593..77f2f872 100644 --- a/tests/PerfTests/ForPerf/spr_while.spr +++ b/tests/PerfTests/ForPerf/spr_while.spr @@ -1,7 +1,7 @@ //!! -O2 -fun testAccumulate(n: UInt): ULong - var res: ULong = 0 +fun testAccumulate(n: UInt32): UInt64 + var res: UInt64 = 0 var i = 0 while i> (this: !Obj, os: !OutStream) { os << "Obj(" << value << ")"; } @@ -23,12 +23,12 @@ datatype Equal(type: Type) fun () (this: Equal, x,y: this.T): Bool = x == y using ObjPtr = Ptr(Obj) -using TestHashMap = Map(UInt, ObjPtr) -using TestSortedMap = SortedMap(UInt, ObjPtr, Less(UInt), Equal(UInt)) +using TestHashMap = Map(Int, ObjPtr) +using TestSortedMap = SortedMap(Int, ObjPtr, Less(Int), Equal(Int)) var objects: Array(Obj) -var insertKeys: Array(UInt) -var searchKeys: Array(UInt) +var insertKeys: Array(Int) +var searchKeys: Array(Int) fun testInsert(bag: !AnyType, n: Int) for i = 0..n @@ -114,17 +114,17 @@ fun testRemove(bag: !AnyType, n: Int) [noDefault] datatype TestTimer desc: StringRef - n: UInt + n: Int timerImpl: time.Timer -fun ctor(this: !TestTimer, desc: StringRef, n: UInt) +fun ctor(this: !TestTimer, desc: StringRef, n: Int) this.desc ctor desc this.n ctor n timerImpl ctor fun dtor(this: !TestTimer) let t = timerImpl.elapsed() - let t_ns = t * 1000000.0 / Double(n) + let t_ns = t * 1000000.0 / Float(n) cout << desc << ":\t" << t << ", " << t_ns << " ns" << endl fun sprMain @@ -137,8 +137,8 @@ fun sprMain objects = Array(Obj)(n) // Initialize the keys - insertKeys = Array(UInt)(n) - searchKeys = Array(UInt)(n) + insertKeys = Array(Int)(n) + searchKeys = Array(Int)(n) for i = 0..n insertKeys(i) = 0x80000000 + i*2 searchKeys(i) = 0x80000000 + i*2 diff --git a/tests/PerfTests/LazyRanges/lazy_ranges.spr b/tests/PerfTests/LazyRanges/lazy_ranges.spr index febbf3ca..e065feb7 100644 --- a/tests/PerfTests/LazyRanges/lazy_ranges.spr +++ b/tests/PerfTests/LazyRanges/lazy_ranges.spr @@ -4,15 +4,17 @@ import std.algorithms import std.ranges import std.rMath -fun nextCollatz n = ife(n%2==0, n/2, n*3+1) -fun collatzSeq(n: ULong) = generate1(n, \nextCollatz) takeUntil (fun n = n==1) +fun nextCollatz(n: UInt64): UInt64 = ife(n%2UL==0UL, n/2UL, n*3UL+1UL) +fun collatzSeq(n: Int) = generate1(UInt64(n), \nextCollatz) takeUntil (fun n = n==1UL) + +fun toU64 n = UInt64(n) fun sprMain if ( programArgs.size() < 2 ) return; let n = programArgs(1) asInt - let res = (1..) map \collatzSeq map \rangeSize takeWhile (fun.{n} s = s < n) rootMeanSquare + let res = (1..) map \collatzSeq map \rangeSize takeWhile (fun.{n} s = s < n) map \toU64 rootMeanSquare cout << res << endl /*<< 1 n = nextCollatz(n) ++len @@ -18,7 +18,7 @@ fun sprMain return; let n = programArgs(1) asInt - var sum: ULong = 0 + var sum: UInt64 = 0 var count = 0 for i = 1.. let len = collatzLen(i) @@ -27,7 +27,7 @@ fun sprMain // Main part of computing the root mean square sum += len*len ++count - let res = sqrt(Double(sum) / Double(count)) + let res = sqrt(Float(sum) / Float(count)) cout << res << endl /*<< err p2 = poly3(a, b, c, d, x2) @@ -21,8 +21,8 @@ fun secantMethod(a, b, c, d, x1, x2, err: Double): Double return t [native("test")] fun test(n: Int) - writeLnDouble(secantMethod(0.0, 1.0, 0.0, -612.0, 10.0, 30.0, 0.001)) - writeLnDouble(secantMethod(1.0, 2.0, 3.0, 4.0, -10.0, 10.0, 0.00001)) + writeLnFloat(secantMethod(0.0, 1.0, 0.0, -612.0, 10.0, 30.0, 0.001)) + writeLnFloat(secantMethod(1.0, 2.0, 3.0, 4.0, -10.0, 10.0, 0.00001)) /*<<>>*/ fun test22() @@ -433,7 +433,7 @@ fun test22() cout << indexOfIf(nr, Even()) << endl /*<<>>*/ fun test23() diff --git a/tests/StdLib/AlgorithmsTest3.spr b/tests/StdLib/AlgorithmsTest3.spr index c639470f..c0d69ad2 100644 --- a/tests/StdLib/AlgorithmsTest3.spr +++ b/tests/StdLib/AlgorithmsTest3.spr @@ -97,9 +97,9 @@ fun makeList(li: !List(Int)) // } // } -fun createRangeAscending(size: SizeType): ContiguousMemoryRange(Int) +fun createRangeAscending(size: Int): ContiguousMemoryRange(Int) var ptr = allocRawPtr(Int, size) - let ptrEnd = ptr.advance(DiffType(size)) + let ptrEnd = ptr.advance(size) var i = 0 while i < size ; i = i + 1 diff --git a/tests/StdLib/AlgorithmsTest4.spr b/tests/StdLib/AlgorithmsTest4.spr index 19bab30f..f1ffabfb 100644 --- a/tests/StdLib/AlgorithmsTest4.spr +++ b/tests/StdLib/AlgorithmsTest4.spr @@ -66,9 +66,9 @@ fun makeList(): List(Int) return li -fun createRangeAscending(size: SizeType): ContiguousMemoryRange(Int) +fun createRangeAscending(size: Int): ContiguousMemoryRange(Int) var ptr = allocRawPtr(Int, size) - let ptrEnd = ptr.advance(DiffType(size)) + let ptrEnd = ptr.advance(size) var i = 0 while i < size ; i = i + 1 diff --git a/tests/StdLib/ArrayTest.spr b/tests/StdLib/ArrayTest.spr index 96056205..665f88fc 100644 --- a/tests/StdLib/ArrayTest.spr +++ b/tests/StdLib/ArrayTest.spr @@ -26,7 +26,7 @@ fun sprMain datatype MyObj x: Int; -fun createRangeAscending(size: SizeType): ContiguousMemoryRange(MyObj) +fun createRangeAscending(size: Int): ContiguousMemoryRange(MyObj) var ptr: RawPtr(MyObj) = allocRawPtr(MyObj, size) let ptrEnd = ptr.advance(size) var i = 0 diff --git a/tests/StdLib/ContiguousMemoryRangeTest.spr b/tests/StdLib/ContiguousMemoryRangeTest.spr index 32e959bd..41dcff2a 100644 --- a/tests/StdLib/ContiguousMemoryRangeTest.spr +++ b/tests/StdLib/ContiguousMemoryRangeTest.spr @@ -23,9 +23,9 @@ datatype MyObj fun ctor(this: !MyObj, xx: Int) x ctor xx -fun createRange(size: SizeType): ContiguousMemoryRange(MyObj) +fun createRange(size: Int): ContiguousMemoryRange(MyObj) var ptr = allocRawPtr(MyObj, size) - let ptrEnd = ptr.advance(DiffType(size)) + let ptrEnd = ptr.advance(size) var p = ptr while (p != ptrEnd) ; p = p.advance() @@ -33,9 +33,9 @@ fun createRange(size: SizeType): ContiguousMemoryRange(MyObj) return ContiguousMemoryRange(MyObj)(ptr, ptrEnd); -fun createRangeAscending(size: SizeType): ContiguousMemoryRange(MyObj) +fun createRangeAscending(size: Int): ContiguousMemoryRange(MyObj) var ptr = allocRawPtr(MyObj, size) - let ptrEnd = ptr.advance(DiffType(size)) + let ptrEnd = ptr.advance(size) var i = 0 while i < size ; i = i + 1 diff --git a/tests/StdLib/HashMapTest.spr b/tests/StdLib/HashMapTest.spr index 4317ac1f..6aef07f4 100644 --- a/tests/StdLib/HashMapTest.spr +++ b/tests/StdLib/HashMapTest.spr @@ -12,9 +12,9 @@ datatype IntWrapper [convert] fun ctor(this: !IntWrapper, x: Int) { this.x ctor x; } -fun hash(this: IntWrapper): SizeType +fun hash(this: IntWrapper): UInt64 cout << "IntWrapper.hash called for value " << x << endl - return x + return UInt64(x) [convert] datatype IntWithNoHash @@ -28,9 +28,9 @@ datatype MyTypeTraits fun equal(this: MyTypeTraits, l, r: IntWithNoHash) = l == r fun less(this: MyTypeTraits, l, r: IntWithNoHash) = l.x < r.x -fun hash(this: MyTypeTraits, val: IntWithNoHash): SizeType +fun hash(this: MyTypeTraits, val: IntWithNoHash): UInt64 cout << "MyTypeTraits.hash called for value " << val.x << endl - return val.x + return UInt64(val.x) fun sprMain if ( programArgs.size() < 2 ) diff --git a/tests/StdLib/ListTest.spr b/tests/StdLib/ListTest.spr index ac0a5b5b..d5053bfe 100644 --- a/tests/StdLib/ListTest.spr +++ b/tests/StdLib/ListTest.spr @@ -51,9 +51,9 @@ datatype Even ; fun ()(this: Even, x: MyObj): Bool { return x.x % 2 == 0; } -fun createRangeAscending(size: SizeType): ContiguousMemoryRange(MyObj) +fun createRangeAscending(size: Int): ContiguousMemoryRange(MyObj) var ptr = allocRawPtr(MyObj, size) - let ptrEnd = ptr.advance(DiffType(size)) + let ptrEnd = ptr.advance(size) var i = 0 while i < size ; i = i + 1 diff --git a/tests/StdLib/PtrTest.spr b/tests/StdLib/PtrTest.spr index 977c25e1..5619dd02 100644 --- a/tests/StdLib/PtrTest.spr +++ b/tests/StdLib/PtrTest.spr @@ -40,7 +40,7 @@ fun sprMain else if n == 7; test7 else if n == 8; test8 -[native("malloc")] fun mallocRt(size: SizeType): UntypedPtr +[native("malloc")] fun mallocRt(size: Int): UntypedPtr [native("free")] fun freeRt(p: UntypedPtr) fun newObj(x: Int): @MyObj @@ -61,11 +61,11 @@ fun test1() var scp: ScopedPtr(MyObj) let shp: SharedPtr(MyObj) - if ( !isNullRef(reinterpretCast(@Byte, p.get())) || !p.isNull() ) + if ( !isNullRef(reinterpretCast(@Int8, p.get())) || !p.isNull() ) cout << "test failed" << endl; - if ( !isNullRef(reinterpretCast(@Byte, scp.get())) || !scp.isNull() ) + if ( !isNullRef(reinterpretCast(@Int8, scp.get())) || !scp.isNull() ) cout << "test failed" << endl; - if ( !isNullRef(reinterpretCast(@Byte, shp.get())) || !shp.isNull() ) + if ( !isNullRef(reinterpretCast(@Int8, shp.get())) || !shp.isNull() ) cout << "test failed" << endl; /*<<>>*/ @@ -78,7 +78,7 @@ fun test2() cout << p.get().x << endl p.reset() - if ( !isNullRef(reinterpretCast(@Byte, p.get())) || !p.isNull() ) + if ( !isNullRef(reinterpretCast(@Int8, p.get())) || !p.isNull() ) cout << "test failed" << endl; p.reset(obj) cout << p.get().x << endl @@ -110,7 +110,7 @@ fun test3() cout << p.get().x << endl p.reset() - if ( !isNullRef(reinterpretCast(@Byte, p.get())) || !p.isNull() ) + if ( !isNullRef(reinterpretCast(@Int8, p.get())) || !p.isNull() ) cout << "test failed" << endl; obj := newObj(42) p.reset(obj) @@ -143,7 +143,7 @@ fun test4() cout << "test failed" << endl; cout << p.get().x << endl p.reset() - if ( !isNullRef(reinterpretCast(@Byte, p.get())) || !p.isNull() ) + if ( !isNullRef(reinterpretCast(@Int8, p.get())) || !p.isNull() ) cout << "test failed" << endl; obj := newObj(42) p.reset(obj) diff --git a/tests/StdLib/RangesTest.spr b/tests/StdLib/RangesTest.spr index dc5218af..423c84ed 100644 --- a/tests/StdLib/RangesTest.spr +++ b/tests/StdLib/RangesTest.spr @@ -101,9 +101,9 @@ fun makeList(): List(Int) return li -fun createRangeAscending(size: SizeType): ContiguousMemoryRange(Int) +fun createRangeAscending(size: Int): ContiguousMemoryRange(Int) var ptr = allocRawPtr(Int, size) - let ptrEnd = ptr.advance(DiffType(size)) + let ptrEnd = ptr.advance(size) var i = 0 while i < size ; i++ @@ -438,9 +438,9 @@ fun test17() fun test18() printRange( (1..) take 10 ) printRange( (21..) take 10 ) - printRange( (Byte(1)..) take 10 ) - printRange( Byte(120).. ) - printRange( (Long(1)..) take 10 ) + printRange( (Int8(1)..) take 10 ) + printRange( Int8(120).. ) + printRange( (Int64(1)..) take 10 ) /*<<>>*/ fun test3 - var union: Union(Int, StaticArray(Byte,4)) + var union: Union(Int, StaticArray(Int8,4)) union.get1 = 7963 cout << (union.get2).at(0) << endl @@ -49,7 +49,7 @@ fun test3 20 >>>*/ fun test4 - var union: Union(Int, StaticArray(Byte, 20), Float) + var union: Union(Int, StaticArray(Int8, 20), Float32) cout << sizeOf(union) << endl @@ -59,11 +59,11 @@ fun test4 fun test5 var union: Union(Int, \ StaticArray(Int, 100), \ - Float, \ - StaticArray(Byte, 100), \ + Float32, \ + StaticArray(Int8, 100), \ Char, \ - Long, \ - StaticArray(Long, 100)) + Int64, \ + StaticArray(Int64, 100)) cout << sizeOf(union) << endl @@ -75,32 +75,32 @@ fun test5 73 >>>*/ fun test6 - var union: Union(Int, \ - StaticArray(UInt, 100), \ - Float, \ - StaticArray(UByte, 100), \ - Char, \ - Long, \ - StaticArray(Int, 100), \ - StaticArray(Float, 100), \ - StaticArray(Char, 100), \ - StaticArray(Long, 100), \ - StaticArray(ULong, 200)) - - (union.get6) = 1234567890 + var union: Union(Int, + StaticArray(UInt32, 100), + Float32, + StaticArray(UInt8, 100), + Char, + Int64, + StaticArray(Int, 100), + StaticArray(Float32, 100), + StaticArray(Char, 100), + StaticArray(Int64, 100), + StaticArray(UInt64, 200)) + + (union.get6) = Int64(1234567890) cout << sizeOf(union) << endl - cout << (union.get4).at(0) << endl - cout << (union.get4).at(1) << endl - cout << (union.get4).at(2) << endl - cout << (union.get4).at(3) << endl + cout << Int(union.get4()(0)) << endl + cout << Int(union.get4()(1)) << endl + cout << Int(union.get4()(2)) << endl + cout << Int(union.get4()(3)) << endl /*<<>>*/ fun test7 - var union: Union(Int, StaticArray(Byte, 20), myType) + var union: Union(Int, StaticArray(Int8, 20), myType) cout << sizeOf(union) << endl /*<<>>*/ fun test8 - var union: Union(myType, innerType, StaticArray(Byte, 20), outerType, ULong, UInt) + var union: Union(myType, innerType, StaticArray(Int8, 20), outerType, UInt64, UInt32) (union.get1).a = 12345 - ((union.get1).b).at(2) = UByte(1) - (union.get3).at(19) = Byte(1) + ((union.get1).b).at(2) = UInt8(1) + (union.get3).at(19) = Int8(1) cout << sizeOf(union) << endl cout << union.get6 << endl diff --git a/tests/StdLib/VectorCtTest.spr b/tests/StdLib/VectorCtTest.spr index 09ff68d3..3dd7644b 100644 --- a/tests/StdLib/VectorCtTest.spr +++ b/tests/StdLib/VectorCtTest.spr @@ -15,9 +15,9 @@ fun sprMain datatype MyObj x: Int -[ct] fun createRangeAscending(size: SizeType): ContiguousMemoryRange(MyObj) +[ct] fun createRangeAscending(size: Int): ContiguousMemoryRange(MyObj) var ptr = allocRawPtr(MyObj, size) - let ptrEnd = ptr.advance(DiffType(size)) + let ptrEnd = ptr.advance(size) var i = 0 while i < size ; i = i + 1 @@ -27,7 +27,7 @@ datatype MyObj return ContiguousMemoryRange(MyObj)(ptr, ptrEnd) -[ct] fun createVector(size: SizeType): Vector(MyObj) +[ct] fun createVector(size: Int): Vector(MyObj) let v = Vector(MyObj)(createRangeAscending(size)) return v diff --git a/tests/StdLib/VectorTest.spr b/tests/StdLib/VectorTest.spr index 5bef8e28..03e7336c 100644 --- a/tests/StdLib/VectorTest.spr +++ b/tests/StdLib/VectorTest.spr @@ -49,7 +49,8 @@ fun sprMain return true }) ~ "vector's copy constructor (Data); no copy ctor" - forAll(SizeType) check (fun sz: Bool { + forAll(UInt16) check (fun szu16: Bool { + let sz: Int = szu16 var vec: Vec = sz if ( vec.size != sz ) return false for i = 0..sz @@ -261,9 +262,9 @@ fun arbitrary(t: Type): TestRange Gen if t == TestRange return mkGen(t, \generateTestRange) //! Generate an arbitrary vector -fun generateVec(sizeHint: UInt): Vec +fun generateVec(sizeHint: Int): Vec var res: Vec - var h: Int = sizeHint + 5 + var h = sizeHint + 5 var size = randBetween(0, h) res.resize(size) for i = 0..size @@ -271,8 +272,8 @@ fun generateVec(sizeHint: UInt): Vec return res //! Generate an arbitrary test range -fun generateTestRange(sizeHint: UInt): TestRange - var h: Int = sizeHint + 3 +fun generateTestRange(sizeHint: Int): TestRange + var h = sizeHint + 3 var size = randBetween(0, h+1) // Allocate a buffer of memory to hold the values @@ -288,13 +289,13 @@ fun generateTestRange(sizeHint: UInt): TestRange datatype SubrangeTestData vec: Vec - start, count: SizeType + start, count: Int fun >>(this: SubrangeTestData, os: !OutStream) os << vec << ", start=" << start << ", count=" << count fun arbitrary(t: Type): SubrangeTestData Gen if t == SubrangeTestData - return mkGen(SubrangeTestData, (fun (sizeHint: UInt): SubrangeTestData { + return mkGen(SubrangeTestData, (fun (sizeHint: Int): SubrangeTestData { var res: SubrangeTestData res.vec = generateVec(sizeHint) res.count = randBetween(0, res.vec.size) @@ -305,14 +306,14 @@ fun arbitrary(t: Type): SubrangeTestData Gen if t == SubrangeTestData datatype InsertValueTestData vec: Vec - idx: SizeType + idx: Int value: Int fun >>(this: InsertValueTestData, os: !OutStream) os << vec << ", idx=" << idx << ", value=" << value fun arbitrary(t: Type): InsertValueTestData Gen if t == InsertValueTestData - return mkGen(InsertValueTestData, (fun (sizeHint: UInt): InsertValueTestData { + return mkGen(InsertValueTestData, (fun (sizeHint: Int): InsertValueTestData { var res: InsertValueTestData res.vec = generateVec(sizeHint) res.idx = randBetween(0, res.vec.size) @@ -322,14 +323,14 @@ fun arbitrary(t: Type): InsertValueTestData Gen if t == InsertValueTestData datatype InsertRangeTestData vec: Vec - idx: SizeType + idx: Int values: Vec fun >>(this: InsertRangeTestData, os: !OutStream) os << vec << ", idx=" << idx << ", values=" << values fun arbitrary(t: Type): InsertRangeTestData Gen if t == InsertRangeTestData - return mkGen(InsertRangeTestData, (fun (sizeHint: UInt): InsertRangeTestData { + return mkGen(InsertRangeTestData, (fun (sizeHint: Int): InsertRangeTestData { var res: InsertRangeTestData res.vec = generateVec(sizeHint) res.idx = randBetween(0, res.vec.size) @@ -354,6 +355,6 @@ var copyCtorCnt = 0 fun arbitrary(t: Type): DataVec Gen if t == DataVec return mkGen(DataVec, \generateDataVec) -fun generateDataVec(sizeHint: UInt): DataVec +fun generateDataVec(sizeHint: Int): DataVec return DataVec(generateVec(sizeHint).all map (fun x = Data(x))) diff --git a/tests/test.py b/tests/test.py index 467007b0..fe871bc7 100755 --- a/tests/test.py +++ b/tests/test.py @@ -80,6 +80,11 @@ def getTestFiles(toRun, testsFile): filename = m.group(1).strip() testName = m.group(2).strip() + # Filename must exist + if not os.path.isfile(filename): + print('WARNING: Invalid filename: "%s"' % filename) + continue + # Apply filter if toRun and toRun not in filename: continue diff --git a/tests/tests.in b/tests/tests.in index 7442b2c1..55ee8fdf 100644 --- a/tests/tests.in +++ b/tests/tests.in @@ -56,6 +56,7 @@ Bugs/VectorOfCtClass.spr: Bugs - vectors of CT-only classes Bugs/WhileVarCond.spr: Bugs - while condition is a variable or a reference Bugs/GenericWithCtConcept.spr: Bugs - generic with CT concept Bugs/CastOnAssignment.spr: Bugs - cast on assignment +Bugs/test.spr: Bugs - using local files instead of std lib ones # AlgoProblems/P1_Collatz.spr: Algo problems - P1. Collatz sequences Examples/Power.spr: Examples: Powers @@ -106,8 +107,6 @@ Basic/SameName.spr: Basic features - Class, function, var wi Basic/CtFun.spr: Basic features - CT functions Basic/CtFactorial.spr: Basic features - CT factorial Basic/CtIf.spr: Basic features - CT if -Basic/Operators.spr: Basic features - Operators -Basic/Convert.spr: Basic features - Conversions Basic/GeneratedCtorDtor.spr: Basic features - Generated ctor dtor Basic/CtorDtor.spr: Basic features - Object constructors & destructors Basic/StaticCtorDtor.spr: Basic features - Static constructors & destructors @@ -121,12 +120,6 @@ Basic/IfClause.spr: Basic features - If clause Basic/Auto.spr: Basic features - Auto Basic/String.spr: Basic features - String Basic/ValueToRef.spr: Basic features - Value to reference -Basic/CallCtorDtor.spr: Basic features - Call ctor & dtor -Basic/TypeTraits.spr: Basic features - Type traits -Basic/Overload.spr: Basic features - Overload -Basic/FunExp.spr: Basic features - Expression functions -Basic/FunSyntax.spr: Basic features - Function syntax -Basic/DefaultParam.spr: Basic features - Default parameters Basic/Concepts.spr: Basic features - Concepts Basic/CtToRt.spr: Basic features - CT to RT for basic types Basic/CtToRtErr.spr: Basic features - CT to RT for basic types - errors @@ -134,7 +127,6 @@ Basic/CtToRtComplex.spr: Basic features - CT to RT for complex ty Basic/ImplicitFunCall.spr: Basic features - Implicit function call, without parenthesis Basic/CompDefines.spr: Basic features - Compiler defines Basic/This.spr: Basic features - This -Basic/CallOperator.spr: Basic features - Call operator Basic/DependentTypes.spr: Basic features - Dependent types Basic/Using.spr: Basic features - Using directives Basic/datatype/syntax.spr: Basic features - datatype - various syntaxes @@ -145,9 +137,21 @@ Basic/datatype/initCtor.spr: Basic features - datatype - initCtor Basic/datatype/bitcopiable.spr: Basic features - datatype - bitcopiable Basic/datatype/queryBitcopiable.spr: Basic features - datatype - query bitcopiable Basic/datatype/autoBitcopiable.spr: Basic features - datatype - auto bitcopiable +Basic/datatype/datatypeCat.spr: Basic features - datatype - categories in datatype Basic/exp/dotOper.spr: Basic features - expressions - dot operator Basic/vars/typeCatVarsErr.spr: Basic features - vars - type cat variables (err) Basic/vars/typeCatFieldsErr.spr: Basic features - vars - type cat fields (err) +Basic/fun/overloadBasic.spr: Basic features - fun - Overload (basic) +Basic/fun/overloadCat.spr: Basic features - fun - Overload on type categories +Basic/fun/callCtorDtor.spr: Basic features - fun - Call ctor & dtor +Basic/fun/callOperator.spr: Basic features - fun - Call operator +Basic/fun/defaultParam.spr: Basic features - fun - Default parameters +Basic/fun/funExp.spr: Basic features - fun - Expression functions +Basic/fun/funSyntax.spr: Basic features - fun - Function syntax +Basic/fun/operators.spr: Basic features - fun - Operators +Basic/types/typeTraits.spr: Basic features - types - Type traits +Basic/types/temp.spr: Basic features - types - temp types +Basic/types/returnsTemp.spr: Basic features - types - Functions return temp types Imports/ImportTwice.spr: Import twice the same file Imports/ImportComplex.spr: Import a complex hierarchy of files, some of them twice @@ -166,6 +170,7 @@ Simple/Ackermann.spr: Simple problems - Ackermann function Frontend/Smoke.spr: Frontend - grammar smoke test Frontend/Identifiers.spr: Frontend - identifiers +Frontend/Numbers.spr: Frontend - numbers Frontend/Operators.spr: Frontend - operators Frontend/PrefixPostfix.spr: Frontend - prefix & postfix operators Frontend/StringAndDsl.spr: Frontend - string and DSL diff --git a/tools/formatDetails/astNodes.spr b/tools/formatDetails/astNodes.spr index 1169791d..70eaee69 100644 --- a/tools/formatDetails/astNodes.spr +++ b/tools/formatDetails/astNodes.spr @@ -45,7 +45,7 @@ fun _toImpl(n: Node): @AstNodeImpl return reinterpretCast(@AstNodeImpl, n.data.data) else return _nullAstNodeImpl -fun _toNode(impl: @AstNodeImpl) = Node(UntypedPtr(reinterpretCast(@Byte, impl))) +fun _toNode(impl: @AstNodeImpl) = Node(UntypedPtr(impl)) fun isSet(this: Node) = this.data.data !== null fun isNull(this: Node) = this.data.data === null @@ -138,15 +138,15 @@ fun mkBoolLiteral(this: @SimpleAstBuilder, loc: @Location, val: Bool) \ = createNode(loc, nkBoolLiteral) fun mkIntLiteral(this: @SimpleAstBuilder, loc: @Location, val: Int) \ = createNode(loc, nkIntLiteral) -fun mkUIntLiteral(this: @SimpleAstBuilder, loc: @Location, val: UInt) \ +fun mkUIntLiteral(this: @SimpleAstBuilder, loc: @Location, val: UInt32) \ = createNode(loc, nkUIntLiteral) -fun mkLongLiteral(this: @SimpleAstBuilder, loc: @Location, val: Long) \ +fun mkLongLiteral(this: @SimpleAstBuilder, loc: @Location, val: Int64) \ = createNode(loc, nkLongLiteral) -fun mkULongLiteral(this: @SimpleAstBuilder, loc: @Location, val: ULong) \ +fun mkULongLiteral(this: @SimpleAstBuilder, loc: @Location, val: UInt64) \ = createNode(loc, nkULongLiteral) -fun mkFloatLiteral(this: @SimpleAstBuilder, loc: @Location, val: Float) \ +fun mkFloatLiteral(this: @SimpleAstBuilder, loc: @Location, val: Float32) \ = createNode(loc, nkFloatLiteral) -fun mkDoubleLiteral(this: @SimpleAstBuilder, loc: @Location, val: Double) \ +fun mkDoubleLiteral(this: @SimpleAstBuilder, loc: @Location, val: Float64) \ = createNode(loc, nkDoubleLiteral) fun mkCharLiteral(this: @SimpleAstBuilder, loc: @Location, val: Char) \ = createNode(loc, nkCharLiteral) diff --git a/tools/transforms/removeExtraSpaces.spr b/tools/transforms/removeExtraSpaces.spr index bace3d94..4459a156 100644 --- a/tools/transforms/removeExtraSpaces.spr +++ b/tools/transforms/removeExtraSpaces.spr @@ -25,10 +25,10 @@ fun _removeMultipleEmptyLines(src: @SourceData) var remaining = src.tokens.subrange(i+1) if tok.type != tkWHITESPACE && tok.type != tkEOL - lastLineWithVisible = tok.loc.start.line + lastLineWithVisible = Int(tok.loc.start.line) numNewlines = 0 if tok.type == tkEOL - if lastLineWithVisible != tok.loc.start.line + if lastLineWithVisible != Int(tok.loc.start.line) numNewlines++ if numNewlines >= 3 && tok.canFormat diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt index 72194a2e..412ae367 100644 --- a/unittests/CMakeLists.txt +++ b/unittests/CMakeLists.txt @@ -31,6 +31,7 @@ SET(sourceFiles "SparrowFrontend/SprCommon/SampleTypes.cpp" "SparrowFrontend/TestCallable.cpp" "SparrowFrontend/TestConvert.cpp" + "SparrowFrontend/TestDecls.cpp" "SparrowFrontend/TestGenerics.cpp" ) diff --git a/unittests/Common/TypeFactory.cpp b/unittests/Common/TypeFactory.cpp index 4a842677..89160ea0 100644 --- a/unittests/Common/TypeFactory.cpp +++ b/unittests/Common/TypeFactory.cpp @@ -108,14 +108,14 @@ Gen arbTypeWithStorage(EvalMode mode, int minRef, int maxRef) { Gen arbBasicStorageType(EvalMode mode, int minRef, int maxRef) { int weightDataType = 5; - int weightConstType = minRef == 0 ? 0 : 3; - int weightMutableType = minRef == 0 ? 0 : 3; + int weightConstType = maxRef == 0 ? 0 : 3; + int weightMutableType = maxRef == 0 ? 0 : 3; int weightTempType = 1; return gen::weightedOneOf({ {weightDataType, gen::cast(arbDataType(mode, minRef, maxRef))}, - {weightConstType, gen::cast(arbConstType(mode, minRef, maxRef))}, - {weightMutableType, gen::cast(arbMutableType(mode, minRef, maxRef))}, - {weightTempType, gen::cast(arbTempType(mode, minRef, maxRef))}, + {weightConstType, gen::cast(arbConstType(mode, std::min(minRef, 1), maxRef))}, + {weightMutableType, gen::cast(arbMutableType(mode, std::min(minRef, 1), maxRef))}, + {weightTempType, gen::cast(arbTempType(mode, std::min(minRef, 1), maxRef))}, }); } diff --git a/unittests/SparrowFrontend/SprCommon/GenValueForType.cpp b/unittests/SparrowFrontend/SprCommon/GenValueForType.cpp index 9130e22d..40a54524 100644 --- a/unittests/SparrowFrontend/SprCommon/GenValueForType.cpp +++ b/unittests/SparrowFrontend/SprCommon/GenValueForType.cpp @@ -72,7 +72,7 @@ Gen arbValueConvertibleTo(TypeWithStorage t, const SampleTypes* samp int weightFromPlain = tk == typeKindConst ? 1 : 0; int weightFromConst = tk == typeKindData ? 1 : 0; int weightFromMutable = tk != typeKindTemp ? 1 : 0; - int weightFromTmp = 1; + int weightFromTmp = tk != typeKindMutable ? 1 : 0; TypeWithStorage newType; auto alt = *gen::weightedElement( diff --git a/unittests/SparrowFrontend/TestConvert.cpp b/unittests/SparrowFrontend/TestConvert.cpp index b9eb890a..deb415db 100644 --- a/unittests/SparrowFrontend/TestConvert.cpp +++ b/unittests/SparrowFrontend/TestConvert.cpp @@ -172,25 +172,26 @@ TEST_CASE_METHOD(ConvertFixture, "Conversion rules are properly applied") { ConversionType c1 = getConvType(t, u); RC_LOG() << " " << t << " -> " << u << " = " << int(c1) << endl; - if (c1) + // Allowed exception: T -> U tmp + if (c1 && u.kind() != typeKindTemp) RC_ASSERT(getConvType(mutT, u) != convNone); }); - rc::prop("if @T->U (T=datatype) then lv(T)->U", [=]() { - auto t = *TypeFactory::arbDataType(); - auto u = *TypeFactory::arbBasicStorageType(); - RC_PRE(t.referredNode() == u.referredNode()); // increase the chance of matching - Type mutT = MutableType::get(t); - RC_LOG() << mutT << " -> " << u << endl; + // rc::prop("if @T->U (T=datatype) then mut(T)->U", [=]() { + // auto t = *TypeFactory::arbDataType(); + // auto u = *TypeFactory::arbBasicStorageType(); + // RC_PRE(t.referredNode() == u.referredNode()); // increase the chance of matching + // Type mutT = MutableType::get(t); + // RC_LOG() << mutT << " -> " << u << endl; - Type rt = addRef(DataType(t)); - ConversionType c1 = getConvType(rt, u); - RC_LOG() << " " << rt << " -> " << u << " = " << int(c1) << endl; + // Type rt = addRef(DataType(t)); + // ConversionType c1 = getConvType(rt, u); + // RC_LOG() << " " << rt << " -> " << u << " = " << int(c1) << endl; - if (c1) { - RC_ASSERT(getConvType(mutT, u) != convNone); - } - }); + // if (c1 && u.kind() != typeKindConst) { + // RC_ASSERT(getConvType(mutT, u) != convNone); + // } + // }); SECTION("MutableType examples") { Node* decl = TypeFactory::g_dataTypeDecls[0]; @@ -329,9 +330,15 @@ TEST_CASE_METHOD(ConvertFixture, "Conversion rules are properly applied") { TypeWithStorage c2tmp = TempType::get(c2); CHECK(getConvType(src0, c0) == convConcept); + CHECK(getConvType(src0, c0const) == convConcept); + CHECK(getConvType(src0, c0tmp) == convConcept); CHECK(getConvType(src0const, c0const) == convConcept); CHECK(getConvType(src0mut, c0mut) == convConcept); + CHECK(getConvType(src0mut, c0const) == convConcept); CHECK(getConvType(src0tmp, c0tmp) == convConcept); + CHECK(getConvType(src0tmp, c0const) == convConcept); + CHECK(getConvType(src0tmp, c0mut) == convNone); + CHECK(getConvType(src0tmp, c0) == convConcept); CHECK(getConvType(src1const, c1) == convConcept); CHECK(getConvType(src1const, c1const) == convConcept); @@ -655,7 +662,7 @@ void ConvertFixture::checkCatConversions(DataType src, DataType dest) { // Direct: tmp(T)->const(U), if T->U RC_ASSERT(getConvType(tmpSrc, constDest) == baseConv); // Direct: tmp(T)->mut(U), if T->U - RC_ASSERT(getConvType(tmpSrc, mutDest) == baseConv); + RC_ASSERT(getConvType(tmpSrc, mutDest) == convNone); // Direct: tmp(T)->plain(U), if T->U RC_ASSERT(getConvType(tmpSrc, dest) == baseConv); } diff --git a/unittests/SparrowFrontend/TestDecls.cpp b/unittests/SparrowFrontend/TestDecls.cpp new file mode 100644 index 00000000..a0cade15 --- /dev/null +++ b/unittests/SparrowFrontend/TestDecls.cpp @@ -0,0 +1,100 @@ +#include "StdInc.h" +#include "Common/RcBasic.hpp" +#include "Common/TypeFactory.hpp" +#include "Common/GeneralFixture.hpp" +#include "Common/FeatherNodeFactory.hpp" +#include "Common/LocationGen.hpp" +#include "SprCommon/SampleTypes.hpp" +#include "SprCommon/GenGenericParams.hpp" +#include "SprCommon/GenCallableDecl.hpp" +#include "SprCommon/Utils.hpp" + +#include "SparrowFrontend/SprDebug.h" +#include "SparrowFrontend/Nodes/Decl.hpp" +#include "SparrowFrontend/Nodes/Exp.hpp" +#include "SparrowFrontend/Nodes/Builder.h" +#include "SparrowFrontend/Helpers/Generics.h" +#include "SparrowFrontend/Helpers/SprTypeTraits.h" +#include "Feather/Utils/cppif/FeatherNodes.hpp" + +using namespace Feather; +using namespace SprFrontend; +using namespace rc; + +struct DeclsFixture : SparrowGeneralFixture { + //! The types that we are using while performing our tests + SampleTypes types_; +}; + +rc::Gen arbBasicDataTypeDecl() { + return rc::gen::exec([=]() -> DataTypeDecl { + auto loc = g_LocationGen(); + int numFields = *gen::inRange(0, 10); + NodeList body; + for (int i=0; i(); + RC_ASSERT(structDecl); + + // Check that the fields match + RC_ASSERT(structDecl.fields().size() == nodeListSize(datatypeDecl.body())); + for ( int i=0; i(); + RC_ASSERT(structVar); + auto origField = datatypeDecl.body().children()[i].kindCast(); + RC_ASSERT(origField); + + // Original field should be explained by the field found in the structure + RC_ASSERT(origField.explanation() == structVar); + + auto tRes = structVar.type(); + auto tOrig = TypeWithStorage(origField.typeNode().type()); + + // No category in the resulting type + RC_ASSERT(!isCategoryType(tRes)); + + // Check for the number of references + RC_ASSERT(tRes.numReferences() == removeCategoryIfPresent(tOrig).numReferences()); + + // If the original type is a cat-type, make sure the category is kept as a property + if (isCategoryType(tOrig)) + RC_ASSERT(tOrig.kind() == structVar.getCheckPropertyInt(propSprOrigCat)); + } + }); +}