[GVN] Strengthen the updating of dominated users

[jonpa]

Summary

This is a first effort to replace https://reviews.llvm.org/D90231, which aimed to exclude @llvm.is.constant() from value replacements. Instead, this patch takes the approach of improving GVN so that the failed test case compiles.

propagateEquality() calls replaceDominatedUsesWith() at the point where one Value can replace another one as long as it is dominated from a certain point. This patch makes sure that also the cases where a user that is not dominated by any such call can still be updated if all of its (parents) predecessors are dominated by such an equivalence. In other words, if there are multiple calls to replaceDominatedUsesWith() at different points with the same equivalency, they may together dominate a user.

This is needed to be able to compile Linux Kernel code with multiple __builtin_constant_p calls.

[jonpa]

This seems to have very limited impact on GVN in general: In total, only 3 branches and 2 comparisons less on SPEC 2017 (SystemZ). This means that the patch could probably be reduced to more specifically handle the builtin_constant_p case and not much more...

[nickdesaulniers]

llvm/lib/Transforms/Utils/Local.cpp

2670

can probably use a range for here, too.

2677

can be range based for via predecessors(UBB).

[lebedev.ri]

As of D90231 i'm personally still unconvinced that it is the LLVM code that needs fixing and not the particular code that is using __builtin_constant_p().

[jonpa]

Patch updated per review, and also improved to handle even more cases by iteratively accumulating the dominance. This is needed in order to handle the same example with a sanitizer enabled, which inserts new blocks before the inline asm call (see new test case @fun1).

I factored out a dominates(BB) function into the DominanceSources class. I thought about also putting an "accumulateDomince()" method there, but for now that is done directly in replaceDominatedUsesWith().

As of D90231 i'm personally still unconvinced that it is the LLVM code that needs fixing and not the particular code that is using __builtin_constant_p().

The s390 Linux kernel code in question here is (IMO) undoubtedly impractical, but it seems they have their reasons for that and it would be very helpful if clang could support it, or it seems clang can't be used for the Linux kernel on SystemZ, which would be a shame.

[jonpa]

I have it now confirmed that this patch fixes the kernel issues on SystemZ: "This patch seems to fix all the kernel build issues. It builds, it runs, all looks good...".

[jonpa]

ping!

[jonpa]

ping!

[lebedev.ri]

In D91786#2406652, @lebedev.ri wrote:

As of D90231 i'm personally still unconvinced that it is the LLVM code that needs fixing and not the particular code that is using __builtin_constant_p().

^ still am.
Are langref changes needed to justify these optimization changes?

[jonpa]

In D91786#2474795, @lebedev.ri wrote:

In D91786#2406652, @lebedev.ri wrote:

As of D90231 i'm personally still unconvinced that it is the LLVM code that needs fixing and not the particular code that is using __builtin_constant_p().

^ still am.
Are langref changes needed to justify these optimization changes?

The reason was that this code was somehow the result of some kind of generated code via macros that happened to turn out a certain way, I guess. However, the developers have now decided to change this after all to use builtin calls instead.

So you were right, and I abandon this now given that this doesn't give much as a general improvement... Thanks for review.

I wonder if I perhaps should add a small comment somewhere in GVN.cpp that this has been tried without much benefit?

llvm/include/llvm/IR/Dominators.h

public:
   /// Provide an overload for a Use.
   bool isReachableFromEntry(const Use &U) const;
 
   // Pop up a GraphViz/gv window with the Dominator Tree rendered using `dot`.
   void viewGraph(const Twine &Name, const Twine &Title);
   void viewGraph();
 };
 
