Index: include/llvm/Transforms/Scalar/GVNExpression.h =================================================================== --- include/llvm/Transforms/Scalar/GVNExpression.h +++ include/llvm/Transforms/Scalar/GVNExpression.h @@ -333,11 +333,14 @@ class StoreExpression final : public BasicExpression { private: StoreInst *Store; + Value *StoredValue; MemoryAccess *DefiningAccess; public: - StoreExpression(unsigned NumOperands, StoreInst *S, MemoryAccess *DA) - : BasicExpression(NumOperands, ET_Store), Store(S), DefiningAccess(DA) {} + StoreExpression(unsigned NumOperands, StoreInst *S, Value *StoredValue, + MemoryAccess *DA) + : BasicExpression(NumOperands, ET_Store), Store(S), + StoredValue(StoredValue), DefiningAccess(DA) {} StoreExpression() = delete; StoreExpression(const StoreExpression &) = delete; StoreExpression &operator=(const StoreExpression &) = delete; @@ -349,10 +352,13 @@ StoreInst *getStoreInst() const { return Store; } MemoryAccess *getDefiningAccess() const { return DefiningAccess; } + Value *getStoredValue() const { return StoredValue; } bool equals(const Expression &Other) const override; hash_code getHashValue() const override { + // This deliberately does not include the stored value we compare it as part + // of equals, and only against other stores. return hash_combine(getOpcode(), getType(), DefiningAccess, hash_combine_range(op_begin(), op_end())); } Index: lib/Transforms/Scalar/NewGVN.cpp =================================================================== --- lib/Transforms/Scalar/NewGVN.cpp +++ lib/Transforms/Scalar/NewGVN.cpp @@ -132,6 +132,8 @@ unsigned ID; // Representative leader. Value *RepLeader = nullptr; + // If this is represented by a store, the value. + Value *RepStoredValue = nullptr; // Defining Expression. const Expression *DefiningExpr = nullptr; // Actual members of this class. @@ -389,7 +391,13 @@ } bool StoreExpression::equals(const Expression &Other) const { - return equalsLoadStoreHelper(*this, Other); + bool Result = equalsLoadStoreHelper(*this, Other); + // Make sure that store vs store includes the value operand. + if (Result) + if (const auto *S = dyn_cast(&Other)) + if (getStoredValue() != S->getStoredValue()) + return false; + return Result; } #ifndef NDEBUG @@ -682,7 +690,7 @@ Value *NewGVN::lookupOperandLeader(Value *V, const User *U, const T &B) const { CongruenceClass *CC = ValueToClass.lookup(V); if (CC && (CC != InitialClass)) - return CC->RepLeader; + return CC->RepStoredValue ? CC->RepStoredValue : CC->RepLeader; return V; } @@ -713,8 +721,9 @@ const StoreExpression *NewGVN::createStoreExpression(StoreInst *SI, MemoryAccess *DA, const BasicBlock *B) { - auto *E = - new (ExpressionAllocator) StoreExpression(SI->getNumOperands(), SI, DA); + auto *StoredValueLeader = lookupOperandLeader(SI->getValueOperand(), SI, B); + auto *E = new (ExpressionAllocator) + StoreExpression(SI->getNumOperands(), SI, StoredValueLeader, DA); E->allocateOperands(ArgRecycler, ExpressionAllocator); E->setType(SI->getValueOperand()->getType()); @@ -755,9 +764,10 @@ // Basically, check if the congruence class the store is in is defined by a // store that isn't us, and has the same value. MemorySSA takes care of // ensuring the store has the same memory state as us already. + // The RepStoredValue gets nulled if all the stores disappear in a class, so + // we don't need to check if the class contains a store besides us. if (CC && CC->DefiningExpr && isa(CC->DefiningExpr) && - CC->RepLeader == lookupOperandLeader(SI->getValueOperand(), SI, B) && - hasMemberOtherThanUs(CC, I)) + CC->RepStoredValue == lookupOperandLeader(SI->getValueOperand(), SI, B)) return createStoreExpression(SI, StoreRHS, B); } @@ -1118,6 +1128,10 @@ // reprocess. DEBUG(dbgs() << "Leader change!\n"); ++NumGVNLeaderChanges; + // Destroy the stored value if there are no more stores to represent it. + if (OldClass->RepStoredValue != nullptr && OldClass->StoreCount == 0) + OldClass->RepStoredValue = nullptr; + // We don't need to sort members if there is only 1, and we don't care about // sorting the initial class because everything either gets out of it or is // unreachable. @@ -1172,7 +1186,8 @@ NewClass->RepLeader = CE->getConstantValue(); } else if (const auto *SE = dyn_cast(E)) { StoreInst *SI = SE->getStoreInst(); - NewClass->RepLeader = + NewClass->RepLeader = SI; + NewClass->RepStoredValue = lookupOperandLeader(SI->getValueOperand(), SI, SI->getParent()); } else { NewClass->RepLeader = I; @@ -1183,7 +1198,10 @@ EClass = NewClass; DEBUG(dbgs() << "Created new congruence class for " << *I << " using expression " << *E << " at " << NewClass->ID - << " and leader " << *(NewClass->RepLeader) << "\n"); + << " and leader " << *(NewClass->RepLeader)); + if (NewClass->RepStoredValue) + DEBUG(dbgs() << " and stored value " << *(NewClass->RepStoredValue)); + DEBUG(dbgs() << "\n"); DEBUG(dbgs() << "Hash value was " << E->getHashValue() << "\n"); } else { EClass = lookupResult.first->second; @@ -1221,27 +1239,6 @@ } markMemoryUsersTouched(MA); } - } else if (auto *SI = dyn_cast(I)) { - // There is, sadly, one complicating thing for stores. Stores do not - // produce values, only consume them. However, in order to make loads and - // stores value number the same, we ignore the value operand of the store. - // But the value operand will still be the leader of our class, and thus, it - // may change. Because the store is a use, the store will get reprocessed, - // but nothing will change about it, and so nothing above will catch it - // (since the class will not change). In order to make sure everything ends - // up okay, we need to recheck the leader of the class. Since stores of - // different values value number differently due to different memorydefs, we - // are guaranteed the leader is always the same between stores in the same - // class. - DEBUG(dbgs() << "Checking store leader\n"); - auto ProperLeader = - lookupOperandLeader(SI->getValueOperand(), SI, SI->getParent()); - if (EClass->RepLeader != ProperLeader) { - DEBUG(dbgs() << "Store leader changed, fixing\n"); - EClass->RepLeader = ProperLeader; - markLeaderChangeTouched(EClass); - markMemoryUsersTouched(MSSA->getMemoryAccess(SI)); - } } } @@ -1893,7 +1890,15 @@ DomTreeNode *DomNode = DT->getNode(BB); VD.DFSIn = DomNode->getDFSNumIn(); VD.DFSOut = DomNode->getDFSNumOut(); - VD.Val = D; + // If it's a store, use the leader of the value operand. + if (auto *SI = dyn_cast(D)) { + auto Leader = + lookupOperandLeader(SI->getValueOperand(), SI, SI->getParent()); + VD.Val = alwaysAvailable(Leader) ? Leader : SI->getValueOperand(); + } else { + VD.Val = D; + } + // If it's an instruction, use the real local dfs number. if (auto *I = dyn_cast(D)) VD.LocalNum = InstrDFS.lookup(I); @@ -2098,7 +2103,8 @@ // constant or has no equivalences, just replace everything with // it. We then update the congruence class with whatever members // are left. - if (alwaysAvailable(CC->RepLeader)) { + Value *Leader = CC->RepStoredValue ? CC->RepStoredValue : CC->RepLeader; + if (alwaysAvailable(Leader)) { SmallPtrSet MembersLeft; for (auto M : CC->Members) { @@ -2110,15 +2116,14 @@ continue; } - DEBUG(dbgs() << "Found replacement " << *(CC->RepLeader) << " for " - << *Member << "\n"); + DEBUG(dbgs() << "Found replacement " << *(Leader) << " for " << *Member + << "\n"); // Due to equality propagation, these may not always be // instructions, they may be real values. We don't really // care about trying to replace the non-instructions. if (auto *I = dyn_cast(Member)) { - assert(CC->RepLeader != I && - "About to accidentally remove our leader"); - replaceInstruction(I, CC->RepLeader); + assert(Leader != I && "About to accidentally remove our leader"); + replaceInstruction(I, Leader); AnythingReplaced = true; continue; Index: test/Transforms/NewGVN/loadforward.ll =================================================================== --- /dev/null +++ test/Transforms/NewGVN/loadforward.ll @@ -0,0 +1,32 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" + +%rec11 = type { i16, i16, i16 } + +@str = global %rec11 { i16 1, i16 2, i16 3 } + +;; Test that we forward the first store to the second load +define i16 @bazinga() { +; CHECK-LABEL: @bazinga( +; CHECK-NEXT: [[_TMP10:%.*]] = load i16, i16* getelementptr inbounds (%rec11, %rec11* @str, i16 0, i32 1) +; CHECK-NEXT: store i16 [[_TMP10]], i16* getelementptr inbounds (%rec11, %rec11* @str, i16 0, i32 0) +; CHECK-NEXT: [[_TMP15:%.*]] = icmp eq i16 [[_TMP10]], 3 +; CHECK-NEXT: [[_TMP16:%.*]] = select i1 [[_TMP15]], i16 1, i16 0 +; CHECK-NEXT: br label [[BB1:%.*]] +; CHECK: bb1: +; CHECK-NEXT: ret i16 [[_TMP16]] +; + %_tmp9 = getelementptr %rec11, %rec11* @str, i16 0, i32 1 + %_tmp10 = load i16, i16* %_tmp9 + %_tmp12 = getelementptr %rec11, %rec11* @str, i16 0, i32 0 + store i16 %_tmp10, i16* %_tmp12 + %_tmp13 = getelementptr %rec11, %rec11* @str, i16 0, i32 0 + %_tmp14 = load i16, i16* %_tmp13 + %_tmp15 = icmp eq i16 %_tmp14, 3 + %_tmp16 = select i1 %_tmp15, i16 1, i16 0 + br label %bb1 + +bb1: + ret i16 %_tmp16 +} Index: test/Transforms/NewGVN/pr31594.ll =================================================================== --- test/Transforms/NewGVN/pr31594.ll +++ test/Transforms/NewGVN/pr31594.ll @@ -19,6 +19,7 @@ ; CHECK-NEXT: br label [[WHILE_COND]] ; CHECK: while.end: ; CHECK-NEXT: store i8 0, i8* [[FOO]], align 1 +; CHECK-NEXT: [[TMP0:%.*]] = load i8, i8* [[BLAH]], align 1 ; CHECK-NEXT: store i8 0, i8* [[BLAH]], align 1 ; CHECK-NEXT: ret void ; Index: test/Transforms/NewGVN/pr31686.ll =================================================================== --- /dev/null +++ test/Transforms/NewGVN/pr31686.ll @@ -0,0 +1,2016 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s +target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-scei-ps4" + +%struct.ham = type { float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float } +%struct.bar = type { i32 (...)** } +%struct.eggs = type { %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, float, i32, i32, i32, [32 x i8], i32, i32, i32, %struct.spam*, %struct.blam, [8 x i8] } +%struct.bar.0 = type { float, float, float, float } +%struct.spam = type { %struct.ham, [3 x float], [4 x i8] } +%struct.blam = type <{ %struct.eggs.1*, i32, [256 x i16], [4 x i8] }> +%struct.eggs.1 = type opaque +%struct.foo = type { %struct.blam.2, [16 x %struct.widget], [8 x i8], [16 x %struct.bar.3], i32, i32, i32, i32, i32, i32, i32, i32, [32 x %struct.quux*], %struct.eggs.6*, %struct.hoge.10*, %struct.wobble.57*, %struct.quux.89*, %struct.wombat.108*, %struct.barney.130*, %struct.wombat.135*, %struct.zot.137*, %struct.snork.146*, %struct.hoge.168*, %struct.wibble.169*, %struct.wibble.169*, [512 x i8], i32, [1024 x %struct.wibble.169*], i32, [1024 x i32], [256 x i8], i32, [1024 x [256 x i8]], [256 x i8], [256 x i8], [256 x i8], [8 x float], float, i8, i32, i32, i32, i32, [8 x i8], %struct.eggs.251, float, [16 x [256 x i8]], [16 x float], [16 x [256 x i8]], [16 x i32], i32, [1024 x %struct.bar.252], [128 x i8], %struct.bar.253*, %struct.bar.253*, %struct.blam, %struct.blam, %struct.blam, [512 x [32 x i8]], [512 x i32], i32, float, float, [8 x [256 x %struct.bar.254]], [12 x i8], [1024 x %struct.eggs], i32, %struct.pluto.255*, [8 x %struct.quux.256], %struct.blam.258, %struct.snork.260, %struct.spam.270, %struct.pluto.274, %struct.pluto.274, i8, %struct.hoge.275, i32, %struct.eggs.277, i32, %struct.pluto.281, [8 x i8] } +%struct.blam.2 = type { i32 (...)**, i32, [32 x i8], i32, i32, %struct.blam.2*, %struct.blam.2*, %struct.blam.2*, %struct.blam.2*, %struct.barney*, i8*, i32, i32, i32, i32 } +%struct.barney = type <{ %struct.blam.2*, %struct.blam.2*, i8*, %struct.baz*, %struct.baz*, %struct.hoge.275, float, i32, i32, i32, i32, [4 x i8] }> +%struct.baz = type <{ %struct.hoge*, i8, [7 x i8] }> +%struct.hoge = type opaque +%struct.widget = type { i8, i8, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float } +%struct.bar.3 = type { %struct.bar.0, float, [12 x i8] } +%struct.quux = type { %struct.eggs.4, %struct.ham.5* } +%struct.eggs.4 = type { i32 (...)** } +%struct.ham.5 = type opaque +%struct.eggs.6 = type { %struct.blam.2, [64 x i8], %struct.hoge.7*, %struct.bar.8*, %struct.barney.9*, %struct.wobble*, i32, i8, %struct.foo* } +%struct.hoge.7 = type opaque +%struct.bar.8 = type opaque +%struct.barney.9 = type opaque +%struct.wobble = type opaque +%struct.hoge.10 = type <{ %struct.blam.2, [8 x i8], %struct.bar.0, float, float, i8, [3 x i8], float, float, float, float, i32, i8, i8, i8, i8, float, float, i32, i32, i32, i8, [7 x i8], %struct.eggs.11, i8, [7 x i8], %struct.foo.12, i8, [7 x i8], %struct.widget.20, %struct.wibble.23, %struct.baz.24*, i32, [4 x i8], %struct.foo*, %struct.ham.25*, i8, [7 x i8] }> +%struct.eggs.11 = type { %struct.bar.0, %struct.bar.0 } +%struct.foo.12 = type { %struct.foo.13 } +%struct.foo.13 = type { %struct.spam.14 } +%struct.spam.14 = type { %struct.spam.15 } +%struct.spam.15 = type { %struct.quux.16, %struct.wibble.18*, i64 } +%struct.quux.16 = type { %struct.wombat* } +%struct.wombat = type { %struct.wibble*, %struct.wobble.17* } +%struct.wibble = type { %struct.wombat* } +%struct.wobble.17 = type { %struct.wombat*, %struct.wobble.17* } +%struct.wibble.18 = type { %struct.wibble.18*, %struct.wibble.18*, %struct.snork* } +%struct.snork = type <{ %struct.hoge.10*, %struct.pluto*, %struct.blam.19*, %struct.spam.298*, i8, [7 x i8] }> +%struct.pluto = type opaque +%struct.blam.19 = type opaque +%struct.widget.20 = type { %struct.wobble.21*, i32, %struct.blam.22, %struct.blam.22, [4 x i8], %struct.baz } +%struct.wobble.21 = type { i8, %struct.spam.298* } +%struct.blam.22 = type { i32 } +%struct.wibble.23 = type { %struct.spam.298**, i32, %struct.blam.22, %struct.blam.22, [4 x i8], %struct.baz } +%struct.baz.24 = type opaque +%struct.ham.25 = type { %struct.quux.26, i8, %struct.hoge.27*, %struct.hoge.27*, %struct.hoge.27*, %struct.hoge.10*, [4 x i32], [4 x [32 x %struct.hoge.27*]], [4 x [32 x i32]] } +%struct.quux.26 = type { i32 (...)** } +%struct.hoge.27 = type { i32 (...)**, %struct.quux.28*, [64 x i8], %struct.spam.298*, void (i8*, %struct.hoge.27*, %struct.ham*, %struct.bar.0*, i8)*, i8*, %struct.blam.22, i8, i8, i8, i8 } +%struct.quux.28 = type { %struct.ham, %struct.wibble.29*, %struct.snork.30, %struct.spam.298**, %struct.ham.43*, %struct.ham*, i32, i32, i32, float, %struct.snork.44*, i32, [4 x i8], %struct.hoge.50, %struct.eggs.51, %struct.eggs.51, i32, i32, i32, i32, i32, [4 x i8], %struct.barney.52, [64 x i8], i32, %struct.spam.56* } +%struct.wibble.29 = type opaque +%struct.snork.30 = type <{ [16 x %struct.zot], %struct.ham.33, %struct.widget.35*, %struct.foo.37*, %struct.ham.39, %struct.quux.28*, %struct.wobble.41*, %struct.wobble.41*, i32, float, i32, i32, i32, i32, i32, i32, i8, [7 x i8], %struct.quux.42*, [1 x i32], [4 x i8] }> +%struct.zot = type { %struct.snork.30*, %struct.spam.31*, [16 x %struct.blam.32], i32, i32, float, i32, float, float, float, float, float, i32, i32, i32 } +%struct.spam.31 = type <{ i32, i32, i32, i32, float, [16 x i32], float, float, float, float, float, float, float, float, float, float, i8, i8, i8, i8, i8, i8, i8, i8 }> +%struct.blam.32 = type <{ i32, float, float, i8, [3 x i8] }> +%struct.ham.33 = type <{ %struct.foo.34*, i32, [4 x i8] }> +%struct.foo.34 = type <{ [4 x %struct.bar.0], [4 x %struct.bar.0], [4 x %struct.bar.0], [4 x float], i8, [15 x i8] }> +%struct.widget.35 = type <{ %struct.eggs.36*, i32, i32, i32, [4 x i8] }> +%struct.eggs.36 = type { [32 x i8], i32, i32, i32, float, i32, [16 x [32 x i8]], [16 x i32], [8 x i32] } +%struct.foo.37 = type <{ %struct.bar.38*, i32, i32, i32, [4 x i8] }> +%struct.bar.38 = type { i32, [32 x i8], [31 x i8], [20 x [32 x i8]], i32, i32, i32, i32 } +%struct.ham.39 = type <{ %struct.wibble.40*, i32, i32, i32, [4 x i8] }> +%struct.wibble.40 = type { float } +%struct.wobble.41 = type <{ [2 x %struct.bar.38*], %struct.wobble.41*, [2 x float], i32, i32, float, [4 x i8] }> +%struct.quux.42 = type <{ %struct.spam.298*, float, [4 x i8] }> +%struct.ham.43 = type <{ %struct.snork.30*, [8 x %struct.quux.28*], [8 x i32], i32, i32, i32, [4 x i8] }> +%struct.snork.44 = type <{ %struct.spam.45*, i32, [4 x i8] }> +%struct.spam.45 = type <{ [32 x i8], %struct.bar.0, %struct.ham.46*, i8, i8, [6 x i8] }> +%struct.ham.46 = type { i8*, %struct.barney.47, i8*, i32, i32, i32, [12 x i8], %struct.wobble.49 } +%struct.barney.47 = type <{ %struct.quux.48*, i32, i32, i32, [4 x i8] }> +%struct.quux.48 = type { i32 } +%struct.wobble.49 = type <{ %struct.bar.0, [4 x i32], [4 x i32], [4 x i32], i8, i8, [14 x i8] }> +%struct.hoge.50 = type <{ i8**, i32, i32, i32, [4 x i8] }> +%struct.eggs.51 = type <{ %struct.spam.298**, i32, i32, i32, [4 x i8] }> +%struct.barney.52 = type <{ %struct.zot.53**, i32, i32, i32, [4 x i8] }> +%struct.zot.53 = type <{ %struct.bar.0, %struct.bar.0, %struct.pluto.54*, %struct.pluto.54*, i64, i64, i32, [6 x float], i32, i32, [24 x float], i16, i16, i16, i8, i8, i8, i8, [2 x i8] }> +%struct.pluto.54 = type { %struct.eggs.4, %struct.foo.55* } +%struct.foo.55 = type opaque +%struct.spam.56 = type opaque +%struct.wobble.57 = type <{ %struct.blam.2, i32, i32, %struct.wibble.58, %struct.foo*, %struct.ham.78*, %struct.widget.83*, i32, i32, i32, i32, i32, i16, i16, [1024 x %struct.ham.85], [1024 x %struct.ham.78*], [1024 x [128 x i8]], i32, [1024 x %struct.widget.86], i32, [8 x i8], [96 x %struct.spam.87], [96 x [128 x i8]], i32, [96 x [128 x i8]], i32, i32, [96 x [128 x i8]], i32, i32, i32, [96 x i32], [128 x i8], [2048 x %struct.wibble.88], i32, i32, i32, i16, [10 x i8] }> +%struct.wibble.58 = type { %struct.baz.59 } +%struct.baz.59 = type { %struct.spam.60 } +%struct.spam.60 = type { %struct.quux.16, %struct.foo.61**, %struct.foo.61**, %struct.foo.61** } +%struct.foo.61 = type <{ %struct.eggs.62, %struct.ham, %struct.ham, %struct.ham, %struct.ham, %struct.ham, %struct.ham, %struct.bar.0, %struct.bar.0, %struct.bar.0, [4 x %struct.bar.0], [4 x %struct.bar.0], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, [8 x %struct.pluto.68*], [64 x %struct.quux.69*], %struct.spam.298*, %struct.zot.72*, %struct.widget*, [4 x i64], i64, i8*, [16 x %struct.hoge.76], float, float, i32, i32, i32, float, float, float, float, float, float, float, [3 x float], i32, i32, i32, i32, i32, i32, i32, float, float, float, i32, i32, i32, i32, i32, float, float, i32, i32, i32, float, i32, [64 x i32], float, i32, [4 x i32], float, float, float, float, float, float, i32, i32, i32, %struct.hoge.77, i16, [64 x i16], i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, [64 x i8], i8, i8, i8, i8, [6 x i8] }> +%struct.eggs.62 = type { %struct.baz.63, [8 x i8], %struct.blam.64 } +%struct.baz.63 = type { i32 (...)** } +%struct.blam.64 = type <{ i32 (...)**, [8 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, [2 x %struct.ham.65*], [2 x float], %struct.bar.66*, i32, [4 x i8], %struct.wombat.67*, i16, i8, [13 x i8] }> +%struct.ham.65 = type opaque +%struct.bar.66 = type opaque +%struct.wombat.67 = type opaque +%struct.pluto.68 = type opaque +%struct.quux.69 = type <{ i32 (...)**, [8 x i8], %struct.ham, %struct.bar.0, %struct.bar.0, i64, %struct.spam.298*, %struct.spam.298*, %struct.wobble.70*, %struct.foo.61*, %struct.quux.71*, i32, i32, i32, float, i16, i16, i16, i8, i8, i8, i8, [6 x i8] }> +%struct.wobble.70 = type <{ %struct.bar.0, %struct.bar.0, i64, float, i32, i16, i16, i8, i8, [10 x i8] }> +%struct.quux.71 = type opaque +%struct.zot.72 = type <{ %struct.hoge.73, i16, i16, i16, i16, i8, [7 x i8] }> +%struct.hoge.73 = type { %struct.blam.74, %struct.blam.74, %struct.blam.74 } +%struct.blam.74 = type { %struct.foo.75 } +%struct.foo.75 = type { <4 x float> } +%struct.hoge.76 = type { i32 } +%struct.hoge.77 = type { i32 } +%struct.ham.78 = type { %struct.hoge.27, %struct.blam.79, %struct.bar.82, [4 x i8], %struct.bar.0 } +%struct.blam.79 = type { %struct.widget.80 } +%struct.widget.80 = type { %struct.wibble.81**, i64, i64 } +%struct.wibble.81 = type { i32 (...)** } +%struct.bar.82 = type <{ i32 (...)**, i32, [8 x i32], [256 x i8], i32, i32 }> +%struct.widget.83 = type { %struct.eggs.4, %struct.baz.84* } +%struct.baz.84 = type opaque +%struct.ham.85 = type { i32, i32, i32, i32, i32, i8*, i8*, i8*, float, float, float, float, i32, [128 x i8], [128 x i8], [128 x i8] } +%struct.widget.86 = type { i32, i32, i32, i32, float, float, float, float, [128 x i8], [128 x i8], [128 x i8] } +%struct.spam.87 = type <{ %struct.bar.0, [32 x i8], i32, float, i32, i32, i8, [15 x i8] }> +%struct.wibble.88 = type { i32, [128 x i8] } +%struct.quux.89 = type <{ %struct.blam.2, i32, float, float, i32, i32, float, float, [12 x i8], %struct.bar.0, float, float, i32, i32, float, i32, float, i32, float, float, [8 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, float, float, float, float, float, float, float, float, %struct.bar.0, float, i32, i32, i32, float, [12 x i8], %struct.bar.0, %struct.bar.0, float, float, %struct.wombat.90, [2 x [255 x %struct.eggs.92*]], i32, i32, i32, i32, i32, float, [8 x i8], %struct.bar.0, float, float, float, float, i8, [7 x i8], %struct.baz.93, float, i32, [8 x i32], [8 x i32], i32, i32, i32, i32, i32, float, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, float, float, float, [12 x i8], %struct.eggs.95, %struct.bar.0, float, float, float, i32, i32, i32, i32, [4 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, float, float, float, float, float, float, float, float, float, float, [8 x i8], %struct.ham, i8, [3 x i8], i32, [32 x i8], [32 x i8], float, float, i32, [12 x i8], %struct.eggs.96, %struct.hoge.97, %struct.ham.98, %struct.spam.298*, %struct.baz.99, i32, [12 x i8], %struct.bar.0, %struct.bar.0, float, float, [8 x i8], %struct.wobble.101, %struct.wombat.102, %struct.snork.103, i32, i32, i32, [4 x i8], %struct.spam.105, i32, [4 x i8], [8 x %struct.spam.107], i32, i32, i32, i32, i32, i32, %struct.foo*, void ()*, [256 x i8], i32, i32, float, float, float, float, i32, i32, i32, [4 x i8] }> +%struct.wombat.90 = type { %struct.bar.91**, i64, i64 } +%struct.bar.91 = type opaque +%struct.eggs.92 = type opaque +%struct.baz.93 = type <{ float*, float, float, %struct.spam.94*, float, float, i8, [7 x i8] }> +%struct.spam.94 = type { i32 (...)** } +%struct.eggs.95 = type { float, float, float, float, %struct.bar.0, %struct.bar.0, float, [12 x i8] } +%struct.eggs.96 = type { %struct.bar.0, %struct.bar.0, float, float, [8 x i8] } +%struct.hoge.97 = type { [6 x %struct.bar.0], %struct.bar.0, float, float, [8 x i8], [5 x %struct.bar.0], [5 x %struct.bar.0] } +%struct.ham.98 = type { float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float } +%struct.baz.99 = type { %struct.blam.100**, i64, i64 } +%struct.blam.100 = type { i32, i32, [128 x i8], [256 x i8] } +%struct.wobble.101 = type { [256 x i8], i8*, float, [4 x i8], %struct.bar.0, %struct.bar.0 } +%struct.wombat.102 = type { i32, float, float, float, float, float, [8 x i8], %struct.bar.0, i32, [12 x i8], %struct.bar.0, i32, [12 x i8] } +%struct.snork.103 = type { i32 (...)**, [8 x i8], [64 x %struct.eggs.104], [128 x i8] } +%struct.eggs.104 = type { [64 x i8], i32, [16 x i32], [64 x i8], [32 x float], i32, [8 x i8], [8 x %struct.bar.0] } +%struct.spam.105 = type { i32 (...)**, [128 x %struct.barney.106], [128 x i8] } +%struct.barney.106 = type { i32, [64 x i8], i64, i64, i64, i64 } +%struct.spam.107 = type { %struct.bar.0, %struct.bar.0, i32, i32, i32, [4 x i8] } +%struct.wombat.108 = type { %struct.blam.2, i32, %struct.foo*, [16 x %struct.quux.109], [64 x %struct.blam.111], %struct.barney.112*, %struct.bar.113*, %struct.wombat.114* } +%struct.quux.109 = type { %struct.wombat.108*, %struct.zot.110*, [32 x i8], [32 x i8] } +%struct.zot.110 = type { i32 (...)**, [8 x [32 x i8]], [8 x i32], [8 x float], [8 x i8], [8 x %struct.bar.0], [8 x %struct.ham.98], i32, i32, i32, float, i8*, [8 x i8], %struct.bar.0, %struct.ham.98, %struct.quux.109*, [8 x i8] } +%struct.blam.111 = type { [32 x i8], i32, float } +%struct.barney.112 = type opaque +%struct.bar.113 = type opaque +%struct.wombat.114 = type { i32, i32, i32, %struct.spam.115*, [9 x i32], [4 x i8], %struct.bar.116, i32, i32, float, i32, [4 x %struct.ham.78*], [512 x i32], [512 x %struct.widget.117*], [512 x %struct.widget.117*] } +%struct.spam.115 = type <{ i16, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, float, float, [12 x i8], %struct.ham, %struct.foo.61*, [8 x i8], %struct.ham, i32, i32, i32, i32, i32, i32, float, float, %struct.bar.0, %struct.bar.0, float, float, float, float, float, [12 x i8], %struct.ham, float, float, float, float, float, float, i32, float, %struct.bar.0, float, float, [8 x i8], %struct.ham, i32, i32, [8 x i8], %struct.bar.0, %struct.bar.0, float, [12 x i8], %struct.ham, i32, [12 x i8] }> +%struct.bar.116 = type { i32, i32, [8 x i8], %struct.bar.0, %struct.bar.0, [2 x %struct.bar.0], [2 x %struct.bar.0], [2 x %struct.bar.0], %struct.bar.0, %struct.bar.0, float, float, [8 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, float, float, float, [4 x i8], [2 x %struct.bar.0], [2 x %struct.bar.0], [2 x %struct.ham], i32, [12 x i8], %struct.bar.0, float, [12 x i8], %struct.bar.0, float, [12 x i8] } +%struct.widget.117 = type <{ %struct.blam.118, %struct.bar.0, %struct.bar.0, %struct.spam.298*, i32, i32, i32, i32, float, i16, i16, i16, i8, i8, [12 x i8] }> +%struct.blam.118 = type { %struct.ham, %struct.pluto.54*, %struct.pluto.54*, %struct.barney.119*, i64, i64, i64 } +%struct.barney.119 = type { %struct.widget.120, %struct.wombat.125, %struct.zot.126, [12 x i8], %struct.eggs.127, i8*, [8 x i8] } +%struct.widget.120 = type { [32 x %struct.blam.121*], [4 x %struct.eggs.123*], [4 x %struct.ham.46*], %struct.barney.119* } +%struct.blam.121 = type { %struct.eggs.4, %struct.zot.122* } +%struct.zot.122 = type opaque +%struct.eggs.123 = type { %struct.eggs.4, %struct.wombat.124* } +%struct.wombat.124 = type opaque +%struct.wombat.125 = type { %struct.barney.119*, %struct.bar.0*, [4 x i64], [4 x i64], [4 x i64], [4 x i32], [4 x i32], i8 } +%struct.zot.126 = type { i32, i32, i32, [32 x i8], [32 x i8], [4 x [32 x i8]], [32 x [32 x i8]], [16 x i8], [4 x i8], i8, [32 x i8] } +%struct.eggs.127 = type <{ %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, [4 x %struct.bar.0], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, [5 x %struct.bar.0], [5 x %struct.bar.0], [5 x %struct.bar.0], [5 x %struct.bar.0], [5 x %struct.bar.0], %struct.bar.0, %struct.bar.0, [2 x %struct.bar.0], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, [4 x %struct.bar.0], [4 x %struct.bar.0], [4 x %struct.bar.0], [4 x %struct.bar.0], %struct.bar.0, %struct.bar.0, [16 x %struct.bar.0], [7 x %struct.bar.0], %struct.ham.46*, %struct.ham.46*, %struct.ham.46*, [4 x %struct.ham.46*], %struct.wombat.128*, %struct.blam.129*, float, float, [5 x float], float, float, [16 x i8], [16 x i8], [16 x i8], [16 x i8], [16 x i8], [16 x i8], [16 x i8], [16 x i8], i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, [2 x i8], i8, i8, i8, i8, i8 }> +%struct.wombat.128 = type opaque +%struct.blam.129 = type { [4 x i32] } +%struct.barney.130 = type { %struct.blam.2, [8 x i8], %struct.eggs.131, [8192 x %struct.ham.78*], [64 x [64 x i8]], [64 x i32], [64 x i32], [64 x i32], [64 x [5 x i32]], [64 x i32], i32, [6 x i32], i32, i8, %struct.wibble.132*, %struct.spam.133, %struct.spam.133, %struct.foo*, [8 x i8] } +%struct.eggs.131 = type { [128 x [128 x i32]], [128 x i32], [128 x %struct.ham], [128 x i32], [128 x %struct.ham], [128 x %struct.bar.0] } +%struct.wibble.132 = type opaque +%struct.spam.133 = type { i32, [12 x i8], [128 x %struct.ham.134] } +%struct.ham.134 = type { i32, i32, [8 x i8], %struct.bar.0 } +%struct.wombat.135 = type { %struct.blam.2, i32, i32, i32, i32, %struct.foo*, %struct.widget.117*, i32, i32, [128 x %struct.ham.78*], i32, [4 x i8], [32 x %struct.foo.136], i32, i32, i32, i32, [128 x i32] } +%struct.foo.136 = type <{ %struct.widget.117*, i32, i32, i32, [4 x i8] }> +%struct.zot.137 = type { %struct.blam.2, i32, float, float, float, i32, %struct.widget.138, [256 x %struct.wobble.142], float, i32, i32, [8 x [128 x i8]], [128 x i8], [128 x i8], i32, %struct.bar.143*, %struct.hoge.144*, i32, i32, i32, i32, float, float, i32, i32, i32, i32, float, i32, i32, i32, i32, float, i32, float, float, float, i32, i32, i32, i32, i32, i32, i32, %struct.foo*, %struct.foo.145*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, i32, i32, i32, float, i32, i32, i32, [128 x i8], i32, void (%struct.zot.137*)*, [8 x %struct.hoge.27*], i32, [32 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, i32, [2 x %struct.wibble.169*], float, [128 x i32], i32, i32, i32, i32, float, float, i32, [8 x i8] } +%struct.widget.138 = type { %struct.quux.139 } +%struct.quux.139 = type { %struct.blam.140 } +%struct.blam.140 = type { %struct.quux.16, %struct.wobble.141**, %struct.wobble.141**, %struct.wobble.141** } +%struct.wobble.141 = type { i32 (...)**, i32, [64 x i8], float, float, [12 x i8], [6 x %struct.ham.46], i8, [32 x %struct.wobble.142*], i32, %struct.foo*, [8 x i8] } +%struct.wobble.142 = type { i32 (...)**, i32, i32, i32, float, [8 x i8], %struct.bar.0, [64 x i8], i32, i32, i32, i32 } +%struct.bar.143 = type opaque +%struct.hoge.144 = type opaque +%struct.foo.145 = type opaque +%struct.snork.146 = type { %struct.ham.147, %struct.baz.151*, %struct.blam.159*, i32 (i32, i8*, i8*)*, i32 (i32, i8*, i8*)*, [2 x void (i32, i8**, i8*)*], [32 x [512 x %struct.widget.160]], [32 x i32], [32 x i16], [32 x [16 x %struct.blam.159*]], i32, [2048 x [64 x i8]], [2048 x [64 x i8]], [32 x i32], [2560 x %struct.blam.159], [32 x i32], [5120 x [2 x i8*]], [32 x [6 x [256 x i8]]], [32 x i8], [32 x %struct.blam.159*], i32, i32, i8*, i32, i32, [32 x i8*], i32, i32, i32, i32, i32, [32 x [32 x i8]], [32 x i8*], [32 x i16], %struct.widget.161*, i32, [4096 x i32], [4096 x i32], [4096 x [64 x i8]], %struct.baz* } +%struct.ham.147 = type { %struct.zot.148 } +%struct.zot.148 = type { %struct.baz.149 } +%struct.baz.149 = type { %struct.quux.16, %struct.snork.150, i64, i64 } +%struct.snork.150 = type { i8*, [8 x i8] } +%struct.baz.151 = type { i8*, [2560 x i32], %struct.baz.152*, i32, i8*, [32 x [256 x i8]], [32 x [32 x i8]], i32, i32*, i32*, i8*, i32, i32, i32, i32, i32, %struct.snork.146*, %struct.wibble.153*, [256 x %struct.wibble.153], %struct.spam.154*, i32, i32, i32, i32, i32, [4 x i32], [4 x i32], [4 x i32], [4 x [128 x i8]], [4 x [128 x i8]], [4 x i32], [32 x [256 x i8]], [32 x i32], [32 x float], i8*, %struct.spam.155*, i8, i8, %struct.snork.156*, %struct.wobble.157*, %struct.widget.158*, i32, i32, i32, i32, i32, [32 x i32], i32, [32 x i32], [32 x i32] } +%struct.baz.152 = type { i64, [64 x i8], i64, i64, i64, i32, i64 } +%struct.wibble.153 = type { [4 x i8] } +%struct.spam.154 = type <{ i32, i16, i8, i8, [16 x i8], i16, [2 x i8] }> +%struct.spam.155 = type { [32 x i8], i32, i32, [64 x i16], [64 x [32 x i8]], [64 x i32], [64 x i8], [64 x [8 x i32]] } +%struct.snork.156 = type <{ i32, i32, i32, i16, [16 x i16], [32 x i8], i8, i8 }> +%struct.wobble.157 = type { [16 x [32 x i8]] } +%struct.widget.158 = type { i32, i32, i32, [36 x i8] } +%struct.blam.159 = type <{ i32, i32, i32, i32, i16, [2 x i8] }> +%struct.widget.160 = type { [32 x i8], i16, i32, [8 x i32], i32, i8, i8 } +%struct.widget.161 = type { i16, i8, i32, i8*, i8*, i8*, i8*, i8*, i8*, i16*, [2 x i16], i8*, i8*, i8*, %struct.zot.162, i8*, [6 x i8], i8, i8*, i8*, i32, i32, i16, i16, %struct.blam.163, i32, i8*, i32 (i8*)*, i32 (i8*, i8*, i32)*, void (%struct.quux.164*, i8*, %struct.quux.164*, i32)*, i32 (i8*, i8*, i32)*, %struct.blam.163, i8*, i32, [3 x i8], [1 x i8], %struct.blam.163, i32, %struct.quux.164, %struct.blam.165*, %struct.bar.166*, i32, i32, %struct.barney.167 } +%struct.zot.162 = type <{ i64, i16, i16, [4 x i8] }> +%struct.blam.163 = type { i8*, i32 } +%struct.quux.164 = type { i64, %struct.zot.162 } +%struct.blam.165 = type opaque +%struct.bar.166 = type opaque +%struct.barney.167 = type { i64, [120 x i8] } +%struct.hoge.168 = type { %struct.blam.2, [1024 x i8] } +%struct.wibble.169 = type <{ %struct.blam.2, %struct.wombat.170, %struct.eggs.173*, i32, float, float, float, [16 x %struct.widget], i32, float, float, i32, float, i32, i32, i32, i8, i8, [6 x i8], %struct.wobble.174*, i8, [7 x i8], %struct.foo.61*, [8 x i8], %struct.bar.0, %struct.ham.78*, float, i32, %struct.bar.0, i8, [3 x i8], i32, %struct.spam.298*, i32, float, float, [4 x i8], %struct.bar.0, %struct.ham, i32, [4 x i8], %struct.widget.177, %struct.quux.183*, i8, [7 x i8], %struct.hoge.185, %struct.bar.0, i32, [12 x i8], [3 x %struct.bar.0], float, float, float, [4 x i8], %struct.bar.0, i32, i32, i32, i32, i32, [12 x i8], %struct.ham, %struct.ham, %struct.ham, i8, [15 x i8], %struct.ham, float, float, [64 x i8], [64 x i32], [9 x i8], [3 x i8], float, float, [64 x i8], [64 x i8], [64 x i8], [64 x i8], float, i32, i32, i32, i8, i8, [2 x i8], float, i32, i32, i32, float, float, [8 x i8], %struct.bar.0, i32, float, float, float, float, float, [8 x i8], %struct.ham, %struct.bar.0, %struct.bar.0, float, float, %struct.snork.186, %struct.barney.193*, i32, %struct.wibble.217, float, [4 x i8], %struct.spam.298*, %struct.spam.298*, %struct.zot.198, [64 x i8], [64 x i8], i32, i32, i32, i32, i8, [256 x i8], [256 x i8], [3 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], i32, [4 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, float, float, float, float, i8, i8, [2 x i8], i32, %struct.blam.205*, %struct.wibble.207*, %struct.hoge.208, %struct.blam*, i32, [4 x i8], %struct.ham*, %struct.ham, %struct.bar.0, float, float, float, [32 x i8], [128 x i8], i32, i32, [3 x %struct.wibble.217], i32, [4 x i32], [4 x i8], %struct.eggs.209*, %struct.baz.210, [4 x i8], %struct.bar.212*, %struct.zot.216*, [16 x [256 x i8]], [16 x float], [16 x [256 x i8]], [16 x i32], i8, [6 x [32 x i8]], [7 x i8], %struct.foo.61*, %struct.foo.61*, [8 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, i8, i8, i8, i8, i8, i8, i8, i8, float, float, float, float, float, float, float, [2 x float], float, i32, i32, i16, i16, i16, i16, i8, i8, i8, i8, i8, i8, [2 x i8], i8, i8, [2 x i8], i32, i32, %struct.wibble.217, float, float, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, i32, i32, i32, i32, float, float, float, i16, i8, i8, i8, [3 x i8], i32, i32, float, %struct.ham.218, i8, [3 x i8], %struct.ham.221, [4 x i8], [4 x %struct.barney.222*], i32, i32, %struct.blam.227*, %struct.zot.228*, %struct.widget.245*, %struct.wombat.247*, %struct.wobble.248*, i32, [4 x i8], %struct.widget.117*, %struct.widget.117*, i8, i8, i8, i8, i32, i32, i32, i32, [4 x i8], %struct.barney.249*, %struct.spam.250*, i8, [15 x i8], %struct.bar.0, %struct.foo*, [8 x i8], %struct.eggs.11, %struct.eggs.11, %struct.eggs.11*, i8, [7 x i8] }> +%struct.wombat.170 = type { %struct.bar.171 } +%struct.bar.171 = type { %struct.widget.172**, i64, i64 } +%struct.widget.172 = type { i32 (...)** } +%struct.eggs.173 = type { i32, [1024 x %struct.wibble.169*] } +%struct.wobble.174 = type { %struct.spam.298*, %struct.foo.61*, i8, i32, [16 x i8], [8 x i8], [16 x %struct.bar.0], i8, i8, float, float, float, float, [12 x i8], %struct.bar.0, float, float, float, float, float, float, float, [4 x i8], %struct.bar.0, %struct.bar.0, float, float, float, [16 x %struct.widget], i32, %struct.bar.175*, i32, i32, %struct.spam.298**, i32, i8, i8, float, float, [16 x %struct.widget.176], %struct.foo* } +%struct.bar.175 = type <{ %struct.foo.61*, %struct.spam.298*, %struct.spam.298*, %struct.ham.221, float, i32, [12 x i8], %struct.bar.0, float, float, %struct.ham.221, i32, float, i8, i8, [10 x i8] }> +%struct.widget.176 = type { i8, i8, i32, i32, i32, i32, i32 } +%struct.widget.177 = type { %struct.quux.178*, i32, i32, double, double, %struct.bar.180* } +%struct.quux.178 = type { [10 x %struct.quux.179], %struct.hoge.27*, [8 x i8] } +%struct.quux.179 = type { i8, [15 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, float, [12 x i8] } +%struct.bar.180 = type { [32 x %struct.barney.181*] } +%struct.barney.181 = type { %struct.ham, %struct.snork.182 } +%struct.snork.182 = type { float, float, float, float, %struct.hoge.27*, %struct.snork.182** } +%struct.quux.183 = type { i8, i32, [8 x i8], [32 x %struct.pluto.184] } +%struct.pluto.184 = type { float, float, i8, i8, [6 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.ham, %struct.ham, %struct.ham, %struct.ham, float, float, %struct.ham*, %struct.ham*, i8, i8, i32, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.ham, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.ham } +%struct.hoge.185 = type { [16 x i8], [32 x i8], [32 x i8], float, i64 } +%struct.snork.186 = type { %struct.spam.187 } +%struct.spam.187 = type { %struct.barney.188 } +%struct.barney.188 = type { %struct.zot.189 } +%struct.zot.189 = type { %struct.spam.190 } +%struct.spam.190 = type { %struct.wombat.191 } +%struct.wombat.191 = type { %struct.quux.16, %struct.blam.192*, i64 } +%struct.blam.192 = type opaque +%struct.barney.193 = type { %struct.ham.98, %struct.ham.98, float, i32, i32, %struct.quux.194 } +%struct.quux.194 = type { %struct.blam.195 } +%struct.blam.195 = type { %struct.wobble.196 } +%struct.wobble.196 = type { %struct.quux.16, %struct.barney.197**, %struct.barney.197**, %struct.barney.197** } +%struct.barney.197 = type <{ %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.ham*, %struct.ham*, %struct.spam.298*, float, i8, i8, [2 x i8] }> +%struct.zot.198 = type <{ %struct.wombat.199, i32, [4 x i8] }> +%struct.wombat.199 = type { %struct.blam.200*, i64, i64 } +%struct.blam.200 = type { i32, %struct.eggs.201* } +%struct.eggs.201 = type { i32 (...)**, %struct.blam.202, %struct.bar.204* } +%struct.blam.202 = type { i32, %struct.blam.203, %struct.blam.203 } +%struct.blam.203 = type { float } +%struct.bar.204 = type { i8*, void (%struct.bar.204*)* } +%struct.blam.205 = type { %struct.baz.151*, %struct.wibble.169*, [64 x i8], [256 x i8], i32, i32, i32, i8*, i64, i8, i32, i32, [16 x %struct.pluto.206], i8, [128 x i8], %struct.foo* } +%struct.pluto.206 = type { i8, i16, %struct.spam.298*, %struct.bar.0, %struct.bar.0 } +%struct.wibble.207 = type opaque +%struct.hoge.208 = type { i32, float, float, i32, i32, i32, i32, float } +%struct.eggs.209 = type { float, float, float, %struct.ham*, [8 x i8], %struct.ham } +%struct.baz.210 = type { %struct.hoge.211, %struct.hoge.211, i32 } +%struct.hoge.211 = type { float, float, float, float, float, float, float, float, float } +%struct.bar.212 = type { %struct.bar.213, %struct.spam.214, %struct.spam.215, %struct.wibble.217, [4 x i8], %struct.blam.258 } +%struct.bar.213 = type { i32, float, [8 x i8], %struct.bar.0 } +%struct.spam.214 = type { [8 x %struct.spam.298*], [8 x %struct.spam.298*], [8 x %struct.spam.298*], [8 x %struct.spam.298*], i32, i32, i32, i32 } +%struct.spam.215 = type { i32, %struct.wibble.217 } +%struct.zot.216 = type { [32 x [32 x float]], float, [12 x i8], [256 x %struct.ham.46] } +%struct.wibble.217 = type <{ float, float, float, float, i8, [3 x i8] }> +%struct.ham.218 = type { i32, float, float, i32, %struct.widget.219 } +%struct.widget.219 = type { %struct.pluto.220 } +%struct.pluto.220 = type { i32 } +%struct.ham.221 = type { i32 } +%struct.barney.222 = type { i32 (...)**, i32, %struct.barney.223*, %struct.ham.225*, %struct.foo* } +%struct.barney.223 = type <{ %struct.eggs.224, [8 x i8], [50 x %struct.blam.74], [50 x %struct.blam.74], [50 x %struct.blam.74], %struct.blam.74, %struct.blam.74, [150 x %struct.ham], i32, i32, i8, [3 x i8], float, float, float, i32, i32, float, i32, %struct.wibble.169*, %struct.wibble.169*, [256 x i8], [256 x i8], [8 x i8], %struct.bar.0, float, float, i32, [4 x i8], %struct.hoge.27*, [50 x %struct.foo.61*], [50 x i32], %struct.foo*, i8, [7 x i8] }> +%struct.eggs.224 = type { i32 (...)** } +%struct.ham.225 = type { %struct.wibble.226, [7 x i8] } +%struct.wibble.226 = type <{ %struct.eggs.224, [8 x i8], [50 x %struct.blam.74], [50 x %struct.blam.74], [50 x %struct.blam.74], %struct.blam.74, %struct.blam.74, [150 x %struct.ham], i32, i32, i8, [3 x i8], float, float, float, i32, i32, float, i32, %struct.wibble.169*, %struct.wibble.169*, [256 x i8], [256 x i8], [8 x i8], %struct.bar.0, float, float, i32, [4 x i8], %struct.hoge.27*, [50 x %struct.foo.61*], [50 x i32], %struct.foo*, i8 }> +%struct.blam.227 = type opaque +%struct.zot.228 = type { %struct.wobble.229, %struct.wibble.169*, %struct.snork.231*, %struct.ham.233*, %struct.eggs.239*, %struct.ham.240*, %struct.snork.241*, %struct.foo.242*, %struct.wibble.243*, %struct.wobble.244* } +%struct.wobble.229 = type <{ i32 (...)**, i32, [64 x i8], [4 x i8], i8*, %struct.zot.230*, i32 }> +%struct.zot.230 = type opaque +%struct.snork.231 = type <{ i32 (...)**, %struct.zot.228*, %struct.baz.232, i32, [4 x i8] }> +%struct.baz.232 = type { i32, float, float, i32, i32, i32, i32, float } +%struct.ham.233 = type { i32 (...)**, %struct.zot.228*, i8, i8, %struct.hoge.234, %struct.zot.236, [8 x i8], %struct.spam.237, %struct.bar.238, %struct.ham, %struct.bar.0, i8, i8, i8, i8, [12 x i8], %struct.bar.0, float, i32, i32, i32, i32, i32, float, float, float, float, i8, i8, i8, float, float, float, %struct.hoge.275, [8 x i8] } +%struct.hoge.234 = type { %struct.snork.235, %struct.snork.235, i32 } +%struct.snork.235 = type <{ float, float, float, float, float, float, float, float, float, float, i8, i8, [2 x i8] }> +%struct.zot.236 = type { i32, %struct.wibble.217 } +%struct.spam.237 = type { i32, float, [8 x i8], %struct.bar.0 } +%struct.bar.238 = type { i32, i32, i32, i32 } +%struct.eggs.239 = type opaque +%struct.ham.240 = type opaque +%struct.snork.241 = type opaque +%struct.foo.242 = type opaque +%struct.wibble.243 = type opaque +%struct.wobble.244 = type opaque +%struct.widget.245 = type { i8, %struct.bar.246, %struct.bar.246, %struct.bar.246, %struct.bar.246, float, float, i8, i8, i32 } +%struct.bar.246 = type { [64 x i8] } +%struct.wombat.247 = type { i8, %struct.bar.246, float, float, float, i32 } +%struct.wobble.248 = type { %struct.bar.246, i32 } +%struct.barney.249 = type opaque +%struct.spam.250 = type opaque +%struct.eggs.251 = type { %struct.bar.0, %struct.bar.0, i32, float, i32, i32, i32, i32, [8 x i8] } +%struct.bar.252 = type { [32 x i8], [256 x i8] } +%struct.bar.253 = type { %struct.foo*, i32, [256 x i8], [256 x i8], [256 x i8], [1024 x i32], i32, i32, i32, i32, i32 } +%struct.bar.254 = type { i32, i32, [128 x i8], [128 x i8], float, i32 } +%struct.pluto.255 = type { %struct.snork.146*, [8 x [256 x i8]], [256 x i8], [256 x i8], i32, %struct.foo*, i8*, i64 } +%struct.quux.256 = type { i32, %struct.eggs.257 } +%struct.eggs.257 = type { i64 } +%struct.blam.258 = type { [33 x %struct.wombat.259], i32, [12 x i8] } +%struct.wombat.259 = type { i32, i32, i32, i32, float, [32 x i8], [12 x i8], %struct.bar.0 } +%struct.snork.260 = type { i32 (...)**, %struct.snork.261, %struct.baz.265* } +%struct.snork.261 = type { %struct.barney.262 } +%struct.barney.262 = type { %struct.bar.263 } +%struct.bar.263 = type { %struct.quux.16, %struct.pluto.264**, %struct.pluto.264**, %struct.pluto.264** } +%struct.pluto.264 = type { i32, i32, [8 x i8], %struct.bar.0, float, [12 x i8], %struct.bar.0, %struct.bar.0, float, float, float, float, %struct.spam, [32 x i8] } +%struct.baz.265 = type { i8**, i32, i32, %struct.blam.266*, %struct.blam.266*, %struct.foo.267, %struct.foo.267 } +%struct.blam.266 = type { i8*, i32 } +%struct.foo.267 = type { %struct.zot.268, %struct.baz.269*, i32, i32, i32, i32, [260 x i32], [260 x i32] } +%struct.zot.268 = type { i8 } +%struct.baz.269 = type opaque +%struct.spam.270 = type { %struct.zot.271 } +%struct.zot.271 = type { %struct.blam.272 } +%struct.blam.272 = type { %struct.quux.16, %struct.wibble.273**, %struct.wibble.273**, %struct.wibble.273** } +%struct.wibble.273 = type { [32 x i8], %struct.bar.0, %struct.bar.0, i32, [12 x i8] } +%struct.pluto.274 = type { [128 x i32], i32, i32, i32, i32 } +%struct.hoge.275 = type { %struct.eggs.4, %struct.ham.276*, [8192 x i8] } +%struct.ham.276 = type opaque +%struct.eggs.277 = type { %struct.baz.278 } +%struct.baz.278 = type { %struct.zot.279 } +%struct.zot.279 = type { %struct.widget.280 } +%struct.widget.280 = type { %struct.quux.16, %struct.spam*, %struct.spam*, %struct.spam* } +%struct.pluto.281 = type { %struct.quux.282 } +%struct.quux.282 = type { %struct.wobble.283 } +%struct.wobble.283 = type { %struct.snork.284 } +%struct.snork.284 = type { %struct.bar.285 } +%struct.bar.285 = type { %struct.quux.16, %struct.barney.286*, %struct.barney.286*, %struct.barney.286* } +%struct.barney.286 = type { i32, [256 x i8], [64 x i8], [64 x i8], i32, i32, float, float, %struct.spam.298*, %struct.spam.287*, %struct.spam.298*, %struct.spam.287* } +%struct.spam.287 = type <{ i32, i32, %struct.hoge.288, %struct.spam.291, float, [4 x i8], %struct.bar.294, i32, [4 x i8] }> +%struct.hoge.288 = type { %struct.bar.289 } +%struct.bar.289 = type { %struct.hoge.290 } +%struct.hoge.290 = type { %struct.quux.16, %struct.bar.0*, %struct.bar.0*, %struct.bar.0* } +%struct.spam.291 = type { %struct.wombat.292 } +%struct.wombat.292 = type { %struct.blam.293 } +%struct.blam.293 = type { %struct.quux.16, float*, float*, float* } +%struct.bar.294 = type { %struct.foo.295 } +%struct.foo.295 = type { %struct.bar.296 } +%struct.bar.296 = type { %struct.quux.16, %struct.hoge.297**, %struct.hoge.297**, %struct.hoge.297** } +%struct.hoge.297 = type { [256 x i8], i32, [256 x [256 x i8]], float, float, float, float, %struct.ham.46* } +%struct.spam.298 = type { %struct.snork.299, [14 x i8] } +%struct.snork.299 = type <{ %struct.spam.300, i64, %struct.quux.28*, %struct.ham*, %struct.bar.301*, %struct.bar.306*, %struct.eggs.307*, %struct.hoge.309*, %struct.blam.310*, %struct.blam.311*, %struct.ham.312*, %struct.wibble.313*, %struct.wibble.314*, %struct.wibble.315*, %struct.spam.287*, %struct.foo.316*, %struct.eggs.317*, %struct.ham.318*, %struct.ham*, i8*, float, float, %struct.barney.320, i32, i32, i32, i16 }> +%struct.spam.300 = type { %struct.bar.0, %struct.bar.0, %struct.bar.0 } +%struct.bar.301 = type { %struct.wibble.302*, i32, i32, i32, %struct.blam.303 } +%struct.wibble.302 = type <{ [64 x i8], i8*, i32, [4 x i8] }> +%struct.blam.303 = type { %struct.spam.304, %struct.zot.305*, i32, i32, i32, i32, [260 x i32], [260 x i32] } +%struct.spam.304 = type { i8 } +%struct.zot.305 = type opaque +%struct.bar.306 = type <{ %struct.ham.46, %struct.ham.46, %struct.ham.46, i32, [12 x i8] }> +%struct.eggs.307 = type { i32 (...)**, i32, [4 x i8], %struct.bar.0, %struct.pluto.308, i8, float, float, [8 x i8] } +%struct.pluto.308 = type <{ float, float, float, float, float, float, i8, [3 x i8] }> +%struct.hoge.309 = type { i32, i32, i8*, i8**, i8, %struct.ham*, %struct.ham*, %struct.ham*, %struct.spam.298*, %struct.spam.298** } +%struct.blam.310 = type <{ %struct.bar.0, %struct.spam.298*, %struct.spam.298*, %struct.widget.117*, float, i8, i8, [2 x i8] }> +%struct.blam.311 = type { i32, i32, [2 x float], [2 x float], [2 x float] } +%struct.ham.312 = type { i32 (...)**, [32 x i8], i32, i32, i32, float, float, float } +%struct.wibble.313 = type { %struct.bar.0, %struct.ham.46*, %struct.ham.46*, %struct.ham.46*, %struct.ham.46*, [2 x float], float, float, float, float, float, i32, i8, i8, i8, float, float, float, [64 x i8], [64 x i8], %struct.blam.121*, %struct.blam.121*, i32, %struct.spam.298*, %struct.eggs.11, %struct.bar.0 } +%struct.wibble.314 = type { %struct.ham.46*, %struct.ham.46*, %struct.ham.46*, %struct.ham.46*, %struct.ham.46*, %struct.ham.46* } +%struct.wibble.315 = type { [64 x i8], [64 x i8], i32, i32 } +%struct.foo.316 = type { %struct.bar.0*, i32, float, i32, i16, i8, i8 } +%struct.eggs.317 = type { i32, i8, i32, [3 x float], i32, [2 x i32], i8* } +%struct.ham.318 = type <{ %struct.quux.319, i32, [12 x i8] }> +%struct.quux.319 = type { i8, i8, [6 x i8], i16*, %struct.bar.0*, [16 x i8], [8 x i8], %struct.bar.0 } +%struct.barney.320 = type { i32 } +%struct.foo.321 = type <{ %struct.bar, %struct.widget.322*, %struct.bar.338, [4 x i8], %struct.wobble.339*, %struct.quux.380*, %struct.ham.387*, %struct.zot.393*, %struct.barney.394*, %struct.pluto.395*, %struct.wombat.396*, %struct.ham.397*, %struct.eggs.398*, %struct.barney.399*, %struct.snork.400*, %struct.baz.404*, %struct.barney*, %struct.pluto.421*, %struct.hoge.422*, %struct.snork.486*, %struct.hoge.487*, %struct.hoge.488*, %struct.pluto.489*, %struct.wobble.490*, [3 x %struct.wombat.491*], [2 x %struct.barney.499*], %struct.widget.500*, %struct.zot.502*, %struct.blam*, %struct.blam*, %struct.blam*, %struct.eggs.503, %struct.zot.504*, %struct.ham.506*, [2 x %struct.foo*], [17 x %struct.ham.507*], %struct.baz.508*, %struct.wombat.509*, %struct.baz.510*, %struct.blam.511*, %struct.quux.512*, %struct.snork.513*, %struct.blam.514, %struct.baz.515*, %struct.barney.516*, %struct.baz.152*, i8*, %struct.hoge.517*, %struct.snork.519*, %struct.snork.519*, i32, %struct.blam.22, i32, i32, i32, i32, i32, [4 x i8], i8*, i32, i32, i32, i32, i32, i32, i32, float, i32, i32, i32, i32, i32, i32, i32, i8, [3 x i8], i32, float, float, i32, i32, i32, i32, i8, i8, i8, i8, i32, i32, i64, %struct.pluto.521*, %struct.barney.577*, i32, float, %struct.baz*, %struct.baz*, %struct.blam.22, i32, [2 x i32], [2 x i32], i32, i32, %struct.ham.580*, i8, [7 x i8], %struct.hoge.603*, %struct.spam.604*, [10 x i32], [64 x i8], i8, [3 x i8], i32, [32 x i32], [32 x i32], [32 x [256 x i8]], i32, i32, [256 x i8], i32, i32, i32, i32, i32, float, float, i32, i32, i32, float, [4 x i8], %struct.pluto.255*, %struct.quux.605*, [64 x i8], i8, [3 x i8], i32, i32, [12 x i8] }> +%struct.widget.322 = type <{ %struct.blam.2, [2 x %struct.pluto.323], [8 x i8], %struct.blam.330, [2 x i64], [2 x i32], %struct.spam.336, [8 x i8] }> +%struct.pluto.323 = type { %struct.baz.324 } +%struct.baz.324 = type { %struct.foo.325 } +%struct.foo.325 = type { %struct.pluto.326 } +%struct.pluto.326 = type { %struct.blam.327 } +%struct.blam.327 = type { %struct.wombat.328 } +%struct.wombat.328 = type { %struct.quux.16, %struct.wobble.329*, i64 } +%struct.wobble.329 = type opaque +%struct.blam.330 = type { %struct.wombat.331, %struct.blam.332, %struct.blam.332, float, i32, i32, %struct.bar.335, %struct.bar.335 } +%struct.wombat.331 = type { i32 (...)** } +%struct.blam.332 = type { %struct.zot.333 } +%struct.zot.333 = type { %struct.quux.334 } +%struct.quux.334 = type { %struct.quux.16, %struct.bar.335*, %struct.bar.335*, %struct.bar.335* } +%struct.bar.335 = type { %struct.foo.75 } +%struct.spam.336 = type { [64 x [16 x i8]], [64 x [16 x i8]], [64 x i32], [64 x %struct.widget.337] } +%struct.widget.337 = type { [64 x float] } +%struct.bar.338 = type { float, i32, i32 } +%struct.wobble.339 = type { %struct.barney.340, [256 x i8], i8, i32, [29 x %struct.spam.341], i32 (i8*, i32, i32, %struct.bar.0*, %struct.bar.0*, i32, %struct.ham*, i32, %struct.bar.0*, i32, %struct.bar.0*, i32)*, i32 (i8*, i32, %struct.bar.0*, %struct.bar.0*, %struct.bar.0*, %struct.bar.0*)*, i32 (i8*, i32, i32, %struct.barney.346*, i32*)*, i32 (i8*, i32, i32, %struct.hoge.347*, i32*)*, i8*, i32 (i8*, i8*, i8*, i32, i32, i8*)*, i8*, void (%struct.ham*, i8*)*, i8*, void (i32, i8*, %struct.spam.348*)*, i8*, { <2 x float>, <2 x float> } (i8*, %struct.bar.0*, i32)*, %struct.blam.349*, %struct.blam.349*, i32*, [8 x i32], float, %struct.spam.350*, [8 x i8], [4 x %struct.quux.351], i32, i32, i32, i32, i32, i32, [1024 x %struct.blam.362*], [1024 x %struct.blam.362*], [1024 x %struct.blam.362*], %struct.blam.22, %struct.blam.22, [512 x float], i32, %struct.zot.367, %struct.wobble.370, [1024 x %struct.ham.373], i32, i8, [8 x %struct.ham], i32, %struct.baz*, %struct.baz*, float, float, [5 x float], [12 x i8], %struct.bar.0, %struct.ham, %struct.ham, %struct.bar.0, %struct.hoge.97, %struct.hoge.97, i32, %struct.blam.374*, %struct.wibble.375*, i8, i8, i16, [2560 x i8], i32, float, [12 x i8], [256 x %struct.hoge.376], [2 x %struct.quux.378], [512 x %struct.snork.182*], %struct.pluto.379*, [8 x i8] } +%struct.barney.340 = type { i32 (...)** } +%struct.spam.341 = type { %struct.quux.26* (i8*, i32, %struct.snork.342*)*, i8* } +%struct.snork.342 = type <{ %struct.hoge.343, %struct.ham.344, %struct.ham, %struct.ham, %struct.ham, %struct.ham, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, [4 x %struct.bar.0], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.wibble.345, float, float, float, float, float, float, float, [4 x i8], i8*, i32, i16, i16, i16, i16, i8, [3 x i8], i32, i32, i32, i8, i8, i8, i8, i8, i8, i8, i8, i32, float, i8, [3 x i8], i32, [4 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.bar.0, float, i32, [4 x i32], i32, [4 x i8], %struct.hoge.27*, float*, float*, %struct.snork.182**, float, [8 x float], [8 x i16], float, %struct.ham*, %struct.ham*, %struct.ham*, %struct.quux.26*, %struct.snork.342*, float, i16, i16, i32, i8, [3 x i8] }> +%struct.hoge.343 = type { %struct.hoge.343*, %struct.hoge.343* } +%struct.ham.344 = type { %struct.ham.344*, %struct.ham.344* } +%struct.wibble.345 = type { float, float, float, float } +%struct.barney.346 = type { %struct.bar.0, %struct.bar.0, %struct.bar.0, %struct.ham, i32, i32, i32, i32 } +%struct.hoge.347 = type <{ %struct.bar.0, %struct.bar.0, float, i32, %struct.bar.0*, float*, %struct.bar.0*, float*, i32*, i32*, i8, [7 x i8] }> +%struct.spam.348 = type { i32, i32, i8*, i8* } +%struct.blam.349 = type opaque +%struct.spam.350 = type { i32 (...)** } +%struct.quux.351 = type <{ %struct.bar.352, float, float, %struct.snork.182*, [8 x i8], %struct.ham, i32, i32, i32, i32, i32, i32, i32, [4 x i32], [32 x float], [10 x [4 x i32]], i8, [3 x i8], %struct.ham**, float, [4 x i8], [625 x %struct.blam.353], [625 x %struct.snork.342*], i32, [4 x i8], [192 x %struct.foo.354], i32, [194 x i32], [194 x i32], [194 x i32], [4 x i8], [2500 x %struct.snork.342], [2500 x %struct.barney.358], [2500 x i32], i32, [2500 x float], i32, [8 x i8], [5000 x %struct.eggs.11], [5000 x i8], %struct.hoge.343*, [192 x %struct.widget.359], %struct.zot.360, %struct.zot.360, %struct.hoge.517*, i8*, %struct.hoge.517*, i8*, i8*, [128 x %struct.hoge.27*], %struct.blam.349*, i32, [128 x float], i32, [8 x i8], [512 x %struct.barney.346], i32, [12 x i8], [2 x [512 x %struct.hoge.347]], [2 x i32], i32, [4 x i8], %struct.snork.342*, i32, i32, [1024 x %struct.baz.361], i32, [12 x i8] }> +%struct.bar.352 = type { i32 (...)** } +%struct.blam.353 = type { [64 x i8], [32 x i8], i32, i32, i32, i32, float, float, float, float*, i8, i16, i8, %struct.bar.0, %struct.bar.0, %struct.wibble.345, i32, i8, float, i8, %struct.snork.342*, %struct.snork.182*, %struct.ham*, %struct.ham*, i8, [15 x i8], %struct.ham } +%struct.foo.354 = type { i32, i8, %struct.wibble.355*, %struct.spam.356* } +%struct.wibble.355 = type opaque +%struct.spam.356 = type { [4 x %struct.bar.357], [4 x %struct.bar.357], [3 x %struct.bar.357], [3 x %struct.bar.357], [3 x %struct.bar.357], %struct.bar.357, %struct.bar.357, [4 x %struct.bar.357], [4 x %struct.bar.357], [2 x %struct.bar.357], %struct.ham.46, %struct.ham.46, [16 x %struct.ham.46], [32 x i8], i32, i32, i32, i32, i32, [8 x [8 x i32]], i32, i32, [4 x float], i32, i8, i8, i32, float, float, float, float, float, float, i8, i32, float, [64 x i8], i32, i8, i8, i32, i8, %struct.wibble.355*, [8 x i8] } +%struct.bar.357 = type { [30 x i8], [12 x float] } +%struct.barney.358 = type { %struct.snork.342*, float, float } +%struct.widget.359 = type <{ %struct.ham.344, i32, [4 x i8] }> +%struct.zot.360 = type <{ %struct.hoge.343, i32, [4 x i8] }> +%struct.baz.361 = type { i32, %struct.snork.342* } +%struct.blam.362 = type { [64 x i8], i32, i32, i32, i32, i32, [128 x %struct.spam.356*], [128 x %struct.wibble.355*], [128 x %struct.hoge.27*], [128 x %struct.snork.363*], [128 x i32], %struct.bar.364 } +%struct.snork.363 = type { [4 x float], [3 x float], i8 } +%struct.bar.364 = type { %struct.widget.365, %struct.quux.366*, i32, i32, i32, i32, [260 x i32], [260 x i32] } +%struct.widget.365 = type { %struct.baz } +%struct.quux.366 = type opaque +%struct.zot.367 = type { %struct.hoge.368, %struct.ham.369*, i32, i32, i32, i32, [260 x i32], [260 x i32] } +%struct.hoge.368 = type { %struct.baz } +%struct.ham.369 = type opaque +%struct.wobble.370 = type { %struct.widget.371, %struct.zot.372*, i32, i32, i32, i32, [260 x i32], [260 x i32] } +%struct.widget.371 = type { %struct.baz } +%struct.zot.372 = type opaque +%struct.ham.373 = type { [32 x i8], [128 x i8], i32 } +%struct.blam.374 = type opaque +%struct.wibble.375 = type opaque +%struct.hoge.376 = type { %struct.hoge.377, float, [12 x i8], %struct.blam.353 } +%struct.hoge.377 = type { %struct.hoge.377*, %struct.hoge.377* } +%struct.quux.378 = type <{ %struct.hoge.377, i32, [4 x i8] }> +%struct.pluto.379 = type opaque +%struct.quux.380 = type { %struct.blam.381, %struct.baz*, %struct.wobble.382*, [8 x i8], %struct.ham, %struct.bar.0, %struct.baz.384, %struct.baz.384 } +%struct.blam.381 = type { i32 (...)** } +%struct.wobble.382 = type { %struct.barney.119, i32, i32, i32, i32, i32, float, i32, i32, i32, i32, i32, %struct.ham*, %struct.blam.121*, i8*, [8 x i8], %struct.bar.0, %struct.bar.0, float, i32, [2 x %struct.ham.383*], [2 x %struct.ham.383*], [8 x i8] } +%struct.ham.383 = type { i32, i8* } +%struct.baz.384 = type { %struct.zot.385 } +%struct.zot.385 = type { %struct.zot.386 } +%struct.zot.386 = type { %struct.quux.16, %struct.wobble.382**, %struct.wobble.382**, %struct.wobble.382** } +%struct.ham.387 = type { %struct.snork.388, %struct.baz*, %struct.quux.389*, [8 x i8], %struct.ham, %struct.bar.0, %struct.widget.390, %struct.widget.390 } +%struct.snork.388 = type { i32 (...)** } +%struct.quux.389 = type { %struct.barney.119, i32, i32, i32, i32, i32, float, i32, i32, i32, %struct.ham*, %struct.blam.121*, i8*, %struct.bar.0, %struct.bar.0, float, i32, [2 x %struct.ham.383*], [8 x i8] } +%struct.widget.390 = type { %struct.wombat.391 } +%struct.wombat.391 = type { %struct.baz.392 } +%struct.baz.392 = type { %struct.quux.16, %struct.quux.389**, %struct.quux.389**, %struct.quux.389** } +%struct.zot.393 = type opaque +%struct.barney.394 = type opaque +%struct.pluto.395 = type opaque +%struct.wombat.396 = type opaque +%struct.ham.397 = type opaque +%struct.eggs.398 = type opaque +%struct.barney.399 = type opaque +%struct.snork.400 = type <{ %struct.blam.2, %struct.barney.401, [32768 x i32], [32768 x float], i32, [2 x [32768 x float]], i32, [8 x i8], [2 x [32768 x %struct.bar.0]], [32 x %struct.wibble.402], float, i32, i32, [4 x i8] }> +%struct.barney.401 = type { i32 (...)** } +%struct.wibble.402 = type { %struct.ham, %struct.quux.389*, i8, [7 x i8], [1024 x %struct.baz.403] } +%struct.baz.403 = type { %struct.bar.0, %struct.bar.0, float, float, float, float, float, i32, [8 x i8] } +%struct.baz.404 = type { %struct.baz*, %struct.baz*, %struct.barney.405, %struct.quux.416, i32, i32 } +%struct.barney.405 = type { %struct.foo.406, [4 x i8] } +%struct.foo.406 = type <{ %struct.blam.407, %struct.bar.412, i64, i64, float }> +%struct.blam.407 = type { %struct.ham.408 } +%struct.ham.408 = type { %struct.wombat.409 } +%struct.wombat.409 = type { %struct.wobble.410 } +%struct.wobble.410 = type { %struct.quux.16, %struct.zot.411*, i64 } +%struct.zot.411 = type opaque +%struct.bar.412 = type { %struct.wombat.413 } +%struct.wombat.413 = type { %struct.zot.414 } +%struct.zot.414 = type { %struct.quux.16, %struct.foo.415*, %struct.foo.415*, %struct.foo.415* } +%struct.foo.415 = type opaque +%struct.quux.416 = type { %struct.baz.417 } +%struct.baz.417 = type { %struct.barney.418 } +%struct.barney.418 = type { %struct.zot.419 } +%struct.zot.419 = type { %struct.quux.16, %struct.snork.420*, i64 } +%struct.snork.420 = type opaque +%struct.pluto.421 = type <{ %struct.blam.2, i32, i32, i32, i32, i32, i32, i32, i32, i32, [256 x i8], [256 x i8], [256 x i8], [256 x i8], [4 x i8] }> +%struct.hoge.422 = type { %struct.blam.2, %struct.barney.423, i64, i64, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, %struct.ham.424, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, i32, float, float, float, i32, i32, i32, float, float, float, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, i32, i32, i32, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, float, float, float, float, float, float, float, float, float, i32, i32, i32, float, float, float, i32, i32, float, float, float, float, i32, float, float, float, float, float, i32, i32, i32, i32, i32, i32, float, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [12 x i8], [4 x %struct.ham.98], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, i32, [4 x float], i32, i32, i32, i32, i32, [4 x i8], %struct.bar.0, [2 x %struct.eggs.11], %struct.eggs.11, %struct.ham.98, %struct.ham, %struct.bar.0, i32, [5 x i32], i8, double, float, [4 x i8], %struct.bar.0, %struct.bar.0, float, float, float, float, float, i8, i8, i8, i8, float, [4 x float], i8, i8, i32, i32, float, %struct.blam.425, %struct.blam.426*, %struct.blam.426*, %struct.blam.426*, %struct.blam.426*, %struct.eggs.427*, [8 x i8], %struct.bar.0, %struct.bar.0, [2 x %struct.bar.0], [2 x %struct.bar.0], [2 x %struct.bar.0], %struct.ham.98, float, i32, [8 x i8], [1 x %struct.bar.0], %struct.spam.437, %struct.spam.437, %struct.blam.121*, %struct.blam.121*, %struct.blam.121*, %struct.blam.121*, %struct.blam.121*, %struct.blam.121*, %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, [6 x %struct.pluto.54*], %struct.pluto.54*, [4 x %struct.pluto.54*], [4 x %struct.pluto.54*], %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, %struct.pluto.54*, %struct.hoge.275, %struct.wobble.448, [2 x %struct.wobble.451], %struct.ham.453*, %struct.wobble.454*, %struct.bar.455*, %struct.wobble.456*, %struct.barney.457*, [8 x i8], %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.wibble.458, %struct.eggs.461*, %struct.snork.462, %struct.zot.484, [8 x i8] } +%struct.barney.423 = type { i32 (...)** } +%struct.ham.424 = type { float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float } +%struct.blam.425 = type { i8*, i8*, i8*, i64 } +%struct.blam.426 = type { [64 x i8], i32, [12 x i8], %struct.bar.0, %struct.bar.0, %struct.bar.0, float, float, float, float, %struct.bar.0, %struct.bar.0, %struct.bar.0, float, float, float, float, i32, i32, float, float, float, float, float, float, float, float, float, [4 x i8], %struct.bar.0, float, float, i32, float, float, float, float, float, float, float, float, i32, float, float, float, float, float, i32, float, float, float, float, i32, float, float, float, float, float, float, float, float, float, i32, [12 x i8], %struct.bar.0, float, float, float, float, float, float, i32, float, float, float, float, float, float, float, float, i32, float, [12 x i8], %struct.bar.0, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, float, i32, float, i32, float, i32, float, i32, float, float, float, float, float, i32, float } +%struct.eggs.427 = type { %struct.wombat.428, %struct.snork.435 } +%struct.wombat.428 = type { %struct.wombat.429 } +%struct.wombat.429 = type { %struct.snork.430 } +%struct.snork.430 = type { %struct.bar.431 } +%struct.bar.431 = type { %struct.ham.432 } +%struct.ham.432 = type { %struct.zot.433 } +%struct.zot.433 = type { %struct.quux.16, %struct.hoge.434*, i64 } +%struct.hoge.434 = type opaque +%struct.snork.435 = type { %struct.widget.436*, %struct.widget.436* } +%struct.widget.436 = type opaque +%struct.spam.437 = type { %struct.barney.438, [4 x i8] } +%struct.barney.438 = type <{ %struct.ham.439, %struct.zot.444, i64, i64, float }> +%struct.ham.439 = type { %struct.quux.440 } +%struct.quux.440 = type { %struct.ham.441 } +%struct.ham.441 = type { %struct.barney.442 } +%struct.barney.442 = type { %struct.quux.16, %struct.foo.443*, i64 } +%struct.foo.443 = type opaque +%struct.zot.444 = type { %struct.wobble.445 } +%struct.wobble.445 = type { %struct.bar.446 } +%struct.bar.446 = type { %struct.quux.16, %struct.hoge.447*, %struct.hoge.447*, %struct.hoge.447* } +%struct.hoge.447 = type opaque +%struct.wobble.448 = type { %struct.ham.449 } +%struct.ham.449 = type { %struct.snork.450*, i32, %struct.blam.22, %struct.blam.22, [4 x i8], %struct.baz } +%struct.snork.450 = type { %struct.bar.0, float, float, i32, [4 x i8] } +%struct.wobble.451 = type { %struct.barney.452* } +%struct.barney.452 = type opaque +%struct.ham.453 = type opaque +%struct.wobble.454 = type opaque +%struct.bar.455 = type opaque +%struct.wobble.456 = type opaque +%struct.barney.457 = type opaque +%struct.wibble.458 = type <{ i32 (...)**, i8*, i32, i32, i32, i32, i32, i8, i8, [8 x i8], i8, i8, i8, i8, i8, [13 x i8], %struct.bar.0, %struct.bar.0, [8 x i32], [8 x %struct.blam.121*], %struct.blam.121*, [8 x %struct.pluto.54*], [64 x %struct.blam.121*], [80 x %struct.pluto.54*], %struct.eggs.123*, [8 x i32], i32, i32, i32 (%struct.barney.459*, i32, i32)*, i8, [3 x i8], i32, i32, i32, i32, i8, i8, i8, [9 x i8] }> +%struct.barney.459 = type { %struct.eggs.4, %struct.ham.460* } +%struct.ham.460 = type opaque +%struct.eggs.461 = type opaque +%struct.snork.462 = type { %struct.spam.463, %struct.widget.470, %struct.pluto.475 } +%struct.spam.463 = type { %struct.quux.464 } +%struct.quux.464 = type { %struct.barney.465 } +%struct.barney.465 = type { %struct.barney.466 } +%struct.barney.466 = type { %struct.hoge.467 } +%struct.hoge.467 = type { %struct.foo.468 } +%struct.foo.468 = type { %struct.quux.16, %struct.quux.469*, i64 } +%struct.quux.469 = type opaque +%struct.widget.470 = type { %struct.wombat.471 } +%struct.wombat.471 = type { %struct.snork.472 } +%struct.snork.472 = type { %struct.quux.16, %struct.wombat.473*, %struct.wombat.473*, %struct.wombat.473* } +%struct.wombat.473 = type { %struct.bar.0, i32, i32, i32, i8, i8, i8, [4 x i32], [4 x float], %struct.barney.474 } +%struct.barney.474 = type { [9 x %struct.bar.0] } +%struct.pluto.475 = type { %struct.wobble.476 } +%struct.wobble.476 = type { %struct.wibble.477 } +%struct.wibble.477 = type { %struct.ham.478 } +%struct.ham.478 = type { %struct.wibble, %struct.spam.479**, i64, i64, i64 } +%struct.spam.479 = type <{ %struct.barney.480, %struct.widget.470, void (%struct.ham.147*, %struct.widget.470*)*, %struct.ham.147, %struct.hoge.275, i32, [4 x i8] }> +%struct.barney.480 = type { %struct.baz.481 } +%struct.baz.481 = type { %struct.foo.482 } +%struct.foo.482 = type { %struct.foo.483 } +%struct.foo.483 = type { %struct.wibble, %struct.wombat.473**, i64, i64, i64 } +%struct.zot.484 = type { %struct.hoge.485*, %struct.hoge.485* } +%struct.hoge.485 = type opaque +%struct.snork.486 = type opaque +%struct.hoge.487 = type <{ %struct.blam.2, %struct.baz*, i32, i8, i8, i8, i8, i32, i32, i32, i32, i32, float, i32, [4 x i8] }> +%struct.hoge.488 = type opaque +%struct.pluto.489 = type opaque +%struct.wobble.490 = type opaque +%struct.wombat.491 = type { %struct.blam.2, [1024 x %struct.ham.492], i32, %struct.hoge.495 } +%struct.ham.492 = type <{ %struct.snork.493, %struct.wibble.169*, float, [4 x i8] }> +%struct.snork.493 = type { %struct.hoge.494, %struct.snork.493* } +%struct.hoge.494 = type <{ i32 (...)**, i32 }> +%struct.hoge.495 = type { %struct.wobble.496 } +%struct.wobble.496 = type { %struct.quux.497, %struct.eggs.498, %struct.snork.493*, %struct.snork.493* } +%struct.quux.497 = type { i32 (...)** } +%struct.eggs.498 = type { %struct.snork.493 } +%struct.barney.499 = type <{ %struct.blam.2, i32, [4 x i8] }> +%struct.widget.500 = type { %struct.blam.2, [1024 x %struct.widget.501], i32, %struct.hoge.495 } +%struct.widget.501 = type { %struct.snork.493, float, %struct.wibble.169* } +%struct.zot.502 = type opaque +%struct.eggs.503 = type { i32, [12 x i8], %struct.bar.0, [256 x i8], i32, %struct.blam*, %struct.blam*, %struct.blam* } +%struct.zot.504 = type <{ %struct.eggs.4, %struct.wibble.505*, [2 x [23 x i32]], i8, [7 x i8] }> +%struct.wibble.505 = type opaque +%struct.ham.506 = type opaque +%struct.ham.507 = type opaque +%struct.baz.508 = type opaque +%struct.wombat.509 = type { [1536 x %struct.baz.265*], [1536 x [128 x i8]], %struct.baz.265*, [128 x i8] } +%struct.baz.510 = type opaque +%struct.blam.511 = type opaque +%struct.quux.512 = type opaque +%struct.snork.513 = type opaque +%struct.blam.514 = type <{ i32, i32, i32, i32, %struct.blam.2*, i32, [4 x i8] }> +%struct.baz.515 = type opaque +%struct.barney.516 = type opaque +%struct.hoge.517 = type { %struct.eggs.4, %struct.blam.518*, %struct.baz* } +%struct.blam.518 = type opaque +%struct.snork.519 = type { %struct.eggs.4, %struct.snork.520* } +%struct.snork.520 = type opaque +%struct.pluto.521 = type { %struct.blam.2, [40 x %struct.eggs.531*], %struct.quux.522*, %struct.wobble.523*, %struct.wibble.524*, %struct.spam.525*, %struct.eggs.531*, %struct.zot.526*, %struct.quux.527*, %struct.pluto.528*, %struct.barney.529*, %struct.foo.530*, %struct.eggs.531*, %struct.eggs.531*, %struct.wombat.533*, %struct.eggs.538*, %struct.hoge.539*, %struct.wombat.540*, %struct.wombat.540*, %struct.wombat.540*, %struct.widget.541*, %struct.widget.542*, %struct.eggs.543*, %struct.pluto.546*, %struct.widget.547*, %struct.widget.548*, %struct.wobble.549*, %struct.baz.554*, %struct.widget.556*, %struct.blam.557*, %struct.foo.558*, %struct.blam.559*, %struct.eggs.560*, %struct.pluto.561*, i32, float, float, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [64 x i8], i32, i32, i32, i32, %struct.wobble.564*, %struct.wobble.564*, %struct.wobble.564*, i32, [32 x i32], [32 x [64 x i8]], [32 x [64 x i8]], [32 x [64 x i8]], [32 x [64 x i8]], [32 x i8], [256 x i8], [256 x i8], i32, i32, i32, float, float, i32, [5 x [128 x i8]], [5 x [128 x i16]], [5 x [128 x i16]], [5 x [128 x i16]], [5 x [1024 x i16]], [64 x [64 x i16]], [64 x i32], [64 x float], [64 x float], [12 x i8], [64 x %struct.bar.0], i32, %struct.blam.565, %struct.wobble.569*, %struct.foo.570, i8, %struct.widget.576*, i32, [4 x i8], %struct.blam, [8 x i8] } +%struct.quux.522 = type <{ %struct.blam.2, [40 x %struct.eggs.531*], [40 x %struct.eggs.531*], [40 x float], i32, i32, i32, i32, float, float, i32, i8, [3 x i8] }> +%struct.wobble.523 = type opaque +%struct.wibble.524 = type opaque +%struct.spam.525 = type opaque +%struct.zot.526 = type opaque +%struct.quux.527 = type opaque +%struct.pluto.528 = type opaque +%struct.barney.529 = type opaque +%struct.foo.530 = type opaque +%struct.eggs.531 = type <{ i32 (...)**, [256 x i16], i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, i32, i32, i32, i32, [4 x i8], [256 x %struct.widget.532*], i32, i32, i32, [4 x i8] }> +%struct.widget.532 = type { i32 (...)**, i32, i32, i32, i32, i32, [256 x i16], i32 } +%struct.wombat.533 = type { %struct.snork.534, %struct.foo*, %struct.pluto.521*, %struct.spam.535 } +%struct.snork.534 = type <{ i32 (...)**, [256 x i16], i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, i32, i32, i32, i32, [4 x i8], [256 x %struct.widget.532*], i32, i32, i32 }> +%struct.spam.535 = type { %struct.hoge.536**, i64, i64 } +%struct.hoge.536 = type { i32 (...)**, i32, %struct.snork.537, %struct.snork.537 } +%struct.snork.537 = type { i8* } +%struct.eggs.538 = type opaque +%struct.hoge.539 = type opaque +%struct.wombat.540 = type opaque +%struct.widget.541 = type opaque +%struct.widget.542 = type opaque +%struct.eggs.543 = type <{ %struct.snork.534, [12 x i8], [2 x [128 x %struct.pluto.544]], %struct.wobble.545*, i32, i32, i32, [12 x i8] }> +%struct.pluto.544 = type { [32 x i8], %struct.bar.0, i32, i32, i32, i32 } +%struct.wobble.545 = type <{ %struct.widget.532, i32*, i32*, i16*, i32*, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [4 x i8] }> +%struct.pluto.546 = type opaque +%struct.widget.547 = type opaque +%struct.widget.548 = type opaque +%struct.wobble.549 = type <{ %struct.snork.534, i32, i32, i32, i32, i32, i32, [4 x i8], %struct.wombat.550*, %struct.wombat.550*, %struct.wombat.550*, i32, i32, %struct.hoge.551*, i32, [4 x i8], %struct.widget.552*, i32, i32, i32, [4 x i8], %struct.snork.553*, i32, i32, i32, i32, i32, [4 x i8] }> +%struct.wombat.550 = type opaque +%struct.hoge.551 = type opaque +%struct.widget.552 = type opaque +%struct.snork.553 = type opaque +%struct.baz.554 = type { %struct.snork.534, i32, float, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, i32, i32, i32, i32, float, float, i32, float, float, float, float, i32, float, i32, i32, i32, i32, i32, i32, i32, i32, [4 x i8], %struct.pluto.555, [128 x i8], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [4 x i8] } +%struct.pluto.555 = type { %struct.snork.534, [4 x i8] } +%struct.widget.556 = type opaque +%struct.blam.557 = type opaque +%struct.foo.558 = type opaque +%struct.blam.559 = type opaque +%struct.eggs.560 = type opaque +%struct.pluto.561 = type { %struct.blam.2, %struct.quux.562, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, float, float, i32, i32, i32, i32, i32, i8, %struct.snork.519, float, float, [8 x i8], %struct.bar.0, %struct.hoge.563, float, float, [8 x i8] } +%struct.quux.562 = type { i32 (...)** } +%struct.hoge.563 = type { [64 x i8], i16, i16, i16, i16, i32, i32 } +%struct.wobble.564 = type <{ %struct.widget.532, i32*, i16*, i16*, i32*, [9 x i32], i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, [4 x i8] }> +%struct.blam.565 = type { %struct.wibble.566 } +%struct.wibble.566 = type { %struct.snork.567 } +%struct.snork.567 = type { %struct.quux.16, %struct.foo.568*, %struct.foo.568*, %struct.foo.568* } +%struct.foo.568 = type { [128 x i16], %struct.bar.0, i32, [12 x i8] } +%struct.wobble.569 = type opaque +%struct.foo.570 = type { [128 x %struct.barney.571], [128 x float], [128 x float], [128 x i8], i32, [12 x i8] } +%struct.barney.571 = type <{ %struct.zot.572, [8 x i8], %struct.bar.0, %struct.bar.0, float, i8, [3 x i8], i32, [4 x i8] }> +%struct.zot.572 = type { %struct.baz.573 } +%struct.baz.573 = type { %struct.zot.574 } +%struct.zot.574 = type { %struct.quux.16, %struct.spam.575, i64, i64 } +%struct.spam.575 = type { i16*, [8 x i8] } +%struct.widget.576 = type opaque +%struct.barney.577 = type { %struct.hoge.578*, %struct.snork.519*, i32, i32, i32, [256 x %struct.baz.151*], [256 x [32 x i8]], [256 x [64 x [256 x i8]]], [256 x i32], [256 x i32], [256 x i32], [256 x [256 x i32]], [256 x i32], [256 x i32], [256 x i32], [256 x i32], [256 x [32 x [128 x i8]]], [256 x i32], [256 x i32], [256 x i32], [256 x i32] } +%struct.hoge.578 = type { %struct.eggs.4, %struct.bar.579* } +%struct.bar.579 = type opaque +%struct.ham.580 = type { %struct.blam.2, [2 x %struct.eggs.581], [2 x %struct.wobble.588], %struct.barney.593, %struct.baz*, %struct.baz*, %struct.baz*, float, float, [2 x [30000 x i32]], [2 x [30000 x i8]], [2 x [30000 x i8]], [2 x [30000 x %struct.foo.61*]], [2 x [30000 x i32]], [8 x i8], [6024 x [32 x %struct.bar.0]], [6024 x [32 x %struct.bar.0]], [6024 x [32 x %struct.quux.69*]], [6024 x [32 x i32]], [6024 x [32 x i32]], [6024 x [32 x i32]], [6024 x [32 x i32]], [6024 x i32], [6024 x i32], [2 x i32], [2 x i32], i8, float, i32, [30000 x i32], [30000 x i32], i32, [2 x float], i32, [2 x %struct.snork.596], i32, %struct.wombat.597*, [2 x %struct.blam.598*], %struct.quux.599, i32, i32, [16 x i32], [16 x i32] } +%struct.eggs.581 = type { %struct.ham.582 } +%struct.ham.582 = type { %struct.baz.583 } +%struct.baz.583 = type { %struct.wobble.584 } +%struct.wobble.584 = type { %struct.quux.585 } +%struct.quux.585 = type { %struct.snork.586 } +%struct.snork.586 = type { %struct.quux.16, %struct.quux.587*, i64 } +%struct.quux.587 = type opaque +%struct.wobble.588 = type { %struct.foo.589 } +%struct.foo.589 = type { %struct.spam.590 } +%struct.spam.590 = type { %struct.spam.591 } +%struct.spam.591 = type { %struct.quux.16, %struct.foo.592*, i64 } +%struct.foo.592 = type opaque +%struct.barney.593 = type { %struct.blam.594 } +%struct.blam.594 = type { %struct.widget.595 } +%struct.widget.595 = type { %struct.quux.16, i32*, i32*, i32* } +%struct.snork.596 = type { float, i8, i8, i8, i8 } +%struct.wombat.597 = type opaque +%struct.blam.598 = type opaque +%struct.quux.599 = type { %struct.spam.600 } +%struct.spam.600 = type { %struct.spam.601 } +%struct.spam.601 = type { %struct.quux.16, %struct.barney.602*, %struct.barney.602*, %struct.barney.602* } +%struct.barney.602 = type <{ %struct.quux.69*, i32, [4 x i8] }> +%struct.hoge.603 = type opaque +%struct.spam.604 = type opaque +%struct.quux.605 = type <{ [1 x %struct.snork.606], [1 x i32], [1024 x %struct.hoge.613], [4 x i8] }> +%struct.snork.606 = type { %struct.wibble.607 } +%struct.wibble.607 = type { %struct.wobble.608 } +%struct.wobble.608 = type { %struct.bar.609 } +%struct.bar.609 = type { %struct.ham.610 } +%struct.ham.610 = type { %struct.pluto.611 } +%struct.pluto.611 = type { %struct.quux.16, %struct.widget.612*, i64 } +%struct.widget.612 = type opaque +%struct.hoge.613 = type { i32, float, float, float, float, float, float, float, float, [64 x i8], [64 x i8], [64 x i8], [64 x i8], float, i32, i32, i32 } +%struct.zot.614 = type <{ %struct.spam.300, i64, %struct.quux.28*, %struct.ham*, %struct.bar.301*, %struct.bar.306*, %struct.eggs.307*, %struct.hoge.309*, %struct.blam.310*, %struct.blam.311*, %struct.ham.312*, %struct.wibble.313*, %struct.wibble.314*, %struct.wibble.315*, %struct.spam.287*, %struct.foo.316*, %struct.eggs.317*, %struct.ham.318*, %struct.ham*, i8*, float, float, %struct.barney.320, i32, i32, i32, i16, [14 x i8] }> + +@global = private unnamed_addr constant [10 x i8] c"anonymous\00", align 1 +@global.1 = private unnamed_addr constant [11 x i8] c"_anonymous\00", align 1 +@global.2 = external global %struct.ham, align 16 +@global.3 = external local_unnamed_addr global %struct.bar*, align 8 + +; Function Attrs: argmemonly nounwind +declare void @llvm.lifetime.start(i64, i8* nocapture) #0 + +; Function Attrs: argmemonly nounwind +declare void @llvm.lifetime.end(i64, i8* nocapture) #0 + +; Function Attrs: nounwind readonly +declare i8* @hoge(i8*, i8* nocapture) local_unnamed_addr #1 + +declare void @pluto(%struct.eggs*) local_unnamed_addr #2 + +declare i32 @baz(%struct.spam*, %struct.bar.0* dereferenceable(16), float, %struct.bar.0*, float*) local_unnamed_addr #2 + +; Function Attrs: sspstrong uwtable +define i32 @wobble(%struct.foo* nocapture readonly %arg, %struct.eggs* %arg1, %struct.spam.298* nocapture %arg2, i32 %arg3) local_unnamed_addr #3 align 2 { +; CHECK-LABEL: @wobble( +; CHECK-NEXT: bb: +; CHECK-NEXT: [[TMP:%.*]] = alloca [32 x i8], align 16 +; CHECK-NEXT: [[TMP4:%.*]] = alloca [256 x i8], align 16 +; CHECK-NEXT: [[TMP5:%.*]] = alloca { <2 x float>, <2 x float> }, align 16 +; CHECK-NEXT: [[TMP6:%.*]] = bitcast { <2 x float>, <2 x float> }* [[TMP5]] to %struct.bar.0* +; CHECK-NEXT: tail call void @pluto(%struct.eggs* [[ARG1:%.*]]) +; CHECK-NEXT: [[TMP7:%.*]] = getelementptr inbounds [32 x i8], [32 x i8]* [[TMP]], i64 0, i64 0 +; CHECK-NEXT: call void @llvm.lifetime.start(i64 32, i8* nonnull [[TMP7]]) #4 +; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds [[STRUCT_SPAM_298:%.*]], %struct.spam.298* [[ARG2:%.*]], i64 0, i32 0, i32 19 +; CHECK-NEXT: [[TMP9:%.*]] = load i8*, i8** [[TMP8]], align 16 +; CHECK-NEXT: br label [[BB10:%.*]] +; CHECK: bb10: +; CHECK-NEXT: [[TMP11:%.*]] = phi i8* [ [[TMP9]], [[BB:%.*]] ], [ [[TMP17:%.*]], [[BB16:%.*]] ] +; CHECK-NEXT: [[TMP12:%.*]] = load i8, i8* [[TMP11]], align 1 +; CHECK-NEXT: [[TMP13:%.*]] = icmp eq i8 [[TMP12]], 95 +; CHECK-NEXT: br i1 [[TMP13]], label [[BB16]], label [[BB14:%.*]] +; CHECK: bb14: +; CHECK-NEXT: br label [[BB20:%.*]] +; CHECK: bb16: +; CHECK-NEXT: [[TMP17]] = getelementptr inbounds i8, i8* [[TMP11]], i64 1 +; CHECK-NEXT: [[TMP18:%.*]] = load i8, i8* [[TMP17]], align 1 +; CHECK-NEXT: [[TMP19:%.*]] = icmp eq i8 [[TMP18]], 0 +; CHECK-NEXT: br i1 [[TMP19]], label [[BB30:%.*]], label [[BB10]] +; CHECK: bb20: +; CHECK-NEXT: [[TMP21:%.*]] = phi i8* [ [[TMP25:%.*]], [[BB24:%.*]] ], [ [[TMP11]], [[BB14]] ] +; CHECK-NEXT: [[TMP22:%.*]] = phi i8* [ [[TMP26:%.*]], [[BB24]] ], [ [[TMP7]], [[BB14]] ] +; CHECK-NEXT: [[TMP23:%.*]] = load i8, i8* [[TMP21]], align 1 +; CHECK-NEXT: switch i8 [[TMP23]], label [[BB24]] [ +; CHECK-NEXT: i8 95, label [[BB27:%.*]] +; CHECK-NEXT: i8 0, label [[BB27]] +; CHECK-NEXT: ] +; CHECK: bb24: +; CHECK-NEXT: [[TMP25]] = getelementptr inbounds i8, i8* [[TMP21]], i64 1 +; CHECK-NEXT: [[TMP26]] = getelementptr inbounds i8, i8* [[TMP22]], i64 1 +; CHECK-NEXT: store i8 [[TMP23]], i8* [[TMP22]], align 1 +; CHECK-NEXT: br label [[BB20]] +; CHECK: bb27: +; CHECK-NEXT: br label [[BB32:%.*]] +; CHECK: bb30: +; CHECK-NEXT: br label [[BB32]] +; CHECK: bb32: +; CHECK-NEXT: [[TMP33:%.*]] = phi i8* [ [[TMP22]], [[BB27]] ], [ [[TMP7]], [[BB30]] ] +; CHECK-NEXT: [[TMP34:%.*]] = phi i8* [ [[TMP21]], [[BB27]] ], [ [[TMP17]], [[BB30]] ] +; CHECK-NEXT: store i8 0, i8* [[TMP33]], align 1 +; CHECK-NEXT: [[TMP35:%.*]] = getelementptr inbounds [[STRUCT_EGGS:%.*]], %struct.eggs* [[ARG1]], i64 0, i32 5 +; CHECK-NEXT: store i32 [[ARG3:%.*]], i32* [[TMP35]], align 4 +; CHECK-NEXT: br label [[BB36:%.*]] +; CHECK: bb36: +; CHECK-NEXT: [[TMP37:%.*]] = phi i8* [ [[TMP34]], [[BB32]] ], [ [[TMP43:%.*]], [[BB42:%.*]] ] +; CHECK-NEXT: [[TMP38:%.*]] = load i8, i8* [[TMP37]], align 1 +; CHECK-NEXT: [[TMP39:%.*]] = icmp eq i8 [[TMP38]], 95 +; CHECK-NEXT: br i1 [[TMP39]], label [[BB42]], label [[BB40:%.*]] +; CHECK: bb40: +; CHECK-NEXT: br label [[BB46:%.*]] +; CHECK: bb42: +; CHECK-NEXT: [[TMP43]] = getelementptr inbounds i8, i8* [[TMP37]], i64 1 +; CHECK-NEXT: [[TMP44:%.*]] = load i8, i8* [[TMP43]], align 1 +; CHECK-NEXT: [[TMP45:%.*]] = icmp eq i8 [[TMP44]], 0 +; CHECK-NEXT: br i1 [[TMP45]], label [[BB56:%.*]], label [[BB36]] +; CHECK: bb46: +; CHECK-NEXT: [[TMP47:%.*]] = phi i8* [ [[TMP51:%.*]], [[BB50:%.*]] ], [ [[TMP37]], [[BB40]] ] +; CHECK-NEXT: [[TMP48:%.*]] = phi i8* [ [[TMP52:%.*]], [[BB50]] ], [ [[TMP7]], [[BB40]] ] +; CHECK-NEXT: [[TMP49:%.*]] = load i8, i8* [[TMP47]], align 1 +; CHECK-NEXT: switch i8 [[TMP49]], label [[BB50]] [ +; CHECK-NEXT: i8 95, label [[BB53:%.*]] +; CHECK-NEXT: i8 0, label [[BB53]] +; CHECK-NEXT: ] +; CHECK: bb50: +; CHECK-NEXT: [[TMP51]] = getelementptr inbounds i8, i8* [[TMP47]], i64 1 +; CHECK-NEXT: [[TMP52]] = getelementptr inbounds i8, i8* [[TMP48]], i64 1 +; CHECK-NEXT: store i8 [[TMP49]], i8* [[TMP48]], align 1 +; CHECK-NEXT: br label [[BB46]] +; CHECK: bb53: +; CHECK-NEXT: br label [[BB58:%.*]] +; CHECK: bb56: +; CHECK-NEXT: br label [[BB58]] +; CHECK: bb58: +; CHECK-NEXT: [[TMP59:%.*]] = phi i8* [ [[TMP48]], [[BB53]] ], [ [[TMP7]], [[BB56]] ] +; CHECK-NEXT: [[TMP60:%.*]] = phi i8* [ [[TMP47]], [[BB53]] ], [ [[TMP43]], [[BB56]] ] +; CHECK-NEXT: store i8 0, i8* [[TMP59]], align 1 +; CHECK-NEXT: [[TMP61:%.*]] = load i32, i32* [[TMP35]], align 4 +; CHECK-NEXT: [[TMP62:%.*]] = icmp eq i32 [[TMP61]], 10 +; CHECK-NEXT: br i1 [[TMP62]], label [[BB63:%.*]], label [[BB93:%.*]] +; CHECK: bb63: +; CHECK-NEXT: [[TMP64:%.*]] = getelementptr inbounds [256 x i8], [256 x i8]* [[TMP4]], i64 0, i64 0 +; CHECK-NEXT: call void @llvm.lifetime.start(i64 256, i8* nonnull [[TMP64]]) #4 +; CHECK-NEXT: [[TMP65:%.*]] = load i8*, i8** [[TMP8]], align 16 +; CHECK-NEXT: [[TMP66:%.*]] = getelementptr inbounds i8, i8* [[TMP65]], i64 10 +; CHECK-NEXT: br label [[BB67:%.*]] +; CHECK: bb67: +; CHECK-NEXT: [[TMP68:%.*]] = phi i64 [ [[TMP77:%.*]], [[BB73:%.*]] ], [ 1, [[BB63]] ] +; CHECK-NEXT: [[TMP69:%.*]] = phi i8* [ [[TMP75:%.*]], [[BB73]] ], [ [[TMP66]], [[BB63]] ] +; CHECK-NEXT: [[TMP70:%.*]] = phi i8* [ [[TMP74:%.*]], [[BB73]] ], [ [[TMP64]], [[BB63]] ] +; CHECK-NEXT: [[TMP71:%.*]] = load i8, i8* [[TMP69]], align 1 +; CHECK-NEXT: store i8 [[TMP71]], i8* [[TMP70]], align 1 +; CHECK-NEXT: [[TMP72:%.*]] = icmp eq i8 [[TMP71]], 0 +; CHECK-NEXT: br i1 [[TMP72]], label [[BB80:%.*]], label [[BB73]] +; CHECK: bb73: +; CHECK-NEXT: [[TMP74]] = getelementptr inbounds i8, i8* [[TMP70]], i64 1 +; CHECK-NEXT: [[TMP75]] = getelementptr inbounds i8, i8* [[TMP69]], i64 1 +; CHECK-NEXT: [[TMP76:%.*]] = icmp ult i64 [[TMP68]], 255 +; CHECK-NEXT: [[TMP77]] = add nuw nsw i64 [[TMP68]], 1 +; CHECK-NEXT: br i1 [[TMP76]], label [[BB67]], label [[BB78:%.*]] +; CHECK: bb78: +; CHECK-NEXT: store i8 0, i8* [[TMP74]], align 1 +; CHECK-NEXT: br label [[BB81:%.*]] +; CHECK: bb80: +; CHECK-NEXT: br label [[BB81]] +; CHECK: bb81: +; CHECK-NEXT: [[TMP82:%.*]] = call i8* @hoge(i8* nonnull [[TMP64]], i8* getelementptr inbounds ([11 x i8], [11 x i8]* @global.1, i64 0, i64 0)) +; CHECK-NEXT: [[TMP83:%.*]] = icmp eq i8* [[TMP82]], null +; CHECK-NEXT: br i1 [[TMP83]], label [[BB85:%.*]], label [[BB84:%.*]] +; CHECK: bb84: +; CHECK-NEXT: store i8 0, i8* [[TMP82]], align 1 +; CHECK-NEXT: br label [[BB85]] +; CHECK: bb85: +; CHECK-NEXT: [[TMP86:%.*]] = load %struct.foo.321*, %struct.foo.321** bitcast (%struct.bar** @global.3 to %struct.foo.321**), align 8 +; CHECK-NEXT: [[TMP87:%.*]] = getelementptr inbounds [[STRUCT_FOO_321:%.*]], %struct.foo.321* [[TMP86]], i64 0, i32 131 +; CHECK-NEXT: [[TMP88:%.*]] = load %struct.quux.605*, %struct.quux.605** [[TMP87]], align 16 +; CHECK-NEXT: [[TMP89:%.*]] = call i32 @foo(%struct.quux.605* [[TMP88]], i32 0, i8* nonnull [[TMP64]]) +; CHECK-NEXT: [[TMP90:%.*]] = icmp sgt i32 [[TMP89]], 0 +; CHECK-NEXT: [[TMP91:%.*]] = select i1 [[TMP90]], i32 [[TMP89]], i32 0 +; CHECK-NEXT: [[TMP92:%.*]] = getelementptr inbounds [[STRUCT_EGGS]], %struct.eggs* [[ARG1]], i64 0, i32 6 +; CHECK-NEXT: store i32 [[TMP91]], i32* [[TMP92]], align 8 +; CHECK-NEXT: call void @llvm.lifetime.end(i64 256, i8* nonnull [[TMP64]]) #4 +; CHECK-NEXT: br label [[BB97:%.*]] +; CHECK: bb93: +; CHECK-NEXT: [[TMP94:%.*]] = call i64 @ham(i8* nonnull [[TMP7]], i8** null, i32 10) +; CHECK-NEXT: [[TMP95:%.*]] = trunc i64 [[TMP94]] to i32 +; CHECK-NEXT: [[TMP96:%.*]] = getelementptr inbounds [[STRUCT_EGGS]], %struct.eggs* [[ARG1]], i64 0, i32 6 +; CHECK-NEXT: store i32 [[TMP95]], i32* [[TMP96]], align 8 +; CHECK-NEXT: br label [[BB97]] +; CHECK: bb97: +; CHECK-NEXT: [[TMP98:%.*]] = load i8, i8* [[TMP60]], align 1 +; CHECK-NEXT: [[TMP99:%.*]] = icmp eq i8 [[TMP98]], 0 +; CHECK-NEXT: br i1 [[TMP99]], label [[BB155:%.*]], label [[BB100:%.*]] +; CHECK: bb100: +; CHECK-NEXT: br label [[BB101:%.*]] +; CHECK: bb101: +; CHECK-NEXT: [[TMP102:%.*]] = phi i8* [ [[TMP108:%.*]], [[BB107:%.*]] ], [ [[TMP60]], [[BB100]] ] +; CHECK-NEXT: [[TMP103:%.*]] = load i8, i8* [[TMP102]], align 1 +; CHECK-NEXT: [[TMP104:%.*]] = icmp eq i8 [[TMP103]], 95 +; CHECK-NEXT: br i1 [[TMP104]], label [[BB107]], label [[BB105:%.*]] +; CHECK: bb105: +; CHECK-NEXT: br label [[BB111:%.*]] +; CHECK: bb107: +; CHECK-NEXT: [[TMP108]] = getelementptr inbounds i8, i8* [[TMP102]], i64 1 +; CHECK-NEXT: [[TMP109:%.*]] = load i8, i8* [[TMP108]], align 1 +; CHECK-NEXT: [[TMP110:%.*]] = icmp eq i8 [[TMP109]], 0 +; CHECK-NEXT: br i1 [[TMP110]], label [[BB121:%.*]], label [[BB101]] +; CHECK: bb111: +; CHECK-NEXT: [[TMP112:%.*]] = phi i8* [ [[TMP116:%.*]], [[BB115:%.*]] ], [ [[TMP102]], [[BB105]] ] +; CHECK-NEXT: [[TMP113:%.*]] = phi i8* [ [[TMP117:%.*]], [[BB115]] ], [ [[TMP7]], [[BB105]] ] +; CHECK-NEXT: [[TMP114:%.*]] = load i8, i8* [[TMP112]], align 1 +; CHECK-NEXT: switch i8 [[TMP114]], label [[BB115]] [ +; CHECK-NEXT: i8 95, label [[BB118:%.*]] +; CHECK-NEXT: i8 0, label [[BB118]] +; CHECK-NEXT: ] +; CHECK: bb115: +; CHECK-NEXT: [[TMP116]] = getelementptr inbounds i8, i8* [[TMP112]], i64 1 +; CHECK-NEXT: [[TMP117]] = getelementptr inbounds i8, i8* [[TMP113]], i64 1 +; CHECK-NEXT: store i8 [[TMP114]], i8* [[TMP113]], align 1 +; CHECK-NEXT: br label [[BB111]] +; CHECK: bb118: +; CHECK-NEXT: br label [[BB123:%.*]] +; CHECK: bb121: +; CHECK-NEXT: br label [[BB123]] +; CHECK: bb123: +; CHECK-NEXT: [[TMP124:%.*]] = phi i8* [ [[TMP113]], [[BB118]] ], [ [[TMP7]], [[BB121]] ] +; CHECK-NEXT: [[TMP125:%.*]] = phi i8* [ [[TMP112]], [[BB118]] ], [ [[TMP108]], [[BB121]] ] +; CHECK-NEXT: store i8 0, i8* [[TMP124]], align 1 +; CHECK-NEXT: [[TMP126:%.*]] = load i8, i8* [[TMP125]], align 1 +; CHECK-NEXT: [[TMP127:%.*]] = icmp ne i8 [[TMP126]], 95 +; CHECK-NEXT: [[TMP128:%.*]] = load i8, i8* [[TMP7]], align 16 +; CHECK-NEXT: [[TMP129:%.*]] = icmp eq i8 [[TMP128]], 0 +; CHECK-NEXT: [[TMP130:%.*]] = or i1 [[TMP127]], [[TMP129]] +; CHECK-NEXT: br i1 [[TMP130]], label [[BB155]], label [[BB131:%.*]] +; CHECK: bb131: +; CHECK-NEXT: [[TMP132:%.*]] = call i32 @wibble(i8* nonnull [[TMP7]], i8* getelementptr inbounds ([10 x i8], [10 x i8]* @global, i64 0, i64 0)) +; CHECK-NEXT: [[TMP133:%.*]] = icmp eq i32 [[TMP132]], 0 +; CHECK-NEXT: [[TMP134:%.*]] = getelementptr inbounds [[STRUCT_EGGS]], %struct.eggs* [[ARG1]], i64 0, i32 8, i64 0 +; CHECK-NEXT: br i1 [[TMP133]], label [[BB136:%.*]], label [[BB135:%.*]] +; CHECK: bb135: +; CHECK-NEXT: br label [[BB137:%.*]] +; CHECK: bb136: +; CHECK-NEXT: br label [[BB150:%.*]] +; CHECK: bb137: +; CHECK-NEXT: [[TMP138:%.*]] = phi i64 [ [[TMP147:%.*]], [[BB143:%.*]] ], [ 1, [[BB135]] ] +; CHECK-NEXT: [[TMP139:%.*]] = phi i8* [ [[TMP145:%.*]], [[BB143]] ], [ [[TMP7]], [[BB135]] ] +; CHECK-NEXT: [[TMP140:%.*]] = phi i8* [ [[TMP144:%.*]], [[BB143]] ], [ [[TMP134]], [[BB135]] ] +; CHECK-NEXT: [[TMP141:%.*]] = load i8, i8* [[TMP139]], align 1 +; CHECK-NEXT: store i8 [[TMP141]], i8* [[TMP140]], align 1 +; CHECK-NEXT: [[TMP142:%.*]] = icmp eq i8 [[TMP141]], 0 +; CHECK-NEXT: br i1 [[TMP142]], label [[BB154:%.*]], label [[BB143]] +; CHECK: bb143: +; CHECK-NEXT: [[TMP144]] = getelementptr inbounds i8, i8* [[TMP140]], i64 1 +; CHECK-NEXT: [[TMP145]] = getelementptr inbounds i8, i8* [[TMP139]], i64 1 +; CHECK-NEXT: [[TMP146:%.*]] = icmp ult i64 [[TMP138]], 31 +; CHECK-NEXT: [[TMP147]] = add nuw nsw i64 [[TMP138]], 1 +; CHECK-NEXT: br i1 [[TMP146]], label [[BB137]], label [[BB148:%.*]] +; CHECK: bb148: +; CHECK-NEXT: store i8 0, i8* [[TMP144]], align 1 +; CHECK-NEXT: br label [[BB155]] +; CHECK: bb150: +; CHECK-NEXT: store i8 0, i8* [[TMP134]], align 1 +; CHECK-NEXT: br i1 true, label [[BB153:%.*]], label [[BB151:%.*]] +; CHECK: bb151: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB370:%.*]] +; CHECK: bb153: +; CHECK-NEXT: br label [[BB155]] +; CHECK: bb154: +; CHECK-NEXT: br label [[BB155]] +; CHECK: bb155: +; CHECK-NEXT: [[TMP156:%.*]] = phi i8* [ [[TMP125]], [[BB123]] ], [ [[TMP60]], [[BB97]] ], [ [[TMP125]], [[BB148]] ], [ undef, [[BB428:%.*]] ], [ [[TMP125]], [[BB153]] ], [ [[TMP125]], [[BB154]] ] +; CHECK-NEXT: [[TMP157:%.*]] = load i8, i8* [[TMP156]], align 1 +; CHECK-NEXT: [[TMP158:%.*]] = icmp eq i8 [[TMP157]], 0 +; CHECK-NEXT: br i1 [[TMP158]], label [[BB191:%.*]], label [[BB159:%.*]] +; CHECK: bb159: +; CHECK-NEXT: br label [[BB160:%.*]] +; CHECK: bb160: +; CHECK-NEXT: [[TMP161:%.*]] = phi i8* [ [[TMP167:%.*]], [[BB166:%.*]] ], [ [[TMP156]], [[BB159]] ] +; CHECK-NEXT: [[TMP162:%.*]] = load i8, i8* [[TMP161]], align 1 +; CHECK-NEXT: [[TMP163:%.*]] = icmp eq i8 [[TMP162]], 95 +; CHECK-NEXT: br i1 [[TMP163]], label [[BB166]], label [[BB164:%.*]] +; CHECK: bb164: +; CHECK-NEXT: br label [[BB170:%.*]] +; CHECK: bb166: +; CHECK-NEXT: [[TMP167]] = getelementptr inbounds i8, i8* [[TMP161]], i64 1 +; CHECK-NEXT: [[TMP168:%.*]] = load i8, i8* [[TMP167]], align 1 +; CHECK-NEXT: [[TMP169:%.*]] = icmp eq i8 [[TMP168]], 0 +; CHECK-NEXT: br i1 [[TMP169]], label [[BB180:%.*]], label [[BB160]] +; CHECK: bb170: +; CHECK-NEXT: [[TMP171:%.*]] = phi i8* [ [[TMP175:%.*]], [[BB174:%.*]] ], [ [[TMP161]], [[BB164]] ] +; CHECK-NEXT: [[TMP172:%.*]] = phi i8* [ [[TMP176:%.*]], [[BB174]] ], [ [[TMP7]], [[BB164]] ] +; CHECK-NEXT: [[TMP173:%.*]] = load i8, i8* [[TMP171]], align 1 +; CHECK-NEXT: switch i8 [[TMP173]], label [[BB174]] [ +; CHECK-NEXT: i8 95, label [[BB177:%.*]] +; CHECK-NEXT: i8 0, label [[BB177]] +; CHECK-NEXT: ] +; CHECK: bb174: +; CHECK-NEXT: [[TMP175]] = getelementptr inbounds i8, i8* [[TMP171]], i64 1 +; CHECK-NEXT: [[TMP176]] = getelementptr inbounds i8, i8* [[TMP172]], i64 1 +; CHECK-NEXT: store i8 [[TMP173]], i8* [[TMP172]], align 1 +; CHECK-NEXT: br label [[BB170]] +; CHECK: bb177: +; CHECK-NEXT: br label [[BB182:%.*]] +; CHECK: bb180: +; CHECK-NEXT: br label [[BB182]] +; CHECK: bb182: +; CHECK-NEXT: [[TMP183:%.*]] = phi i8* [ [[TMP172]], [[BB177]] ], [ [[TMP7]], [[BB180]] ] +; CHECK-NEXT: [[TMP184:%.*]] = phi i8* [ [[TMP171]], [[BB177]] ], [ [[TMP167]], [[BB180]] ] +; CHECK-NEXT: store i8 0, i8* [[TMP183]], align 1 +; CHECK-NEXT: [[TMP185:%.*]] = load i8, i8* [[TMP7]], align 16 +; CHECK-NEXT: [[TMP186:%.*]] = icmp eq i8 [[TMP185]], 0 +; CHECK-NEXT: br i1 [[TMP186]], label [[BB191]], label [[BB187:%.*]] +; CHECK: bb187: +; CHECK-NEXT: [[TMP188:%.*]] = call i64 @ham(i8* nonnull [[TMP7]], i8** null, i32 10) +; CHECK-NEXT: [[TMP189:%.*]] = trunc i64 [[TMP188]] to i32 +; CHECK-NEXT: [[TMP190:%.*]] = getelementptr inbounds [[STRUCT_EGGS]], %struct.eggs* [[ARG1]], i64 0, i32 9 +; CHECK-NEXT: store i32 [[TMP189]], i32* [[TMP190]], align 16 +; CHECK-NEXT: br label [[BB191]] +; CHECK: bb191: +; CHECK-NEXT: [[TMP192:%.*]] = phi i8* [ [[TMP184]], [[BB187]] ], [ [[TMP184]], [[BB182]] ], [ [[TMP156]], [[BB155]] ] +; CHECK-NEXT: [[TMP193:%.*]] = load i8, i8* [[TMP192]], align 1 +; CHECK-NEXT: [[TMP194:%.*]] = icmp eq i8 [[TMP193]], 0 +; CHECK-NEXT: br i1 [[TMP194]], label [[BB224:%.*]], label [[BB195:%.*]] +; CHECK: bb195: +; CHECK-NEXT: br label [[BB196:%.*]] +; CHECK: bb196: +; CHECK-NEXT: [[TMP197:%.*]] = phi i8* [ [[TMP203:%.*]], [[BB202:%.*]] ], [ [[TMP192]], [[BB195]] ] +; CHECK-NEXT: [[TMP198:%.*]] = load i8, i8* [[TMP197]], align 1 +; CHECK-NEXT: [[TMP199:%.*]] = icmp eq i8 [[TMP198]], 95 +; CHECK-NEXT: br i1 [[TMP199]], label [[BB202]], label [[BB200:%.*]] +; CHECK: bb200: +; CHECK-NEXT: br label [[BB206:%.*]] +; CHECK: bb202: +; CHECK-NEXT: [[TMP203]] = getelementptr inbounds i8, i8* [[TMP197]], i64 1 +; CHECK-NEXT: [[TMP204:%.*]] = load i8, i8* [[TMP203]], align 1 +; CHECK-NEXT: [[TMP205:%.*]] = icmp eq i8 [[TMP204]], 0 +; CHECK-NEXT: br i1 [[TMP205]], label [[BB215:%.*]], label [[BB196]] +; CHECK: bb206: +; CHECK-NEXT: [[TMP207:%.*]] = phi i8* [ [[TMP211:%.*]], [[BB210:%.*]] ], [ [[TMP197]], [[BB200]] ] +; CHECK-NEXT: [[TMP208:%.*]] = phi i8* [ [[TMP212:%.*]], [[BB210]] ], [ [[TMP7]], [[BB200]] ] +; CHECK-NEXT: [[TMP209:%.*]] = load i8, i8* [[TMP207]], align 1 +; CHECK-NEXT: switch i8 [[TMP209]], label [[BB210]] [ +; CHECK-NEXT: i8 95, label [[BB213:%.*]] +; CHECK-NEXT: i8 0, label [[BB213]] +; CHECK-NEXT: ] +; CHECK: bb210: +; CHECK-NEXT: [[TMP211]] = getelementptr inbounds i8, i8* [[TMP207]], i64 1 +; CHECK-NEXT: [[TMP212]] = getelementptr inbounds i8, i8* [[TMP208]], i64 1 +; CHECK-NEXT: store i8 [[TMP209]], i8* [[TMP208]], align 1 +; CHECK-NEXT: br label [[BB206]] +; CHECK: bb213: +; CHECK-NEXT: br label [[BB216:%.*]] +; CHECK: bb215: +; CHECK-NEXT: br label [[BB216]] +; CHECK: bb216: +; CHECK-NEXT: [[TMP217:%.*]] = phi i8* [ [[TMP208]], [[BB213]] ], [ [[TMP7]], [[BB215]] ] +; CHECK-NEXT: store i8 0, i8* [[TMP217]], align 1 +; CHECK-NEXT: [[TMP218:%.*]] = load i8, i8* [[TMP7]], align 16 +; CHECK-NEXT: [[TMP219:%.*]] = icmp eq i8 [[TMP218]], 0 +; CHECK-NEXT: br i1 [[TMP219]], label [[BB224]], label [[BB220:%.*]] +; CHECK: bb220: +; CHECK-NEXT: [[TMP221:%.*]] = call i64 @ham(i8* nonnull [[TMP7]], i8** null, i32 10) +; CHECK-NEXT: [[TMP222:%.*]] = trunc i64 [[TMP221]] to i32 +; CHECK-NEXT: [[TMP223:%.*]] = getelementptr inbounds [[STRUCT_EGGS]], %struct.eggs* [[ARG1]], i64 0, i32 11 +; CHECK-NEXT: store i32 [[TMP222]], i32* [[TMP223]], align 8 +; CHECK-NEXT: br label [[BB224]] +; CHECK: bb224: +; CHECK-NEXT: [[TMP225:%.*]] = getelementptr inbounds [[STRUCT_SPAM_298]], %struct.spam.298* [[ARG2]], i64 0, i32 0, i32 3 +; CHECK-NEXT: [[TMP226:%.*]] = load %struct.ham*, %struct.ham** [[TMP225]], align 16 +; CHECK-NEXT: [[TMP227:%.*]] = icmp eq %struct.ham* [[TMP226]], null +; CHECK-NEXT: [[TMP228:%.*]] = select i1 [[TMP227]], %struct.ham* @global.2, %struct.ham* [[TMP226]] +; CHECK-NEXT: call void @hoge.4(%struct.eggs* [[ARG1]], %struct.ham* nonnull dereferenceable(64) [[TMP228]]) +; CHECK-NEXT: [[TMP229:%.*]] = bitcast { <2 x float>, <2 x float> }* [[TMP5]] to i8* +; CHECK-NEXT: call void @llvm.lifetime.start(i64 16, i8* nonnull [[TMP229]]) #4 +; CHECK-NEXT: [[TMP230:%.*]] = load %struct.ham*, %struct.ham** [[TMP225]], align 16 +; CHECK-NEXT: [[TMP231:%.*]] = icmp eq %struct.ham* [[TMP230]], null +; CHECK-NEXT: [[TMP232:%.*]] = select i1 [[TMP231]], %struct.ham* @global.2, %struct.ham* [[TMP230]] +; CHECK-NEXT: [[TMP233:%.*]] = call { <2 x float>, <2 x float> } @quux(%struct.ham* nonnull [[TMP232]]) +; CHECK-NEXT: [[TMP234:%.*]] = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* [[TMP5]], i64 0, i32 0 +; CHECK-NEXT: [[TMP235:%.*]] = extractvalue { <2 x float>, <2 x float> } [[TMP233]], 0 +; CHECK-NEXT: store <2 x float> [[TMP235]], <2 x float>* [[TMP234]], align 16 +; CHECK-NEXT: [[TMP236:%.*]] = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* [[TMP5]], i64 0, i32 1 +; CHECK-NEXT: [[TMP237:%.*]] = extractvalue { <2 x float>, <2 x float> } [[TMP233]], 1 +; CHECK-NEXT: store <2 x float> [[TMP237]], <2 x float>* [[TMP236]], align 8 +; CHECK-NEXT: [[TMP238:%.*]] = getelementptr inbounds [[STRUCT_EGGS]], %struct.eggs* [[ARG1]], i64 0, i32 7 +; CHECK-NEXT: store i32 -1, i32* [[TMP238]], align 4 +; CHECK-NEXT: [[TMP239:%.*]] = getelementptr inbounds [[STRUCT_FOO:%.*]], %struct.foo* [[ARG:%.*]], i64 0, i32 66 +; CHECK-NEXT: [[TMP240:%.*]] = load i32, i32* [[TMP239]], align 16 +; CHECK-NEXT: [[TMP241:%.*]] = icmp sgt i32 [[TMP240]], 0 +; CHECK-NEXT: br i1 [[TMP241]], label [[BB242:%.*]], label [[BB258:%.*]] +; CHECK: bb242: +; CHECK-NEXT: br label [[BB243:%.*]] +; CHECK: bb243: +; CHECK-NEXT: [[TMP244:%.*]] = phi i64 [ 0, [[BB242]] ], [ [[TMP266:%.*]], [[BB265:%.*]] ] +; CHECK-NEXT: [[TMP245:%.*]] = getelementptr inbounds [[STRUCT_FOO]], %struct.foo* [[ARG]], i64 0, i32 65, i64 [[TMP244]], i32 5 +; CHECK-NEXT: [[TMP246:%.*]] = load i32, i32* [[TMP245]], align 4 +; CHECK-NEXT: [[TMP247:%.*]] = icmp eq i32 [[TMP246]], 9 +; CHECK-NEXT: br i1 [[TMP247]], label [[BB248:%.*]], label [[BB265]] +; CHECK: bb248: +; CHECK-NEXT: [[TMP249:%.*]] = getelementptr inbounds [[STRUCT_FOO]], %struct.foo* [[ARG]], i64 0, i32 65, i64 [[TMP244]], i32 12 +; CHECK-NEXT: [[TMP250:%.*]] = load %struct.spam*, %struct.spam** [[TMP249]], align 16 +; CHECK-NEXT: [[TMP251:%.*]] = call i32 @baz(%struct.spam* [[TMP250]], %struct.bar.0* nonnull dereferenceable(16) [[TMP6]], float 1.000000e+01, %struct.bar.0* null, float* null) +; CHECK-NEXT: [[TMP252:%.*]] = icmp eq i32 [[TMP251]], 0 +; CHECK-NEXT: br i1 [[TMP252]], label [[BB265]], label [[BB253:%.*]] +; CHECK: bb253: +; CHECK-NEXT: [[TMP255:%.*]] = getelementptr inbounds [[STRUCT_FOO]], %struct.foo* [[ARG]], i64 0, i32 65, i64 [[TMP244]], i32 6 +; CHECK-NEXT: [[TMP256:%.*]] = load i32, i32* [[TMP255]], align 8 +; CHECK-NEXT: store i32 [[TMP256]], i32* [[TMP238]], align 4 +; CHECK-NEXT: br label [[BB258]] +; CHECK: bb257: +; CHECK-NEXT: br label [[BB258]] +; CHECK: bb258: +; CHECK-NEXT: [[TMP259:%.*]] = getelementptr inbounds [[STRUCT_SPAM_298]], %struct.spam.298* [[ARG2]], i64 0, i32 0, i32 24 +; CHECK-NEXT: [[TMP260:%.*]] = getelementptr inbounds [[STRUCT_SPAM_298]], %struct.spam.298* [[ARG2]], i64 0, i32 0, i32 25 +; CHECK-NEXT: [[TMP261:%.*]] = getelementptr inbounds [[STRUCT_SPAM_298]], %struct.spam.298* [[ARG2]], i64 0, i32 0, i32 2 +; CHECK-NEXT: [[TMP262:%.*]] = getelementptr inbounds [[STRUCT_SPAM_298]], %struct.spam.298* [[ARG2]], i64 0, i32 0, i32 26 +; CHECK-NEXT: br label [[BB270:%.*]] +; CHECK: bb265: +; CHECK-NEXT: [[TMP266]] = add nuw i64 [[TMP244]], 1 +; CHECK-NEXT: [[TMP267:%.*]] = load i32, i32* [[TMP239]], align 16 +; CHECK-NEXT: [[TMP268:%.*]] = sext i32 [[TMP267]] to i64 +; CHECK-NEXT: [[TMP269:%.*]] = icmp slt i64 [[TMP266]], [[TMP268]] +; CHECK-NEXT: br i1 [[TMP269]], label [[BB243]], label [[BB257:%.*]] +; CHECK: bb270: +; CHECK-NEXT: [[TMP271:%.*]] = phi i32 [ [[TMP369:%.*]], [[BB368:%.*]] ], [ 0, [[BB258]] ] +; CHECK-NEXT: [[TMP272:%.*]] = load i32, i32* [[TMP259]], align 8 +; CHECK-NEXT: [[TMP273:%.*]] = icmp eq i32 [[TMP272]], -1 +; CHECK-NEXT: br i1 [[TMP273]], label [[BB317:%.*]], label [[BB274:%.*]] +; CHECK: bb274: +; CHECK-NEXT: [[TMP275:%.*]] = load i16, i16* [[TMP262]], align 16 +; CHECK-NEXT: [[TMP276:%.*]] = icmp sgt i16 [[TMP275]], -1 +; CHECK-NEXT: br i1 [[TMP276]], label [[BB277:%.*]], label [[BB279:%.*]] +; CHECK: bb277: +; CHECK-NEXT: [[TMP278:%.*]] = sext i16 [[TMP275]] to i32 +; CHECK-NEXT: br label [[BB317]] +; CHECK: bb279: +; CHECK-NEXT: [[TMP280:%.*]] = load i32, i32* [[TMP260]], align 4 +; CHECK-NEXT: [[TMP281:%.*]] = icmp sgt i32 [[TMP280]], 0 +; CHECK-NEXT: [[TMP282:%.*]] = select i1 [[TMP281]], i32 [[TMP280]], i32 0 +; CHECK-NEXT: [[TMP283:%.*]] = load %struct.quux.28*, %struct.quux.28** [[TMP261]], align 8 +; CHECK-NEXT: [[TMP284:%.*]] = getelementptr inbounds [[STRUCT_QUUX_28:%.*]], %struct.quux.28* [[TMP283]], i64 0, i32 16 +; CHECK-NEXT: [[TMP285:%.*]] = load i32, i32* [[TMP284]], align 16 +; CHECK-NEXT: [[TMP286:%.*]] = icmp slt i32 [[TMP282]], [[TMP285]] +; CHECK-NEXT: br i1 [[TMP286]], label [[BB287:%.*]], label [[BB292:%.*]] +; CHECK: bb287: +; CHECK-NEXT: [[TMP288:%.*]] = zext i32 [[TMP282]] to i64 +; CHECK-NEXT: [[TMP289:%.*]] = getelementptr inbounds [[STRUCT_QUUX_28]], %struct.quux.28* [[TMP283]], i64 0, i32 15, i32 0 +; CHECK-NEXT: br label [[BB295:%.*]] +; CHECK: bb290: +; CHECK-NEXT: br label [[BB292]] +; CHECK: bb292: +; CHECK-NEXT: [[TMP293:%.*]] = phi i32 [ 0, [[BB279]] ], [ [[TMP312:%.*]], [[BB290:%.*]] ] +; CHECK-NEXT: [[TMP294:%.*]] = trunc i32 [[TMP293]] to i16 +; CHECK-NEXT: store i16 [[TMP294]], i16* [[TMP262]], align 16 +; CHECK-NEXT: br label [[BB317]] +; CHECK: bb295: +; CHECK-NEXT: [[TMP296:%.*]] = phi i64 [ [[TMP288]], [[BB287]] ], [ [[TMP313:%.*]], [[BB311:%.*]] ] +; CHECK-NEXT: [[TMP297:%.*]] = phi i32 [ 0, [[BB287]] ], [ [[TMP312]], [[BB311]] ] +; CHECK-NEXT: [[TMP298:%.*]] = load %struct.spam.298**, %struct.spam.298*** [[TMP289]], align 8 +; CHECK-NEXT: [[TMP299:%.*]] = getelementptr inbounds %struct.spam.298*, %struct.spam.298** [[TMP298]], i64 [[TMP296]] +; CHECK-NEXT: [[TMP300:%.*]] = bitcast %struct.spam.298** [[TMP299]] to %struct.zot.614** +; CHECK-NEXT: [[TMP301:%.*]] = load %struct.zot.614*, %struct.zot.614** [[TMP300]], align 8 +; CHECK-NEXT: [[TMP302:%.*]] = getelementptr inbounds [[STRUCT_ZOT_614:%.*]], %struct.zot.614* [[TMP301]], i64 0, i32 23 +; CHECK-NEXT: [[TMP303:%.*]] = load i32, i32* [[TMP302]], align 4 +; CHECK-NEXT: [[TMP304:%.*]] = icmp eq i32 [[TMP272]], [[TMP303]] +; CHECK-NEXT: br i1 [[TMP304]], label [[BB305:%.*]], label [[BB311]] +; CHECK: bb305: +; CHECK-NEXT: [[TMP306:%.*]] = icmp eq i32 [[TMP297]], 0 +; CHECK-NEXT: br i1 [[TMP306]], label [[BB307:%.*]], label [[BB309:%.*]] +; CHECK: bb307: +; CHECK-NEXT: [[TMP308:%.*]] = trunc i64 [[TMP296]] to i32 +; CHECK-NEXT: store i32 [[TMP308]], i32* [[TMP260]], align 4 +; CHECK-NEXT: br label [[BB309]] +; CHECK: bb309: +; CHECK-NEXT: [[TMP310:%.*]] = add nsw i32 [[TMP297]], 1 +; CHECK-NEXT: br label [[BB311]] +; CHECK: bb311: +; CHECK-NEXT: [[TMP312]] = phi i32 [ [[TMP310]], [[BB309]] ], [ [[TMP297]], [[BB295]] ] +; CHECK-NEXT: [[TMP313]] = add nuw nsw i64 [[TMP296]], 1 +; CHECK-NEXT: [[TMP314:%.*]] = load i32, i32* [[TMP284]], align 16 +; CHECK-NEXT: [[TMP315:%.*]] = sext i32 [[TMP314]] to i64 +; CHECK-NEXT: [[TMP316:%.*]] = icmp slt i64 [[TMP313]], [[TMP315]] +; CHECK-NEXT: br i1 [[TMP316]], label [[BB295]], label [[BB290]] +; CHECK: bb317: +; CHECK-NEXT: [[TMP318:%.*]] = phi i32 [ [[TMP278]], [[BB277]] ], [ [[TMP293]], [[BB292]] ], [ 0, [[BB270]] ] +; CHECK-NEXT: [[TMP319:%.*]] = icmp slt i32 [[TMP271]], [[TMP318]] +; CHECK-NEXT: br i1 [[TMP319]], label [[BB321:%.*]], label [[BB320:%.*]] +; CHECK: bb320: +; CHECK-NEXT: call void @llvm.lifetime.end(i64 16, i8* nonnull [[TMP229]]) #4 +; CHECK-NEXT: call void @llvm.lifetime.end(i64 32, i8* nonnull [[TMP7]]) #4 +; CHECK-NEXT: ret i32 1 +; CHECK: bb321: +; CHECK-NEXT: br i1 [[TMP273]], label [[BB368]], label [[BB324:%.*]] +; CHECK: bb324: +; CHECK-NEXT: [[TMP325:%.*]] = load i32, i32* [[TMP260]], align 4 +; CHECK-NEXT: [[TMP326:%.*]] = icmp sgt i32 [[TMP325]], 0 +; CHECK-NEXT: [[TMP327:%.*]] = select i1 [[TMP326]], i32 [[TMP325]], i32 0 +; CHECK-NEXT: [[TMP328:%.*]] = load %struct.quux.28*, %struct.quux.28** [[TMP261]], align 8 +; CHECK-NEXT: [[TMP329:%.*]] = getelementptr inbounds [[STRUCT_QUUX_28]], %struct.quux.28* [[TMP328]], i64 0, i32 16 +; CHECK-NEXT: [[TMP330:%.*]] = load i32, i32* [[TMP329]], align 16 +; CHECK-NEXT: [[TMP331:%.*]] = icmp slt i32 [[TMP327]], [[TMP330]] +; CHECK-NEXT: br i1 [[TMP331]], label [[BB332:%.*]], label [[BB368]] +; CHECK: bb332: +; CHECK-NEXT: [[TMP333:%.*]] = zext i32 [[TMP327]] to i64 +; CHECK-NEXT: [[TMP334:%.*]] = getelementptr inbounds [[STRUCT_QUUX_28]], %struct.quux.28* [[TMP328]], i64 0, i32 15, i32 0 +; CHECK-NEXT: br label [[BB335:%.*]] +; CHECK: bb335: +; CHECK-NEXT: [[TMP336:%.*]] = phi i64 [ [[TMP333]], [[BB332]] ], [ [[TMP355:%.*]], [[BB353:%.*]] ] +; CHECK-NEXT: [[TMP337:%.*]] = phi i32 [ 0, [[BB332]] ], [ [[TMP354:%.*]], [[BB353]] ] +; CHECK-NEXT: [[TMP338:%.*]] = load %struct.spam.298**, %struct.spam.298*** [[TMP334]], align 8 +; CHECK-NEXT: [[TMP339:%.*]] = getelementptr inbounds %struct.spam.298*, %struct.spam.298** [[TMP338]], i64 [[TMP336]] +; CHECK-NEXT: [[TMP340:%.*]] = bitcast %struct.spam.298** [[TMP339]] to %struct.zot.614** +; CHECK-NEXT: [[TMP341:%.*]] = load %struct.zot.614*, %struct.zot.614** [[TMP340]], align 8 +; CHECK-NEXT: [[TMP342:%.*]] = getelementptr inbounds [[STRUCT_ZOT_614]], %struct.zot.614* [[TMP341]], i64 0, i32 23 +; CHECK-NEXT: [[TMP343:%.*]] = load i32, i32* [[TMP342]], align 4 +; CHECK-NEXT: [[TMP344:%.*]] = icmp eq i32 [[TMP272]], [[TMP343]] +; CHECK-NEXT: br i1 [[TMP344]], label [[BB345:%.*]], label [[BB353]] +; CHECK: bb345: +; CHECK-NEXT: [[TMP346:%.*]] = icmp eq i32 [[TMP337]], 0 +; CHECK-NEXT: br i1 [[TMP346]], label [[BB347:%.*]], label [[BB349:%.*]] +; CHECK: bb347: +; CHECK-NEXT: [[TMP348:%.*]] = trunc i64 [[TMP336]] to i32 +; CHECK-NEXT: store i32 [[TMP348]], i32* [[TMP260]], align 4 +; CHECK-NEXT: br label [[BB349]] +; CHECK: bb349: +; CHECK-NEXT: [[TMP350:%.*]] = icmp eq i32 [[TMP337]], [[TMP271]] +; CHECK-NEXT: br i1 [[TMP350]], label [[BB359:%.*]], label [[BB351:%.*]] +; CHECK: bb351: +; CHECK-NEXT: [[TMP352:%.*]] = add nsw i32 [[TMP337]], 1 +; CHECK-NEXT: br label [[BB353]] +; CHECK: bb353: +; CHECK-NEXT: [[TMP354]] = phi i32 [ [[TMP352]], [[BB351]] ], [ [[TMP337]], [[BB335]] ] +; CHECK-NEXT: [[TMP355]] = add nuw nsw i64 [[TMP336]], 1 +; CHECK-NEXT: [[TMP356:%.*]] = load i32, i32* [[TMP329]], align 16 +; CHECK-NEXT: [[TMP357:%.*]] = sext i32 [[TMP356]] to i64 +; CHECK-NEXT: [[TMP358:%.*]] = icmp slt i64 [[TMP355]], [[TMP357]] +; CHECK-NEXT: br i1 [[TMP358]], label [[BB335]], label [[BB367:%.*]] +; CHECK: bb359: +; CHECK-NEXT: [[TMP361:%.*]] = load %struct.spam.298**, %struct.spam.298*** [[TMP334]], align 8 +; CHECK-NEXT: [[TMP362:%.*]] = getelementptr inbounds %struct.spam.298*, %struct.spam.298** [[TMP361]], i64 [[TMP336]] +; CHECK-NEXT: [[TMP363:%.*]] = load %struct.spam.298*, %struct.spam.298** [[TMP362]], align 8 +; CHECK-NEXT: [[TMP364:%.*]] = icmp eq %struct.spam.298* [[TMP363]], null +; CHECK-NEXT: br i1 [[TMP364]], label [[BB368]], label [[BB365:%.*]] +; CHECK: bb365: +; CHECK-NEXT: [[TMP366:%.*]] = call i32 @wombat(%struct.foo* undef, %struct.eggs* [[ARG1]], %struct.spam.298* nonnull [[TMP363]]) +; CHECK-NEXT: br label [[BB368]] +; CHECK: bb367: +; CHECK-NEXT: br label [[BB368]] +; CHECK: bb368: +; CHECK-NEXT: [[TMP369]] = add nuw nsw i32 [[TMP271]], 1 +; CHECK-NEXT: br label [[BB270]] +; CHECK: bb370: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB372:%.*]] +; CHECK: bb372: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB374:%.*]] +; CHECK: bb374: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB376:%.*]] +; CHECK: bb376: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB378:%.*]] +; CHECK: bb378: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB380:%.*]] +; CHECK: bb380: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB382:%.*]] +; CHECK: bb382: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB384:%.*]] +; CHECK: bb384: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB386:%.*]] +; CHECK: bb386: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB388:%.*]] +; CHECK: bb388: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB390:%.*]] +; CHECK: bb390: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB392:%.*]] +; CHECK: bb392: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB394:%.*]] +; CHECK: bb394: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB396:%.*]] +; CHECK: bb396: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB398:%.*]] +; CHECK: bb398: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB400:%.*]] +; CHECK: bb400: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB402:%.*]] +; CHECK: bb402: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB404:%.*]] +; CHECK: bb404: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB406:%.*]] +; CHECK: bb406: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB408:%.*]] +; CHECK: bb408: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB410:%.*]] +; CHECK: bb410: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB412:%.*]] +; CHECK: bb412: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB414:%.*]] +; CHECK: bb414: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB416:%.*]] +; CHECK: bb416: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB418:%.*]] +; CHECK: bb418: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB420:%.*]] +; CHECK: bb420: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB422:%.*]] +; CHECK: bb422: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB424:%.*]] +; CHECK: bb424: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB426:%.*]] +; CHECK: bb426: +; CHECK-NEXT: br i1 true, label [[BB153]], label [[BB428]] +; CHECK: bb428: +; CHECK-NEXT: br label [[BB155]] +; +bb: + %tmp = alloca [32 x i8], align 16 + %tmp4 = alloca [256 x i8], align 16 + %tmp5 = alloca { <2 x float>, <2 x float> }, align 16 + %tmp6 = bitcast { <2 x float>, <2 x float> }* %tmp5 to %struct.bar.0* + tail call void @pluto(%struct.eggs* %arg1) + %tmp7 = getelementptr inbounds [32 x i8], [32 x i8]* %tmp, i64 0, i64 0 + call void @llvm.lifetime.start(i64 32, i8* nonnull %tmp7) #4 + %tmp8 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 19 + %tmp9 = load i8*, i8** %tmp8, align 16 + br label %bb10 + +bb10: ; preds = %bb16, %bb + %tmp11 = phi i8* [ %tmp9, %bb ], [ %tmp17, %bb16 ] + %tmp12 = load i8, i8* %tmp11, align 1 + %tmp13 = icmp eq i8 %tmp12, 95 + br i1 %tmp13, label %bb16, label %bb14 + +bb14: ; preds = %bb10 + %tmp15 = phi i8* [ %tmp11, %bb10 ] + br label %bb20 + +bb16: ; preds = %bb10 + %tmp17 = getelementptr inbounds i8, i8* %tmp11, i64 1 + %tmp18 = load i8, i8* %tmp17, align 1 + %tmp19 = icmp eq i8 %tmp18, 0 + br i1 %tmp19, label %bb30, label %bb10 + +bb20: ; preds = %bb24, %bb14 + %tmp21 = phi i8* [ %tmp25, %bb24 ], [ %tmp15, %bb14 ] + %tmp22 = phi i8* [ %tmp26, %bb24 ], [ %tmp7, %bb14 ] + %tmp23 = load i8, i8* %tmp21, align 1 + switch i8 %tmp23, label %bb24 [ + i8 95, label %bb27 + i8 0, label %bb27 + ] + +bb24: ; preds = %bb20 + %tmp25 = getelementptr inbounds i8, i8* %tmp21, i64 1 + %tmp26 = getelementptr inbounds i8, i8* %tmp22, i64 1 + store i8 %tmp23, i8* %tmp22, align 1 + br label %bb20 + +bb27: ; preds = %bb20, %bb20 + %tmp28 = phi i8* [ %tmp21, %bb20 ], [ %tmp21, %bb20 ] + %tmp29 = phi i8* [ %tmp22, %bb20 ], [ %tmp22, %bb20 ] + br label %bb32 + +bb30: ; preds = %bb16 + %tmp31 = phi i8* [ %tmp17, %bb16 ] + br label %bb32 + +bb32: ; preds = %bb30, %bb27 + %tmp33 = phi i8* [ %tmp29, %bb27 ], [ %tmp7, %bb30 ] + %tmp34 = phi i8* [ %tmp28, %bb27 ], [ %tmp31, %bb30 ] + store i8 0, i8* %tmp33, align 1 + %tmp35 = getelementptr inbounds %struct.eggs, %struct.eggs* %arg1, i64 0, i32 5 + store i32 %arg3, i32* %tmp35, align 4 + br label %bb36 + +bb36: ; preds = %bb42, %bb32 + %tmp37 = phi i8* [ %tmp34, %bb32 ], [ %tmp43, %bb42 ] + %tmp38 = load i8, i8* %tmp37, align 1 + %tmp39 = icmp eq i8 %tmp38, 95 + br i1 %tmp39, label %bb42, label %bb40 + +bb40: ; preds = %bb36 + %tmp41 = phi i8* [ %tmp37, %bb36 ] + br label %bb46 + +bb42: ; preds = %bb36 + %tmp43 = getelementptr inbounds i8, i8* %tmp37, i64 1 + %tmp44 = load i8, i8* %tmp43, align 1 + %tmp45 = icmp eq i8 %tmp44, 0 + br i1 %tmp45, label %bb56, label %bb36 + +bb46: ; preds = %bb50, %bb40 + %tmp47 = phi i8* [ %tmp51, %bb50 ], [ %tmp41, %bb40 ] + %tmp48 = phi i8* [ %tmp52, %bb50 ], [ %tmp7, %bb40 ] + %tmp49 = load i8, i8* %tmp47, align 1 + switch i8 %tmp49, label %bb50 [ + i8 95, label %bb53 + i8 0, label %bb53 + ] + +bb50: ; preds = %bb46 + %tmp51 = getelementptr inbounds i8, i8* %tmp47, i64 1 + %tmp52 = getelementptr inbounds i8, i8* %tmp48, i64 1 + store i8 %tmp49, i8* %tmp48, align 1 + br label %bb46 + +bb53: ; preds = %bb46, %bb46 + %tmp54 = phi i8* [ %tmp47, %bb46 ], [ %tmp47, %bb46 ] + %tmp55 = phi i8* [ %tmp48, %bb46 ], [ %tmp48, %bb46 ] + br label %bb58 + +bb56: ; preds = %bb42 + %tmp57 = phi i8* [ %tmp43, %bb42 ] + br label %bb58 + +bb58: ; preds = %bb56, %bb53 + %tmp59 = phi i8* [ %tmp55, %bb53 ], [ %tmp7, %bb56 ] + %tmp60 = phi i8* [ %tmp54, %bb53 ], [ %tmp57, %bb56 ] + store i8 0, i8* %tmp59, align 1 + %tmp61 = load i32, i32* %tmp35, align 4 + %tmp62 = icmp eq i32 %tmp61, 10 + br i1 %tmp62, label %bb63, label %bb93 + +bb63: ; preds = %bb58 + %tmp64 = getelementptr inbounds [256 x i8], [256 x i8]* %tmp4, i64 0, i64 0 + call void @llvm.lifetime.start(i64 256, i8* nonnull %tmp64) #4 + %tmp65 = load i8*, i8** %tmp8, align 16 + %tmp66 = getelementptr inbounds i8, i8* %tmp65, i64 10 + br label %bb67 + +bb67: ; preds = %bb73, %bb63 + %tmp68 = phi i64 [ %tmp77, %bb73 ], [ 1, %bb63 ] + %tmp69 = phi i8* [ %tmp75, %bb73 ], [ %tmp66, %bb63 ] + %tmp70 = phi i8* [ %tmp74, %bb73 ], [ %tmp64, %bb63 ] + %tmp71 = load i8, i8* %tmp69, align 1 + store i8 %tmp71, i8* %tmp70, align 1 + %tmp72 = icmp eq i8 %tmp71, 0 + br i1 %tmp72, label %bb80, label %bb73 + +bb73: ; preds = %bb67 + %tmp74 = getelementptr inbounds i8, i8* %tmp70, i64 1 + %tmp75 = getelementptr inbounds i8, i8* %tmp69, i64 1 + %tmp76 = icmp ult i64 %tmp68, 255 + %tmp77 = add nuw nsw i64 %tmp68, 1 + br i1 %tmp76, label %bb67, label %bb78 + +bb78: ; preds = %bb73 + %tmp79 = phi i8* [ %tmp74, %bb73 ] + store i8 0, i8* %tmp79, align 1 + br label %bb81 + +bb80: ; preds = %bb67 + br label %bb81 + +bb81: ; preds = %bb80, %bb78 + %tmp82 = call i8* @hoge(i8* nonnull %tmp64, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @global.1, i64 0, i64 0)) + %tmp83 = icmp eq i8* %tmp82, null + br i1 %tmp83, label %bb85, label %bb84 + +bb84: ; preds = %bb81 + store i8 0, i8* %tmp82, align 1 + br label %bb85 + +bb85: ; preds = %bb84, %bb81 + %tmp86 = load %struct.foo.321*, %struct.foo.321** bitcast (%struct.bar** @global.3 to %struct.foo.321**), align 8 + %tmp87 = getelementptr inbounds %struct.foo.321, %struct.foo.321* %tmp86, i64 0, i32 131 + %tmp88 = load %struct.quux.605*, %struct.quux.605** %tmp87, align 16 + %tmp89 = call i32 @foo(%struct.quux.605* %tmp88, i32 0, i8* nonnull %tmp64) + %tmp90 = icmp sgt i32 %tmp89, 0 + %tmp91 = select i1 %tmp90, i32 %tmp89, i32 0 + %tmp92 = getelementptr inbounds %struct.eggs, %struct.eggs* %arg1, i64 0, i32 6 + store i32 %tmp91, i32* %tmp92, align 8 + call void @llvm.lifetime.end(i64 256, i8* nonnull %tmp64) #4 + br label %bb97 + +bb93: ; preds = %bb58 + %tmp94 = call i64 @ham(i8* nonnull %tmp7, i8** null, i32 10) + %tmp95 = trunc i64 %tmp94 to i32 + %tmp96 = getelementptr inbounds %struct.eggs, %struct.eggs* %arg1, i64 0, i32 6 + store i32 %tmp95, i32* %tmp96, align 8 + br label %bb97 + +bb97: ; preds = %bb93, %bb85 + %tmp98 = load i8, i8* %tmp60, align 1 + %tmp99 = icmp eq i8 %tmp98, 0 + br i1 %tmp99, label %bb155, label %bb100 + +bb100: ; preds = %bb97 + br label %bb101 + +bb101: ; preds = %bb107, %bb100 + %tmp102 = phi i8* [ %tmp108, %bb107 ], [ %tmp60, %bb100 ] + %tmp103 = load i8, i8* %tmp102, align 1 + %tmp104 = icmp eq i8 %tmp103, 95 + br i1 %tmp104, label %bb107, label %bb105 + +bb105: ; preds = %bb101 + %tmp106 = phi i8* [ %tmp102, %bb101 ] + br label %bb111 + +bb107: ; preds = %bb101 + %tmp108 = getelementptr inbounds i8, i8* %tmp102, i64 1 + %tmp109 = load i8, i8* %tmp108, align 1 + %tmp110 = icmp eq i8 %tmp109, 0 + br i1 %tmp110, label %bb121, label %bb101 + +bb111: ; preds = %bb115, %bb105 + %tmp112 = phi i8* [ %tmp116, %bb115 ], [ %tmp106, %bb105 ] + %tmp113 = phi i8* [ %tmp117, %bb115 ], [ %tmp7, %bb105 ] + %tmp114 = load i8, i8* %tmp112, align 1 + switch i8 %tmp114, label %bb115 [ + i8 95, label %bb118 + i8 0, label %bb118 + ] + +bb115: ; preds = %bb111 + %tmp116 = getelementptr inbounds i8, i8* %tmp112, i64 1 + %tmp117 = getelementptr inbounds i8, i8* %tmp113, i64 1 + store i8 %tmp114, i8* %tmp113, align 1 + br label %bb111 + +bb118: ; preds = %bb111, %bb111 + %tmp119 = phi i8* [ %tmp112, %bb111 ], [ %tmp112, %bb111 ] + %tmp120 = phi i8* [ %tmp113, %bb111 ], [ %tmp113, %bb111 ] + br label %bb123 + +bb121: ; preds = %bb107 + %tmp122 = phi i8* [ %tmp108, %bb107 ] + br label %bb123 + +bb123: ; preds = %bb121, %bb118 + %tmp124 = phi i8* [ %tmp120, %bb118 ], [ %tmp7, %bb121 ] + %tmp125 = phi i8* [ %tmp119, %bb118 ], [ %tmp122, %bb121 ] + store i8 0, i8* %tmp124, align 1 + %tmp126 = load i8, i8* %tmp125, align 1 + %tmp127 = icmp ne i8 %tmp126, 95 + %tmp128 = load i8, i8* %tmp7, align 16 + %tmp129 = icmp eq i8 %tmp128, 0 + %tmp130 = or i1 %tmp127, %tmp129 + br i1 %tmp130, label %bb155, label %bb131 + +bb131: ; preds = %bb123 + %tmp132 = call i32 @wibble(i8* nonnull %tmp7, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @global, i64 0, i64 0)) + %tmp133 = icmp eq i32 %tmp132, 0 + %tmp134 = getelementptr inbounds %struct.eggs, %struct.eggs* %arg1, i64 0, i32 8, i64 0 + br i1 %tmp133, label %bb136, label %bb135 + +bb135: ; preds = %bb131 + br label %bb137 + +bb136: ; preds = %bb131 + br label %bb150 + +bb137: ; preds = %bb143, %bb135 + %tmp138 = phi i64 [ %tmp147, %bb143 ], [ 1, %bb135 ] + %tmp139 = phi i8* [ %tmp145, %bb143 ], [ %tmp7, %bb135 ] + %tmp140 = phi i8* [ %tmp144, %bb143 ], [ %tmp134, %bb135 ] + %tmp141 = load i8, i8* %tmp139, align 1 + store i8 %tmp141, i8* %tmp140, align 1 + %tmp142 = icmp eq i8 %tmp141, 0 + br i1 %tmp142, label %bb154, label %bb143 + +bb143: ; preds = %bb137 + %tmp144 = getelementptr inbounds i8, i8* %tmp140, i64 1 + %tmp145 = getelementptr inbounds i8, i8* %tmp139, i64 1 + %tmp146 = icmp ult i64 %tmp138, 31 + %tmp147 = add nuw nsw i64 %tmp138, 1 + br i1 %tmp146, label %bb137, label %bb148 + +bb148: ; preds = %bb143 + %tmp149 = phi i8* [ %tmp144, %bb143 ] + store i8 0, i8* %tmp149, align 1 + br label %bb155 + +bb150: ; preds = %bb136 + store i8 0, i8* %tmp134, align 1 + br i1 true, label %bb153, label %bb151 + +bb151: ; preds = %bb150 + %tmp152 = getelementptr inbounds i8, i8* %tmp134, i64 1 + store i8 0, i8* %tmp152, align 1 + br i1 true, label %bb153, label %bb370 + +bb153: ; preds = %bb426, %bb424, %bb422, %bb420, %bb418, %bb416, %bb414, %bb412, %bb410, %bb408, %bb406, %bb404, %bb402, %bb400, %bb398, %bb396, %bb394, %bb392, %bb390, %bb388, %bb386, %bb384, %bb382, %bb380, %bb378, %bb376, %bb374, %bb372, %bb370, %bb151, %bb150 + br label %bb155 + +bb154: ; preds = %bb137 + br label %bb155 + +bb155: ; preds = %bb428, %bb154, %bb153, %bb148, %bb123, %bb97 + %tmp156 = phi i8* [ %tmp125, %bb123 ], [ %tmp60, %bb97 ], [ %tmp125, %bb148 ], [ %tmp125, %bb428 ], [ %tmp125, %bb153 ], [ %tmp125, %bb154 ] + %tmp157 = load i8, i8* %tmp156, align 1 + %tmp158 = icmp eq i8 %tmp157, 0 + br i1 %tmp158, label %bb191, label %bb159 + +bb159: ; preds = %bb155 + br label %bb160 + +bb160: ; preds = %bb166, %bb159 + %tmp161 = phi i8* [ %tmp167, %bb166 ], [ %tmp156, %bb159 ] + %tmp162 = load i8, i8* %tmp161, align 1 + %tmp163 = icmp eq i8 %tmp162, 95 + br i1 %tmp163, label %bb166, label %bb164 + +bb164: ; preds = %bb160 + %tmp165 = phi i8* [ %tmp161, %bb160 ] + br label %bb170 + +bb166: ; preds = %bb160 + %tmp167 = getelementptr inbounds i8, i8* %tmp161, i64 1 + %tmp168 = load i8, i8* %tmp167, align 1 + %tmp169 = icmp eq i8 %tmp168, 0 + br i1 %tmp169, label %bb180, label %bb160 + +bb170: ; preds = %bb174, %bb164 + %tmp171 = phi i8* [ %tmp175, %bb174 ], [ %tmp165, %bb164 ] + %tmp172 = phi i8* [ %tmp176, %bb174 ], [ %tmp7, %bb164 ] + %tmp173 = load i8, i8* %tmp171, align 1 + switch i8 %tmp173, label %bb174 [ + i8 95, label %bb177 + i8 0, label %bb177 + ] + +bb174: ; preds = %bb170 + %tmp175 = getelementptr inbounds i8, i8* %tmp171, i64 1 + %tmp176 = getelementptr inbounds i8, i8* %tmp172, i64 1 + store i8 %tmp173, i8* %tmp172, align 1 + br label %bb170 + +bb177: ; preds = %bb170, %bb170 + %tmp178 = phi i8* [ %tmp171, %bb170 ], [ %tmp171, %bb170 ] + %tmp179 = phi i8* [ %tmp172, %bb170 ], [ %tmp172, %bb170 ] + br label %bb182 + +bb180: ; preds = %bb166 + %tmp181 = phi i8* [ %tmp167, %bb166 ] + br label %bb182 + +bb182: ; preds = %bb180, %bb177 + %tmp183 = phi i8* [ %tmp179, %bb177 ], [ %tmp7, %bb180 ] + %tmp184 = phi i8* [ %tmp178, %bb177 ], [ %tmp181, %bb180 ] + store i8 0, i8* %tmp183, align 1 + %tmp185 = load i8, i8* %tmp7, align 16 + %tmp186 = icmp eq i8 %tmp185, 0 + br i1 %tmp186, label %bb191, label %bb187 + +bb187: ; preds = %bb182 + %tmp188 = call i64 @ham(i8* nonnull %tmp7, i8** null, i32 10) + %tmp189 = trunc i64 %tmp188 to i32 + %tmp190 = getelementptr inbounds %struct.eggs, %struct.eggs* %arg1, i64 0, i32 9 + store i32 %tmp189, i32* %tmp190, align 16 + br label %bb191 + +bb191: ; preds = %bb187, %bb182, %bb155 + %tmp192 = phi i8* [ %tmp184, %bb187 ], [ %tmp184, %bb182 ], [ %tmp156, %bb155 ] + %tmp193 = load i8, i8* %tmp192, align 1 + %tmp194 = icmp eq i8 %tmp193, 0 + br i1 %tmp194, label %bb224, label %bb195 + +bb195: ; preds = %bb191 + br label %bb196 + +bb196: ; preds = %bb202, %bb195 + %tmp197 = phi i8* [ %tmp203, %bb202 ], [ %tmp192, %bb195 ] + %tmp198 = load i8, i8* %tmp197, align 1 + %tmp199 = icmp eq i8 %tmp198, 95 + br i1 %tmp199, label %bb202, label %bb200 + +bb200: ; preds = %bb196 + %tmp201 = phi i8* [ %tmp197, %bb196 ] + br label %bb206 + +bb202: ; preds = %bb196 + %tmp203 = getelementptr inbounds i8, i8* %tmp197, i64 1 + %tmp204 = load i8, i8* %tmp203, align 1 + %tmp205 = icmp eq i8 %tmp204, 0 + br i1 %tmp205, label %bb215, label %bb196 + +bb206: ; preds = %bb210, %bb200 + %tmp207 = phi i8* [ %tmp211, %bb210 ], [ %tmp201, %bb200 ] + %tmp208 = phi i8* [ %tmp212, %bb210 ], [ %tmp7, %bb200 ] + %tmp209 = load i8, i8* %tmp207, align 1 + switch i8 %tmp209, label %bb210 [ + i8 95, label %bb213 + i8 0, label %bb213 + ] + +bb210: ; preds = %bb206 + %tmp211 = getelementptr inbounds i8, i8* %tmp207, i64 1 + %tmp212 = getelementptr inbounds i8, i8* %tmp208, i64 1 + store i8 %tmp209, i8* %tmp208, align 1 + br label %bb206 + +bb213: ; preds = %bb206, %bb206 + %tmp214 = phi i8* [ %tmp208, %bb206 ], [ %tmp208, %bb206 ] + br label %bb216 + +bb215: ; preds = %bb202 + br label %bb216 + +bb216: ; preds = %bb215, %bb213 + %tmp217 = phi i8* [ %tmp214, %bb213 ], [ %tmp7, %bb215 ] + store i8 0, i8* %tmp217, align 1 + %tmp218 = load i8, i8* %tmp7, align 16 + %tmp219 = icmp eq i8 %tmp218, 0 + br i1 %tmp219, label %bb224, label %bb220 + +bb220: ; preds = %bb216 + %tmp221 = call i64 @ham(i8* nonnull %tmp7, i8** null, i32 10) + %tmp222 = trunc i64 %tmp221 to i32 + %tmp223 = getelementptr inbounds %struct.eggs, %struct.eggs* %arg1, i64 0, i32 11 + store i32 %tmp222, i32* %tmp223, align 8 + br label %bb224 + +bb224: ; preds = %bb220, %bb216, %bb191 + %tmp225 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 3 + %tmp226 = load %struct.ham*, %struct.ham** %tmp225, align 16 + %tmp227 = icmp eq %struct.ham* %tmp226, null + %tmp228 = select i1 %tmp227, %struct.ham* @global.2, %struct.ham* %tmp226 + call void @hoge.4(%struct.eggs* %arg1, %struct.ham* nonnull dereferenceable(64) %tmp228) + %tmp229 = bitcast { <2 x float>, <2 x float> }* %tmp5 to i8* + call void @llvm.lifetime.start(i64 16, i8* nonnull %tmp229) #4 + %tmp230 = load %struct.ham*, %struct.ham** %tmp225, align 16 + %tmp231 = icmp eq %struct.ham* %tmp230, null + %tmp232 = select i1 %tmp231, %struct.ham* @global.2, %struct.ham* %tmp230 + %tmp233 = call { <2 x float>, <2 x float> } @quux(%struct.ham* nonnull %tmp232) + %tmp234 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %tmp5, i64 0, i32 0 + %tmp235 = extractvalue { <2 x float>, <2 x float> } %tmp233, 0 + store <2 x float> %tmp235, <2 x float>* %tmp234, align 16 + %tmp236 = getelementptr inbounds { <2 x float>, <2 x float> }, { <2 x float>, <2 x float> }* %tmp5, i64 0, i32 1 + %tmp237 = extractvalue { <2 x float>, <2 x float> } %tmp233, 1 + store <2 x float> %tmp237, <2 x float>* %tmp236, align 8 + %tmp238 = getelementptr inbounds %struct.eggs, %struct.eggs* %arg1, i64 0, i32 7 + store i32 -1, i32* %tmp238, align 4 + %tmp239 = getelementptr inbounds %struct.foo, %struct.foo* %arg, i64 0, i32 66 + %tmp240 = load i32, i32* %tmp239, align 16 + %tmp241 = icmp sgt i32 %tmp240, 0 + br i1 %tmp241, label %bb242, label %bb258 + +bb242: ; preds = %bb224 + br label %bb243 + +bb243: ; preds = %bb265, %bb242 + %tmp244 = phi i64 [ 0, %bb242 ], [ %tmp266, %bb265 ] + %tmp245 = getelementptr inbounds %struct.foo, %struct.foo* %arg, i64 0, i32 65, i64 %tmp244, i32 5 + %tmp246 = load i32, i32* %tmp245, align 4 + %tmp247 = icmp eq i32 %tmp246, 9 + br i1 %tmp247, label %bb248, label %bb265 + +bb248: ; preds = %bb243 + %tmp249 = getelementptr inbounds %struct.foo, %struct.foo* %arg, i64 0, i32 65, i64 %tmp244, i32 12 + %tmp250 = load %struct.spam*, %struct.spam** %tmp249, align 16 + %tmp251 = call i32 @baz(%struct.spam* %tmp250, %struct.bar.0* nonnull dereferenceable(16) %tmp6, float 1.000000e+01, %struct.bar.0* null, float* null) + %tmp252 = icmp eq i32 %tmp251, 0 + br i1 %tmp252, label %bb265, label %bb253 + +bb253: ; preds = %bb248 + %tmp254 = phi i64 [ %tmp244, %bb248 ] + %tmp255 = getelementptr inbounds %struct.foo, %struct.foo* %arg, i64 0, i32 65, i64 %tmp254, i32 6 + %tmp256 = load i32, i32* %tmp255, align 8 + store i32 %tmp256, i32* %tmp238, align 4 + br label %bb258 + +bb257: ; preds = %bb265 + br label %bb258 + +bb258: ; preds = %bb257, %bb253, %bb224 + %tmp259 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 24 + %tmp260 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 25 + %tmp261 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 2 + %tmp262 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 26 + %tmp263 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 25 + %tmp264 = getelementptr inbounds %struct.spam.298, %struct.spam.298* %arg2, i64 0, i32 0, i32 2 + br label %bb270 + +bb265: ; preds = %bb248, %bb243 + %tmp266 = add nuw i64 %tmp244, 1 + %tmp267 = load i32, i32* %tmp239, align 16 + %tmp268 = sext i32 %tmp267 to i64 + %tmp269 = icmp slt i64 %tmp266, %tmp268 + br i1 %tmp269, label %bb243, label %bb257 + +bb270: ; preds = %bb368, %bb258 + %tmp271 = phi i32 [ %tmp369, %bb368 ], [ 0, %bb258 ] + %tmp272 = load i32, i32* %tmp259, align 8 + %tmp273 = icmp eq i32 %tmp272, -1 + br i1 %tmp273, label %bb317, label %bb274 + +bb274: ; preds = %bb270 + %tmp275 = load i16, i16* %tmp262, align 16 + %tmp276 = icmp sgt i16 %tmp275, -1 + br i1 %tmp276, label %bb277, label %bb279 + +bb277: ; preds = %bb274 + %tmp278 = sext i16 %tmp275 to i32 + br label %bb317 + +bb279: ; preds = %bb274 + %tmp280 = load i32, i32* %tmp263, align 4 + %tmp281 = icmp sgt i32 %tmp280, 0 + %tmp282 = select i1 %tmp281, i32 %tmp280, i32 0 + %tmp283 = load %struct.quux.28*, %struct.quux.28** %tmp264, align 8 + %tmp284 = getelementptr inbounds %struct.quux.28, %struct.quux.28* %tmp283, i64 0, i32 16 + %tmp285 = load i32, i32* %tmp284, align 16 + %tmp286 = icmp slt i32 %tmp282, %tmp285 + br i1 %tmp286, label %bb287, label %bb292 + +bb287: ; preds = %bb279 + %tmp288 = zext i32 %tmp282 to i64 + %tmp289 = getelementptr inbounds %struct.quux.28, %struct.quux.28* %tmp283, i64 0, i32 15, i32 0 + br label %bb295 + +bb290: ; preds = %bb311 + %tmp291 = phi i32 [ %tmp312, %bb311 ] + br label %bb292 + +bb292: ; preds = %bb290, %bb279 + %tmp293 = phi i32 [ 0, %bb279 ], [ %tmp291, %bb290 ] + %tmp294 = trunc i32 %tmp293 to i16 + store i16 %tmp294, i16* %tmp262, align 16 + br label %bb317 + +bb295: ; preds = %bb311, %bb287 + %tmp296 = phi i64 [ %tmp288, %bb287 ], [ %tmp313, %bb311 ] + %tmp297 = phi i32 [ 0, %bb287 ], [ %tmp312, %bb311 ] + %tmp298 = load %struct.spam.298**, %struct.spam.298*** %tmp289, align 8 + %tmp299 = getelementptr inbounds %struct.spam.298*, %struct.spam.298** %tmp298, i64 %tmp296 + %tmp300 = bitcast %struct.spam.298** %tmp299 to %struct.zot.614** + %tmp301 = load %struct.zot.614*, %struct.zot.614** %tmp300, align 8 + %tmp302 = getelementptr inbounds %struct.zot.614, %struct.zot.614* %tmp301, i64 0, i32 23 + %tmp303 = load i32, i32* %tmp302, align 4 + %tmp304 = icmp eq i32 %tmp272, %tmp303 + br i1 %tmp304, label %bb305, label %bb311 + +bb305: ; preds = %bb295 + %tmp306 = icmp eq i32 %tmp297, 0 + br i1 %tmp306, label %bb307, label %bb309 + +bb307: ; preds = %bb305 + %tmp308 = trunc i64 %tmp296 to i32 + store i32 %tmp308, i32* %tmp263, align 4 + br label %bb309 + +bb309: ; preds = %bb307, %bb305 + %tmp310 = add nsw i32 %tmp297, 1 + br label %bb311 + +bb311: ; preds = %bb309, %bb295 + %tmp312 = phi i32 [ %tmp310, %bb309 ], [ %tmp297, %bb295 ] + %tmp313 = add nuw nsw i64 %tmp296, 1 + %tmp314 = load i32, i32* %tmp284, align 16 + %tmp315 = sext i32 %tmp314 to i64 + %tmp316 = icmp slt i64 %tmp313, %tmp315 + br i1 %tmp316, label %bb295, label %bb290 + +bb317: ; preds = %bb292, %bb277, %bb270 + %tmp318 = phi i32 [ %tmp278, %bb277 ], [ %tmp293, %bb292 ], [ 0, %bb270 ] + %tmp319 = icmp slt i32 %tmp271, %tmp318 + br i1 %tmp319, label %bb321, label %bb320 + +bb320: ; preds = %bb317 + call void @llvm.lifetime.end(i64 16, i8* nonnull %tmp229) #4 + call void @llvm.lifetime.end(i64 32, i8* nonnull %tmp7) #4 + ret i32 1 + +bb321: ; preds = %bb317 + %tmp322 = load i32, i32* %tmp259, align 8 + %tmp323 = icmp eq i32 %tmp322, -1 + br i1 %tmp323, label %bb368, label %bb324 + +bb324: ; preds = %bb321 + %tmp325 = load i32, i32* %tmp260, align 4 + %tmp326 = icmp sgt i32 %tmp325, 0 + %tmp327 = select i1 %tmp326, i32 %tmp325, i32 0 + %tmp328 = load %struct.quux.28*, %struct.quux.28** %tmp261, align 8 + %tmp329 = getelementptr inbounds %struct.quux.28, %struct.quux.28* %tmp328, i64 0, i32 16 + %tmp330 = load i32, i32* %tmp329, align 16 + %tmp331 = icmp slt i32 %tmp327, %tmp330 + br i1 %tmp331, label %bb332, label %bb368 + +bb332: ; preds = %bb324 + %tmp333 = zext i32 %tmp327 to i64 + %tmp334 = getelementptr inbounds %struct.quux.28, %struct.quux.28* %tmp328, i64 0, i32 15, i32 0 + br label %bb335 + +bb335: ; preds = %bb353, %bb332 + %tmp336 = phi i64 [ %tmp333, %bb332 ], [ %tmp355, %bb353 ] + %tmp337 = phi i32 [ 0, %bb332 ], [ %tmp354, %bb353 ] + %tmp338 = load %struct.spam.298**, %struct.spam.298*** %tmp334, align 8 + %tmp339 = getelementptr inbounds %struct.spam.298*, %struct.spam.298** %tmp338, i64 %tmp336 + %tmp340 = bitcast %struct.spam.298** %tmp339 to %struct.zot.614** + %tmp341 = load %struct.zot.614*, %struct.zot.614** %tmp340, align 8 + %tmp342 = getelementptr inbounds %struct.zot.614, %struct.zot.614* %tmp341, i64 0, i32 23 + %tmp343 = load i32, i32* %tmp342, align 4 + %tmp344 = icmp eq i32 %tmp322, %tmp343 + br i1 %tmp344, label %bb345, label %bb353 + +bb345: ; preds = %bb335 + %tmp346 = icmp eq i32 %tmp337, 0 + br i1 %tmp346, label %bb347, label %bb349 + +bb347: ; preds = %bb345 + %tmp348 = trunc i64 %tmp336 to i32 + store i32 %tmp348, i32* %tmp260, align 4 + br label %bb349 + +bb349: ; preds = %bb347, %bb345 + %tmp350 = icmp eq i32 %tmp337, %tmp271 + br i1 %tmp350, label %bb359, label %bb351 + +bb351: ; preds = %bb349 + %tmp352 = add nsw i32 %tmp337, 1 + br label %bb353 + +bb353: ; preds = %bb351, %bb335 + %tmp354 = phi i32 [ %tmp352, %bb351 ], [ %tmp337, %bb335 ] + %tmp355 = add nuw nsw i64 %tmp336, 1 + %tmp356 = load i32, i32* %tmp329, align 16 + %tmp357 = sext i32 %tmp356 to i64 + %tmp358 = icmp slt i64 %tmp355, %tmp357 + br i1 %tmp358, label %bb335, label %bb367 + +bb359: ; preds = %bb349 + %tmp360 = phi i64 [ %tmp336, %bb349 ] + %tmp361 = load %struct.spam.298**, %struct.spam.298*** %tmp334, align 8 + %tmp362 = getelementptr inbounds %struct.spam.298*, %struct.spam.298** %tmp361, i64 %tmp360 + %tmp363 = load %struct.spam.298*, %struct.spam.298** %tmp362, align 8 + %tmp364 = icmp eq %struct.spam.298* %tmp363, null + br i1 %tmp364, label %bb368, label %bb365 + +bb365: ; preds = %bb359 + %tmp366 = call i32 @wombat(%struct.foo* undef, %struct.eggs* %arg1, %struct.spam.298* nonnull %tmp363) + br label %bb368 + +bb367: ; preds = %bb353 + br label %bb368 + +bb368: ; preds = %bb367, %bb365, %bb359, %bb324, %bb321 + %tmp369 = add nuw nsw i32 %tmp271, 1 + br label %bb270 + +bb370: ; preds = %bb151 + %tmp371 = getelementptr inbounds i8, i8* %tmp152, i64 1 + store i8 0, i8* %tmp371, align 1 + br i1 true, label %bb153, label %bb372 + +bb372: ; preds = %bb370 + %tmp373 = getelementptr inbounds i8, i8* %tmp371, i64 1 + store i8 0, i8* %tmp373, align 1 + br i1 true, label %bb153, label %bb374 + +bb374: ; preds = %bb372 + %tmp375 = getelementptr inbounds i8, i8* %tmp373, i64 1 + store i8 0, i8* %tmp375, align 1 + br i1 true, label %bb153, label %bb376 + +bb376: ; preds = %bb374 + %tmp377 = getelementptr inbounds i8, i8* %tmp375, i64 1 + store i8 0, i8* %tmp377, align 1 + br i1 true, label %bb153, label %bb378 + +bb378: ; preds = %bb376 + %tmp379 = getelementptr inbounds i8, i8* %tmp377, i64 1 + store i8 0, i8* %tmp379, align 1 + br i1 true, label %bb153, label %bb380 + +bb380: ; preds = %bb378 + %tmp381 = getelementptr inbounds i8, i8* %tmp379, i64 1 + store i8 0, i8* %tmp381, align 1 + br i1 true, label %bb153, label %bb382 + +bb382: ; preds = %bb380 + %tmp383 = getelementptr inbounds i8, i8* %tmp381, i64 1 + store i8 0, i8* %tmp383, align 1 + br i1 true, label %bb153, label %bb384 + +bb384: ; preds = %bb382 + %tmp385 = getelementptr inbounds i8, i8* %tmp383, i64 1 + store i8 0, i8* %tmp385, align 1 + br i1 true, label %bb153, label %bb386 + +bb386: ; preds = %bb384 + %tmp387 = getelementptr inbounds i8, i8* %tmp385, i64 1 + store i8 0, i8* %tmp387, align 1 + br i1 true, label %bb153, label %bb388 + +bb388: ; preds = %bb386 + %tmp389 = getelementptr inbounds i8, i8* %tmp387, i64 1 + store i8 0, i8* %tmp389, align 1 + br i1 true, label %bb153, label %bb390 + +bb390: ; preds = %bb388 + %tmp391 = getelementptr inbounds i8, i8* %tmp389, i64 1 + store i8 0, i8* %tmp391, align 1 + br i1 true, label %bb153, label %bb392 + +bb392: ; preds = %bb390 + %tmp393 = getelementptr inbounds i8, i8* %tmp391, i64 1 + store i8 0, i8* %tmp393, align 1 + br i1 true, label %bb153, label %bb394 + +bb394: ; preds = %bb392 + %tmp395 = getelementptr inbounds i8, i8* %tmp393, i64 1 + store i8 0, i8* %tmp395, align 1 + br i1 true, label %bb153, label %bb396 + +bb396: ; preds = %bb394 + %tmp397 = getelementptr inbounds i8, i8* %tmp395, i64 1 + store i8 0, i8* %tmp397, align 1 + br i1 true, label %bb153, label %bb398 + +bb398: ; preds = %bb396 + %tmp399 = getelementptr inbounds i8, i8* %tmp397, i64 1 + store i8 0, i8* %tmp399, align 1 + br i1 true, label %bb153, label %bb400 + +bb400: ; preds = %bb398 + %tmp401 = getelementptr inbounds i8, i8* %tmp399, i64 1 + store i8 0, i8* %tmp401, align 1 + br i1 true, label %bb153, label %bb402 + +bb402: ; preds = %bb400 + %tmp403 = getelementptr inbounds i8, i8* %tmp401, i64 1 + store i8 0, i8* %tmp403, align 1 + br i1 true, label %bb153, label %bb404 + +bb404: ; preds = %bb402 + %tmp405 = getelementptr inbounds i8, i8* %tmp403, i64 1 + store i8 0, i8* %tmp405, align 1 + br i1 true, label %bb153, label %bb406 + +bb406: ; preds = %bb404 + %tmp407 = getelementptr inbounds i8, i8* %tmp405, i64 1 + store i8 0, i8* %tmp407, align 1 + br i1 true, label %bb153, label %bb408 + +bb408: ; preds = %bb406 + %tmp409 = getelementptr inbounds i8, i8* %tmp407, i64 1 + store i8 0, i8* %tmp409, align 1 + br i1 true, label %bb153, label %bb410 + +bb410: ; preds = %bb408 + %tmp411 = getelementptr inbounds i8, i8* %tmp409, i64 1 + store i8 0, i8* %tmp411, align 1 + br i1 true, label %bb153, label %bb412 + +bb412: ; preds = %bb410 + %tmp413 = getelementptr inbounds i8, i8* %tmp411, i64 1 + store i8 0, i8* %tmp413, align 1 + br i1 true, label %bb153, label %bb414 + +bb414: ; preds = %bb412 + %tmp415 = getelementptr inbounds i8, i8* %tmp413, i64 1 + store i8 0, i8* %tmp415, align 1 + br i1 true, label %bb153, label %bb416 + +bb416: ; preds = %bb414 + %tmp417 = getelementptr inbounds i8, i8* %tmp415, i64 1 + store i8 0, i8* %tmp417, align 1 + br i1 true, label %bb153, label %bb418 + +bb418: ; preds = %bb416 + %tmp419 = getelementptr inbounds i8, i8* %tmp417, i64 1 + store i8 0, i8* %tmp419, align 1 + br i1 true, label %bb153, label %bb420 + +bb420: ; preds = %bb418 + %tmp421 = getelementptr inbounds i8, i8* %tmp419, i64 1 + store i8 0, i8* %tmp421, align 1 + br i1 true, label %bb153, label %bb422 + +bb422: ; preds = %bb420 + %tmp423 = getelementptr inbounds i8, i8* %tmp421, i64 1 + store i8 0, i8* %tmp423, align 1 + br i1 true, label %bb153, label %bb424 + +bb424: ; preds = %bb422 + %tmp425 = getelementptr inbounds i8, i8* %tmp423, i64 1 + store i8 0, i8* %tmp425, align 1 + br i1 true, label %bb153, label %bb426 + +bb426: ; preds = %bb424 + %tmp427 = getelementptr inbounds i8, i8* %tmp425, i64 1 + store i8 0, i8* %tmp427, align 1 + br i1 true, label %bb153, label %bb428 + +bb428: ; preds = %bb426 + %tmp429 = getelementptr inbounds i8, i8* %tmp427, i64 1 + store i8 0, i8* %tmp429, align 1 + br label %bb155 +} + +; Function Attrs: sspstrong uwtable +declare i32 @wombat(%struct.foo* nocapture readnone, %struct.eggs*, %struct.spam.298*) local_unnamed_addr #3 align 2 + +declare { <2 x float>, <2 x float> } @quux(%struct.ham*) local_unnamed_addr #2 + +; Function Attrs: nounwind readonly +declare i32 @wibble(i8* nocapture, i8* nocapture) local_unnamed_addr #1 + +declare i32 @foo(%struct.quux.605*, i32, i8*) local_unnamed_addr #2 + +declare void @hoge.4(%struct.eggs*, %struct.ham* dereferenceable(64)) local_unnamed_addr #2 + +declare i64 @ham(i8*, i8**, i32) local_unnamed_addr #2 + +attributes #0 = { argmemonly nounwind } +attributes #1 = { nounwind readonly "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="btver2" "target-features"="+aes,+avx,+bmi,+cx16,+f16c,+fxsr,+lzcnt,+mmx,+pclmul,+popcnt,+prfchw,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+x87,+xsave,+xsaveopt" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #2 = { "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="btver2" "target-features"="+aes,+avx,+bmi,+cx16,+f16c,+fxsr,+lzcnt,+mmx,+pclmul,+popcnt,+prfchw,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+x87,+xsave,+xsaveopt" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #3 = { sspstrong uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="btver2" "target-features"="+aes,+avx,+bmi,+cx16,+f16c,+fxsr,+lzcnt,+mmx,+pclmul,+popcnt,+prfchw,+sse,+sse2,+sse3,+sse4.1,+sse4.2,+sse4a,+ssse3,+x87,+xsave,+xsaveopt" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #4 = { nounwind } + +!llvm.module.flags = !{!0} +!llvm.ident = !{!1} + +!0 = !{i32 1, !"PIC Level", i32 2} +!1 = !{!"clang version 5.0.0 "} Index: test/Transforms/NewGVN/propagate-ir-flags.ll =================================================================== --- test/Transforms/NewGVN/propagate-ir-flags.ll +++ test/Transforms/NewGVN/propagate-ir-flags.ll @@ -1,4 +1,3 @@ -; XFAIL: * ; RUN: opt < %s -newgvn -S | FileCheck %s ; CHECK-LABEL: func_fast