+/// Edges and BBs hold a set of multiple points in the function.
+struct DominanceSources {
+  SmallVector<BasicBlockEdge, 4> Edges;
+  SmallPtrSet<const BasicBlock *, 8> BBs;
+  /// Returns true if all predecessors of BB are dominated by at least one
+  /// edge or block in Edges / BBs.
+  bool dominates(const BasicBlock *BB, DominatorTree &DT);
+};
+
 //===-------------------------------------
 // DominatorTree GraphTraits specializations so the DominatorTree can be
 // iterable by generic graph iterators.
 
 template <class Node, class ChildIterator> struct DomTreeGraphTraitsBase {
   using NodeRef = Node *;
   using ChildIteratorType = ChildIterator;
   using nodes_iterator = df_iterator<Node *, df_iterator_default_set<Node*>>;

llvm/include/llvm/Transforms/Scalar/GVN.h

private:
   // find back edge easily.
   DenseMap<AssertingVH<BasicBlock>, uint32_t> BlockRPONumber;
 
   // This is set 'true' initially and also when new blocks have been added to
   // the function being analyzed. This boolean is used to control the updating
   // of BlockRPONumber prior to accessing the contents of BlockRPONumber.
   bool InvalidBlockRPONumbers = true;
 
+  // A mapping from a known equivalence to all the sources of dominance where
+  // it is valid.
+  struct ValuePair : std::pair<Value *, Value *> {
+    ValuePair(Value *LHS, Value *RHS) : std::pair<Value *, Value *>(LHS, RHS) {}
+    bool operator<(const ValuePair &Other) const {
+      return first != Other.first ? first < Other.first : second < Other.second;
+    }
+  };
+  std::map<ValuePair, DominanceSources> EquivalenceSources;
+
+  // Walk through EquivalenceSources and replace any users now found to be
+  // dominated.
+  bool inferCollectiveDominance(Function &F);
+
   using LoadDepVect = SmallVector<NonLocalDepResult, 64>;
   using AvailValInBlkVect = SmallVector<gvn::AvailableValueInBlock, 64>;
   using UnavailBlkVect = SmallVector<BasicBlock *, 64>;
 
   bool runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
                const TargetLibraryInfo &RunTLI, AAResults &RunAA,
                MemoryDependenceResults *RunMD, LoopInfo *LI,
                OptimizationRemarkEmitter *ORE, MemorySSA *MSSA = nullptr);
private:
   bool performScalarPREInsertion(Instruction *Instr, BasicBlock *Pred,
                                  BasicBlock *Curr, unsigned int ValNo);
   Value *findLeader(const BasicBlock *BB, uint32_t num);
   void cleanupGlobalSets();
   void verifyRemoved(const Instruction *I) const;
   bool splitCriticalEdges();
   BasicBlock *splitCriticalEdges(BasicBlock *Pred, BasicBlock *Succ);
   bool replaceOperandsForInBlockEquality(Instruction *I) const;
+  bool replaceDominatedUsesWith(Value *From, Value *To,
+                                const BasicBlockEdge &Root);
+  bool replaceDominatedUsesWith(Value *From, Value *To, const BasicBlock *BB);
   bool propagateEquality(Value *LHS, Value *RHS, const BasicBlockEdge &Root,
                          bool DominatesByEdge);
   bool processFoldableCondBr(BranchInst *BI);
   void addDeadBlock(BasicBlock *BB);
   void assignValNumForDeadCode();
   void assignBlockRPONumber(Function &F);
 };
 

llvm/include/llvm/Transforms/Utils/Local.h

 /// the given edge.  Returns the number of replacements made.
 unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT,
                                   const BasicBlockEdge &Edge);
 /// Replace each use of 'From' with 'To' if that use is dominated by
 /// the end of the given BasicBlock. Returns the number of replacements made.
 unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT,
                                   const BasicBlock *BB);
 
+/// Replace each use of 'From' with 'To' if that use is dominated
+/// collectively by Sources. The blocks in F found to be dominated by Sources
+/// are inserted into Sources.BBs. Returns the number of replacements made.
+unsigned replaceDominatedUsesWith(Value *From, Value *To,
+                                  Function &F, DominatorTree &DT,
+                                  DominanceSources &Sources);
+
 /// Return true if this call calls a gc leaf function.
 ///
 /// A leaf function is a function that does not safepoint the thread during its
 /// execution.  During a call or invoke to such a function, the callers stack
 /// does not have to be made parseable.
 ///
 /// Most passes can and should ignore this information, and it is only used
 /// during lowering by the GC infrastructure.

llvm/lib/IR/Dominators.cpp

 // Edge BBE1 dominates edge BBE2 if they match or BBE1 dominates start of BBE2.
 bool DominatorTree::dominates(const BasicBlockEdge &BBE1,
                               const BasicBlockEdge &BBE2) const {
   if (BBE1.getStart() == BBE2.getStart() && BBE1.getEnd() == BBE2.getEnd())
     return true;
   return dominates(BBE1, BBE2.getStart());
 }
 
+bool DominanceSources::dominates(const BasicBlock *BB, DominatorTree &DT) {
+  if (!BB->hasNPredecessorsOrMore(1))
+    return false;
+  for (const BasicBlock *PredBB : predecessors(BB)) {
+    bool PredDominated = false;
+    for (const BasicBlockEdge &E : Edges)
+      if (DT.dominates(E, PredBB)) {
+        PredDominated = true;
+        break;
+      }
+    if (PredDominated)
+      continue;
+    for (const BasicBlock *SourceBB : BBs)
+      if (DT.dominates(SourceBB, PredBB)) {
+        PredDominated = true;
+        break;
+      }
+    if (!PredDominated)
+      return false;
+  }
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 //  DominatorTreeAnalysis and related pass implementations
 //===----------------------------------------------------------------------===//
 //
 // This implements the DominatorTreeAnalysis which is used with the new pass
 // manager. It also implements some methods from utility passes.
 //
 //===----------------------------------------------------------------------===//

llvm/lib/Transforms/Scalar/GVN.cpp

if (it != ReplaceOperandsWithMap.end()) {
                         << *it->second << " in instruction " << *Instr << '\n');
       Instr->setOperand(OpNum, it->second);
       Changed = true;
     }
   }
   return Changed;
 }
 
+bool GVN::inferCollectiveDominance(Function &F) {
+  bool Changed = false;
+  for (auto &I : EquivalenceSources) {
+    DominanceSources &Sources = I.second;
+    if (Sources.Edges.size() + Sources.BBs.size() < 2)
+      continue;
+    Value *From = I.first.first;
+    Value *To = I.first.second;
+    Changed |= llvm::replaceDominatedUsesWith(From, To, F, *DT, Sources);
+  }
+  return Changed;
+}
+
+bool GVN::replaceDominatedUsesWith(Value *From, Value *To,
+                                   const BasicBlockEdge &Root) {
+  EquivalenceSources[{From, To}].Edges.push_back(Root);
+  return llvm::replaceDominatedUsesWith(From, To, *DT, Root);
+}
+
+bool GVN::replaceDominatedUsesWith(Value *From, Value *To,
+                                   const BasicBlock *BB) {
+  EquivalenceSources[{From, To}].BBs.insert(BB);
+  return llvm::replaceDominatedUsesWith(From, To, *DT, BB);
+}
+
 /// The given values are known to be equal in every block
 /// dominated by 'Root'.  Exploit this, for example by replacing 'LHS' with
 /// 'RHS' everywhere in the scope.  Returns whether a change was made.
 /// If DominatesByEdge is false, then it means that we will propagate the RHS
 /// value starting from the end of Root.Start.
 bool GVN::propagateEquality(Value *LHS, Value *RHS, const BasicBlockEdge &Root,
                             bool DominatesByEdge) {
   SmallVector<std::pair<Value*, Value*>, 4> Worklist;
if (RootDominatesEnd && !isa<Instruction>(RHS))
       addToLeaderTable(LVN, RHS, Root.getEnd());
 
     // Replace all occurrences of 'LHS' with 'RHS' everywhere in the scope.  As
     // LHS always has at least one use that is not dominated by Root, this will
     // never do anything if LHS has only one use.
     if (!LHS->hasOneUse()) {
       unsigned NumReplacements =
           DominatesByEdge
-              ? replaceDominatedUsesWith(LHS, RHS, *DT, Root)
-              : replaceDominatedUsesWith(LHS, RHS, *DT, Root.getStart());
+              ? replaceDominatedUsesWith(LHS, RHS, Root)
+              : replaceDominatedUsesWith(LHS, RHS, Root.getStart());
 
       Changed |= NumReplacements > 0;
       NumGVNEqProp += NumReplacements;
       // Cached information for anything that uses LHS will be invalid.
       if (MD)
         MD->invalidateCachedPointerInfo(LHS);
     }
 
if (CmpInst *Cmp = dyn_cast<CmpInst>(LHS)) {
       uint32_t Num = VN.lookupOrAddCmp(Cmp->getOpcode(), NotPred, Op0, Op1);
       // If the number we were assigned was brand new then there is no point in
       // looking for an instruction realizing it: there cannot be one!
       if (Num < NextNum) {
         Value *NotCmp = findLeader(Root.getEnd(), Num);
         if (NotCmp && isa<Instruction>(NotCmp)) {
           unsigned NumReplacements =
               DominatesByEdge
-                  ? replaceDominatedUsesWith(NotCmp, NotVal, *DT, Root)
-                  : replaceDominatedUsesWith(NotCmp, NotVal, *DT,
-                                             Root.getStart());
+                  ? replaceDominatedUsesWith(NotCmp, NotVal, Root)
+                  : replaceDominatedUsesWith(NotCmp, NotVal, Root.getStart());
           Changed |= NumReplacements > 0;
           NumGVNEqProp += NumReplacements;
           // Cached information for anything that uses NotCmp will be invalid.
           if (MD)
             MD->invalidateCachedPointerInfo(NotCmp);
         }
       }
       // Ensure that any instruction in scope that gets the "A < B" value number
bool GVN::iterateOnFunction(Function &F) {
   // Needed for value numbering with phi construction to work.
   // RPOT walks the graph in its constructor and will not be invalidated during
   // processBlock.
   ReversePostOrderTraversal<Function *> RPOT(&F);
 
   for (BasicBlock *BB : RPOT)
     Changed |= processBlock(BB);
 
+  Changed |= inferCollectiveDominance(F);
+
   return Changed;
 }
 
 void GVN::cleanupGlobalSets() {
   VN.clear();
   LeaderTable.clear();
   BlockRPONumber.clear();
   TableAllocator.Reset();
   ICF->clear();
   InvalidBlockRPONumbers = true;
+  EquivalenceSources.clear();
 }
 
 /// Verify that the specified instruction does not occur in our
 /// internal data structures.
 void GVN::verifyRemoved(const Instruction *Inst) const {
   VN.verifyRemoved(Inst);
 
   // Walk through the value number scope to make sure the instruction isn't

llvm/lib/Transforms/Utils/Local.cpp

unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To,
                                         const BasicBlock *BB) {
   auto ProperlyDominates = [&DT](const BasicBlock *BB, const Use &U) {
     auto *I = cast<Instruction>(U.getUser())->getParent();
     return DT.properlyDominates(BB, I);
   };
   return ::replaceDominatedUsesWith(From, To, BB, ProperlyDominates);
 }
 
+unsigned llvm::replaceDominatedUsesWith(Value *From, Value *To,
+                                        Function &F, DominatorTree &DT,
+                                        DominanceSources &Sources) {
+  // Accumulate dominance in Sources.
+  bool Change = true;
+  while (Change) {
+    Change = false;
+    for (BasicBlock &BB : F)
+      if (!Sources.BBs.count(&BB) && Sources.dominates(&BB, DT)) {
+        Sources.BBs.insert(&BB);
+        Change = true;
+      }
+  }
+
+  unsigned NumUsesPrior = From->getNumUses();
+  From->replaceUsesWithIf(To, [Sources](Use &U) {
+    BasicBlock *UBB = cast<Instruction>(U.getUser())->getParent();
+    return Sources.BBs.count(UBB);
+  });
+  return NumUsesPrior - From->getNumUses();
+}
+
 bool llvm::callsGCLeafFunction(const CallBase *Call,
                                const TargetLibraryInfo &TLI) {
   // Check if the function is specifically marked as a gc leaf function.
   if (Call->hasFnAttr("gc-leaf-function"))
     return true;
   if (const Function *F = Call->getCalledFunction()) {
     if (F->hasFnAttribute("gc-leaf-function"))
       return true;

llvm/test/Transforms/builtin_constant.ll

+; RUN: opt < %s -O3 -S | FileCheck %s
+;
+; Check that the inline asm call has a constant 0 as argument. This can be
+; inferred from the function (which is derived from the Linux Kernel) where
+; nested __builtin_constant_p:s are used. Since the inline asm operand
+; constraint is "i", the argument must really be a constant 0, or else
+; compilation will fail. This test is run with '-O3' and not just '-gvn',
+; since it seems there is a newgvn which is supposed to replace gvn some day.
+
+@a = global i32 0
+@b = global i32 0
+
+define void @fun0() {
+; CHECK-LABEL: @fun0
+; CHECK: tail call void asm sideeffect "", "i"(i32 0)
+entry:
+  %tmp = alloca i32, align 4
+  %0 = load i32, i32* @a
+  %shl = shl i32 %0, 12
+  store i32 %shl, i32* @b
+  %1 = load i32, i32* @b
+  %cmp = icmp sgt i32 %1, -129
+  br i1 %cmp, label %land.lhs.true, label %land.end
+
+land.lhs.true:                                    ; preds = %entry
+  %2 = load i32, i32* @b
+  %cmp1 = icmp slt i32 %2, 128
+  br i1 %cmp1, label %land.rhs, label %land.end
+
+land.rhs:                                         ; preds = %land.lhs.true
+  %3 = load i32, i32* @b
+  %4 = call i1 @llvm.is.constant.i32(i32 %3)
+  br label %land.end
+
+land.end:                                         ; preds = %land.rhs, %land.lhs.true, %entry
+  %5 = phi i1 [ false, %land.lhs.true ], [ false, %entry ], [ %4, %land.rhs ]
+  %land.ext = zext i1 %5 to i32
+  %6 = call i1 @llvm.is.constant.i32(i32 %land.ext)
+  br i1 %6, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %land.end
+  %7 = load i32, i32* @b
+  %cmp2 = icmp sgt i32 %7, -129
+  br i1 %cmp2, label %land.lhs.true3, label %if.end
+
+land.lhs.true3:                                   ; preds = %cond.true
+  %8 = load i32, i32* @b
+  %cmp4 = icmp slt i32 %8, 128
+  br i1 %cmp4, label %land.lhs.true5, label %if.end
+
+land.lhs.true5:                                   ; preds = %land.lhs.true3
+  %9 = load i32, i32* @b
+  %10 = call i1 @llvm.is.constant.i32(i32 %9)
+  br i1 %10, label %if.then, label %if.end
+
+cond.false:                                       ; preds = %land.end
+  %11 = load i32, i32* @b
+  %cmp6 = icmp sgt i32 %11, -129
+  br i1 %cmp6, label %land.lhs.true7, label %land.end10
+
+land.lhs.true7:                                   ; preds = %cond.false
+  %12 = load i32, i32* @b
+  %cmp8 = icmp slt i32 %12, 128
+  br i1 %cmp8, label %land.rhs9, label %land.end10
+
+land.rhs9:                                        ; preds = %land.lhs.true7
+  %13 = load i32, i32* @b
+  %14 = call i1 @llvm.is.constant.i32(i32 %13)
+  br label %land.end10
+
+land.end10:                                       ; preds = %land.rhs9, %land.lhs.true7, %cond.false
+  %15 = phi i1 [ false, %land.lhs.true7 ], [ false, %cond.false ], [ %14, %land.rhs9 ]
+  %16 = zext i1 %15 to i64
+  %cond = select i1 %15, i32 1, i32 0
+  store i32 %cond, i32* %tmp
+  %17 = load i32, i32* %tmp
+  %tobool = icmp ne i32 %17, 0
+  br i1 %tobool, label %if.then, label %if.end
+
+if.then:                                          ; preds = %land.end10, %land.lhs.true5
+  %18 = load i32, i32* @b
+  call void asm sideeffect "", "i"(i32 %18)
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %land.end10, %land.lhs.true5, %land.lhs.true3, %cond.true
+  ret void
+}
+
+%struct.b = type { i64 }
+@d = dso_local global i64 0, align 8
+@c = dso_local global %struct.b* null, align 8
+@.src = private unnamed_addr constant [22 x i8] c"tc_builtin_constant.c\00", align 2
+@0 = private unnamed_addr constant { i16, i16, [4 x i8] } { i16 -1, i16 0, [4 x i8] c"'b'\00" }
+@1 = private unnamed_addr global { { [22 x i8]*, i32, i32 }, { i16, i16, [4 x i8] }*, i8, i8 } { { [22 x i8]*, i32, i32 } { [22 x i8]* @.src, i32 24, i32 22 }, { i16, i16, [4 x i8] }* @0, i8 1, i8 3 }
+
+define void @fun1() {
+; CHECK-LABEL: @fun1
+; CHECK: tail call void asm "", "=*Q,i,*Q"(i64* %a, i64 0, i64* %a)
+entry:
+  %f = alloca i64, align 8
+  %tmp = alloca i32, align 4
+  %0 = bitcast i64* %f to i8*
+  %1 = load i64, i64* @d, align 8
+  %shl = shl i64 %1, 12
+  store i64 %shl, i64* %f, align 8
+  %2 = load i64, i64* %f, align 8
+  %cmp = icmp sgt i64 %2, -129
+  br i1 %cmp, label %land.lhs.true, label %land.end
+
+land.lhs.true:                                    ; preds = %entry
+  %3 = load i64, i64* %f, align 8
+  %cmp1 = icmp slt i64 %3, 128
+  br i1 %cmp1, label %land.rhs, label %land.end
+
+land.rhs:                                         ; preds = %land.lhs.true
+  %4 = load i64, i64* %f, align 8
+  %5 = call i1 @llvm.is.constant.i64(i64 %4)
+  br label %land.end
+
+land.end:                                         ; preds = %land.rhs, %land.lhs.true, %entry
+  %6 = phi i1 [ false, %land.lhs.true ], [ false, %entry ], [ %5, %land.rhs ]
+  %land.ext = zext i1 %6 to i32
+  %7 = call i1 @llvm.is.constant.i32(i32 %land.ext)
+  br i1 %7, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %land.end
+  %8 = load i64, i64* %f, align 8
+  %cmp2 = icmp sgt i64 %8, -129
+  br i1 %cmp2, label %land.lhs.true3, label %if.end
+
+land.lhs.true3:                                   ; preds = %cond.true
+  %9 = load i64, i64* %f, align 8
+  %cmp4 = icmp slt i64 %9, 128
+  br i1 %cmp4, label %land.lhs.true5, label %if.end
+
+land.lhs.true5:                                   ; preds = %land.lhs.true3
+  %10 = load i64, i64* %f, align 8
+  %11 = call i1 @llvm.is.constant.i64(i64 %10)
+  br i1 %11, label %if.then, label %if.end
+
+cond.false:                                       ; preds = %land.end
+  %12 = load i64, i64* %f, align 8
+  %cmp6 = icmp sgt i64 %12, -129
+  br i1 %cmp6, label %land.lhs.true7, label %land.end10
+
+land.lhs.true7:                                   ; preds = %cond.false
+  %13 = load i64, i64* %f, align 8
+  %cmp8 = icmp slt i64 %13, 128
+  br i1 %cmp8, label %land.rhs9, label %land.end10
+
+land.rhs9:                                        ; preds = %land.lhs.true7
+  %14 = load i64, i64* %f, align 8
+  %15 = call i1 @llvm.is.constant.i64(i64 %14)
+  br label %land.end10
+
+land.end10:                                       ; preds = %land.rhs9, %land.lhs.true7, %cond.false
+  %16 = phi i1 [ false, %land.lhs.true7 ], [ false, %cond.false ], [ %15, %land.rhs9 ]
+  %17 = zext i1 %16 to i64
+  %cond = select i1 %16, i32 1, i32 0
+  store i32 %cond, i32* %tmp, align 4
+  %18 = load i32, i32* %tmp, align 4
+  %tobool = icmp ne i32 %18, 0
+  br i1 %tobool, label %if.then, label %if.end
+
+if.then:                                          ; preds = %land.end10, %land.lhs.true5
+  %19 = load %struct.b*, %struct.b** @c, align 8
+  %20 = bitcast %struct.b* %19 to i8*, !nosanitize !10
+  %21 = call i64 @llvm.objectsize.i64.p0i8(i8* %20, i1 false, i1 false, i1 false), !nosanitize !10
+  %22 = icmp uge i64 %21, 8, !nosanitize !10
+  br i1 %22, label %cont, label %handler.type_mismatch, !nosanitize !10
+
+handler.type_mismatch:                            ; preds = %if.then
+  %23 = ptrtoint %struct.b* %19 to i64, !nosanitize !10
+  call void @__ubsan_handle_type_mismatch_v1(i8* bitcast ({ { [22 x i8]*, i32, i32 }, { i16, i16, [4 x i8] }*, i8, i8 }* @1 to i8*), i64 %23) #5, !nosanitize !10
+  br label %cont, !nosanitize !10
+
+cont:                                             ; preds = %handler.type_mismatch, %if.then
+  %a = getelementptr inbounds %struct.b, %struct.b* %19, i32 0, i32 0
+  %24 = load i64, i64* %f, align 8
+  call void asm "", "=*Q,i,*Q"(i64* %a, i64 %24, i64* %a)
+  br label %if.end
+
+if.end:                                           ; preds = %cont, %land.end10, %land.lhs.true5, %land.lhs.true3, %cond.true
+  %25 = bitcast i64* %f to i8*
+  ret void
+}
+
+declare i1 @llvm.is.constant.i64(i64)
+declare i1 @llvm.is.constant.i32(i32)
+
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i1 immarg, i1 immarg, i1 immarg)
+declare dso_local void @__ubsan_handle_type_mismatch_v1(i8*, i64)
+!10 = !{}