mergefunc: avoid merge with loop metadata

[jfb]

Summary

Loop metadata hints at unrolling and vectorization. mergefunc shouldn't merge
when they're different since someone expressed the wish for the functions to
differ (yes we could also ignore metadata, but let's not be mean). This can
happen when running mergefunc 'early' (right after clang or another frontend
generates code) but shouldn't happen when running it 'late' (after optimizations
are run and loop metadata has been put to use).

This inadvertently happens in test/Transforms/LoopVectorize/X86/metadata-enable.ll

This patch doesn't fix all of mergefunc's handling of metadata, it simply makes
one case less broken and puts us closer to being able to use mergefunc.

[jfb]

Ping.

[hfinkel]

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

[jfb]

In D19075#405855, @hfinkel wrote:

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

mergefunc wants an ordering for what it compares, so pure equality isn't sufficient (although cmpLoopOperandMetadata does start with L == R). It needs to know how to order in a stable way, so we also can't just order based on pointer value.

[hfinkel]

In D19075#406897, @jfb wrote:

In D19075#405855, @hfinkel wrote:

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

mergefunc wants an ordering for what it compares, so pure equality isn't sufficient (although cmpLoopOperandMetadata does start with L == R). It needs to know how to order in a stable way, so we also can't just order based on pointer value.

Do you not already have a way to do this for metadata in general?

[jfb]

In D19075#406907, @hfinkel wrote:

In D19075#406897, @jfb wrote:

In D19075#405855, @hfinkel wrote:

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

mergefunc wants an ordering for what it compares, so pure equality isn't sufficient (although cmpLoopOperandMetadata does start with L == R). It needs to know how to order in a stable way, so we also can't just order based on pointer value.

Do you not already have a way to do this for metadata in general?

Not that I know, but I've been wrong before! I think a lot of the logic in mergefunc could be moved to the actual instruction (ordering as well as mergefunc's special hashing) and factored in a way that would reduce the risk of breakage (right now mergefunc breaks if not updated in sync). I need to hack on things a bit more before I feel comfortable enough to propose a clean solution.

[hfinkel]

In D19075#406955, @jfb wrote:

In D19075#406907, @hfinkel wrote:

In D19075#406897, @jfb wrote:

In D19075#405855, @hfinkel wrote:

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

mergefunc wants an ordering for what it compares, so pure equality isn't sufficient (although cmpLoopOperandMetadata does start with L == R). It needs to know how to order in a stable way, so we also can't just order based on pointer value.

Do you not already have a way to do this for metadata in general?

Not that I know, but I've been wrong before! I think a lot of the logic in mergefunc could be moved to the actual instruction (ordering as well as mergefunc's special hashing) and factored in a way that would reduce the risk of breakage (right now mergefunc breaks if not updated in sync).

This synchronization requirement is part of what worries me about embedding so much knowledge of the metadata format in this code.

I need to hack on things a bit more before I feel comfortable enough to propose a clean solution.

Okay. I suspect a general solution for metadata can be used here (minus the first operand for loop ids), once such a thing exists.

[jfb]

In D19075#406966, @hfinkel wrote:

In D19075#406955, @jfb wrote:

In D19075#406907, @hfinkel wrote:

In D19075#406897, @jfb wrote:

In D19075#405855, @hfinkel wrote:

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

mergefunc wants an ordering for what it compares, so pure equality isn't sufficient (although cmpLoopOperandMetadata does start with L == R). It needs to know how to order in a stable way, so we also can't just order based on pointer value.

Do you not already have a way to do this for metadata in general?

Not that I know, but I've been wrong before! I think a lot of the logic in mergefunc could be moved to the actual instruction (ordering as well as mergefunc's special hashing) and factored in a way that would reduce the risk of breakage (right now mergefunc breaks if not updated in sync).

This synchronization requirement is part of what worries me about embedding so much knowledge of the metadata format in this code.

I need to hack on things a bit more before I feel comfortable enough to propose a clean solution.

Okay. I suspect a general solution for metadata can be used here (minus the first operand for loop ids), once such a thing exists.

Are you saying the current patch looks good with promise to generalize solution later, or are you asking for the generalized solution first?

[hfinkel]

In D19075#406978, @jfb wrote:

In D19075#406966, @hfinkel wrote:

In D19075#406955, @jfb wrote:

In D19075#406907, @hfinkel wrote:

In D19075#406897, @jfb wrote:

In D19075#405855, @hfinkel wrote:

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

mergefunc wants an ordering for what it compares, so pure equality isn't sufficient (although cmpLoopOperandMetadata does start with L == R). It needs to know how to order in a stable way, so we also can't just order based on pointer value.

Do you not already have a way to do this for metadata in general?

Not that I know, but I've been wrong before! I think a lot of the logic in mergefunc could be moved to the actual instruction (ordering as well as mergefunc's special hashing) and factored in a way that would reduce the risk of breakage (right now mergefunc breaks if not updated in sync).

This synchronization requirement is part of what worries me about embedding so much knowledge of the metadata format in this code.

I need to hack on things a bit more before I feel comfortable enough to propose a clean solution.

Okay. I suspect a general solution for metadata can be used here (minus the first operand for loop ids), once such a thing exists.

Are you saying the current patch looks good with promise to generalize solution later, or are you asking for the generalized solution first?

I'm asking for the general solution first, specifically because it seems like it would be simpler than the current code, and more general. I really don't want to embed specific knowledge of the format of the loop metadata into this pass if not really necessary.

[jfb]

In D19075#406990, @hfinkel wrote:

In D19075#406978, @jfb wrote:

In D19075#406966, @hfinkel wrote:

In D19075#406955, @jfb wrote:

In D19075#406907, @hfinkel wrote:

In D19075#406897, @jfb wrote:

In D19075#405855, @hfinkel wrote:

Do we not unqiue MDNodes? This seems like a lot of code for what I would have thought should be: Compare the pointer equality all MDNode operands except the first (because the first is the unique loop id).

mergefunc wants an ordering for what it compares, so pure equality isn't sufficient (although cmpLoopOperandMetadata does start with L == R). It needs to know how to order in a stable way, so we also can't just order based on pointer value.

Do you not already have a way to do this for metadata in general?

Not that I know, but I've been wrong before! I think a lot of the logic in mergefunc could be moved to the actual instruction (ordering as well as mergefunc's special hashing) and factored in a way that would reduce the risk of breakage (right now mergefunc breaks if not updated in sync).

This synchronization requirement is part of what worries me about embedding so much knowledge of the metadata format in this code.

I need to hack on things a bit more before I feel comfortable enough to propose a clean solution.

Okay. I suspect a general solution for metadata can be used here (minus the first operand for loop ids), once such a thing exists.

Are you saying the current patch looks good with promise to generalize solution later, or are you asking for the generalized solution first?

I'm asking for the general solution first, specifically because it seems like it would be simpler than the current code, and more general. I really don't want to embed specific knowledge of the format of the loop metadata into this pass if not really necessary.

Ah OK, thanks! I'll take a stab at this and send another patch.

[rengolin]

Was this abandoned?

lib/Transforms/IPO/MergeFunctions.cpp

private:
   int cmpNumbers(uint64_t L, uint64_t R) const;
   int cmpOrderings(AtomicOrdering L, AtomicOrdering R) const;
   int cmpAPInts(const APInt &L, const APInt &R) const;
   int cmpAPFloats(const APFloat &L, const APFloat &R) const;
   int cmpInlineAsm(const InlineAsm *L, const InlineAsm *R) const;
   int cmpMem(StringRef L, StringRef R) const;
   int cmpAttrs(const AttributeSet L, const AttributeSet R) const;
   int cmpRangeMetadata(const MDNode *L, const MDNode *R) const;
+  int cmpLoopMetadata(const MDNode *L, const MDNode *R) const;
+  int cmpLoopOperandMetadata(const Metadata *L, const Metadata *R) const;
+  int cmpMDString(const MDString *L, const MDString *R) const;
   int cmpOperandBundlesSchema(const Instruction *L, const Instruction *R) const;
 
   // The two functions undergoing comparison.
   const Function *FnL, *FnR;
 
   /// Assign serial numbers to values from left function, and values from
   /// right function.
   /// Explanation:
for (size_t I = 0; I < L->getNumOperands(); ++I) {
     ConstantInt *LLow = mdconst::extract<ConstantInt>(L->getOperand(I));
     ConstantInt *RLow = mdconst::extract<ConstantInt>(R->getOperand(I));
     if (int Res = cmpAPInts(LLow->getValue(), RLow->getValue()))
       return Res;
   }
   return 0;
 }
 
+int FunctionComparator::cmpLoopMetadata(const MDNode *L,
+                                        const MDNode *R) const {
+  if (!L && !R)
+    return 0; // Not an identified loop, just a branch.
+  if (!L)
+    return -1;
+  if (!R)
+    return 1;
+  assert(L != R &&
+         "llvm.loop metadata is guaranteed to be separate for each loop");
+  assert(L->getNumOperands() > 0 && L->getOperand(0) == L &&
+         "loop ID should refer to self");
+  assert(R->getNumOperands() > 0 && R->getOperand(0) == R &&
+         "loop ID should refer to self");
+  if (int Res = cmpNumbers(L->getNumOperands(), R->getNumOperands()))
+    return Res;
+  if (R->getNumOperands() == 1)
+    // Two self-referring (for uniqueness) llvm.loop metadata are otherwise the
+    // same and can be merged.
+    return 0;
+  for (size_t I = 1; I < L->getNumOperands(); ++I)
+    if (int Res = cmpLoopOperandMetadata(L->getOperand(I), R->getOperand(I)))
+      return Res;
+  return 0;
+}
+
+int FunctionComparator::cmpLoopOperandMetadata(const Metadata *L,
+                                               const Metadata *R) const {
+  if (L == R)
+    return 0;
+  if (!L)
+    return -1;
+  if (!R)
+    return 1;
+  if (int Res = cmpNumbers(L->getMetadataID(), R->getMetadataID()))
+    return Res;
+
+  assert((dyn_cast<MDString>(L) || dyn_cast<MDNode>(L)) &&
+         "loop metadata is either string or node");
+
+  if (const auto *StrL = dyn_cast<MDString>(L))
+    return cmpMDString(StrL, cast<MDString>(R));
+
+  // Not a string, must be a node.
+  const auto *NodeL = cast<MDNode>(L);
+  const auto *NodeR = cast<MDNode>(R);
+  if (int Res = cmpNumbers(NodeL->getNumOperands(), NodeR->getNumOperands()))
+    return Res;
+
+  for (size_t I = 0; I < NodeL->getNumOperands(); ++I) {
+    const Metadata *LOp = NodeL->getOperand(I);
+    const Metadata *ROp = NodeR->getOperand(I);
+
+    if (int Res = cmpNumbers(LOp->getMetadataID(), ROp->getMetadataID()))
+      return Res;
+    assert((dyn_cast<MDString>(LOp) || dyn_cast<ConstantAsMetadata>(LOp)) &&
+           "loop metadata operand is either string or constant");
+    if (auto *StrL = dyn_cast<MDString>(LOp)) {
+      if (int Res = cmpMDString(StrL, cast<MDString>(ROp)))
+        return Res;
+      continue;
+    }
+    const Constant *ConstL = cast<ConstantAsMetadata>(LOp)->getValue();
+    const Constant *ConstR = cast<ConstantAsMetadata>(ROp)->getValue();
+    if (int Res = cmpConstants(ConstL, ConstR))
+      return Res;
+    continue;
+
+    llvm_unreachable("Unhandled loop metadata operand type");
+  }
+  return 0;
+}
+
+int FunctionComparator::cmpMDString(const MDString *L,
+                                    const MDString *R) const {
+  if (L == R)
+    return 0;
+  if (!L)
+    return -1;
+  if (!R)
+    return 1;
+  return L->getString().compare(R->getString());
+}
+
 int FunctionComparator::cmpOperandBundlesSchema(const Instruction *L,
                                                 const Instruction *R) const {
   ImmutableCallSite LCS(L);
   ImmutableCallSite RCS(R);
 
   assert(LCS && RCS && "Must be calls or invokes!");
   assert(LCS.isCall() == RCS.isCall() && "Can't compare otherwise!");
 

 
 /// Constants comparison:
 /// 1. Check whether type of L constant could be losslessly bitcasted to R
 /// type.
 /// 2. Compare constant contents.
 /// For more details see declaration comments.
 int FunctionComparator::cmpConstants(const Constant *L,
                                      const Constant *R) const {
+  if (L == R)
+    return 0;
+  if (!L)
+    return -1;
+  if (!R)
+    return 1;
 
   Type *TyL = L->getType();
   Type *TyR = R->getType();
 
   // Check whether types are bitcastable. This part is just re-factored
   // Type::canLosslesslyBitCastTo method, but instead of returning true/false,
   // we also pack into result which type is "less" for us.
   int TypesRes = cmpTypes(TyL, TyR);
if (int Res = cmpNumbers(RMWI->isVolatile(),
                              cast<AtomicRMWInst>(R)->isVolatile()))
       return Res;
     if (int Res = cmpOrderings(RMWI->getOrdering(),
                              cast<AtomicRMWInst>(R)->getOrdering()))
       return Res;
     return cmpNumbers(RMWI->getSynchScope(),
                       cast<AtomicRMWInst>(R)->getSynchScope());
   }
+  if (const BranchInst *Br = dyn_cast<BranchInst>(L)) {
+    return cmpLoopMetadata(
+        Br->getMetadata(LLVMContext::MD_loop),
+        cast<BranchInst>(R)->getMetadata(LLVMContext::MD_loop));
+  }
   return 0;
 }
 
 // Determine whether two GEP operations perform the same underlying arithmetic.
 // Read method declaration comments for more details.
 int FunctionComparator::cmpGEPs(const GEPOperator *GEPL,
                                 const GEPOperator *GEPR) const {
 

test/Transforms/MergeFunc/loop-metadata-different.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+; Test that different llvm.loop metadata prevents merging two functions which
+; don't otherwise differ. This is tricky because this type of metadata refer to
+; a metadata node that is guaranteed to be separate for each loop.
+
+; CHECK-LABEL: @enabled(
+; CHECK-NOT: call
+define i32 @enabled(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+; CHECK-LABEL: @disabled(
+; CHECK-NOT: call
+define i32 @disabled(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !2
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+!0 = !{!0, !1}
+!1 = !{!"llvm.loop.vectorize.enable", i1 1}
+!2 = !{!2, !3}
+!3 = !{!"llvm.loop.vectorize.enable", i1 0}

test/Transforms/MergeFunc/loop-metadata-one-missing.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+; Test that two loops, one with llvm.loop metadata and one without, prevents
+; merging two functions which don't otherwise differ. This is tricky because
+; this type of metadata refer to a metadata node that is guaranteed to be
+; separate for each loop.
+
+; CHECK-LABEL: @enabled(
+; CHECK-NOT: call
+define i32 @enabled(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+; CHECK-LABEL: @nometadata(
+; CHECK-NOT: call
+define i32 @nometadata(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+!0 = !{!0, !1}
+!1 = !{!"llvm.loop.vectorize.enable", i1 1}

test/Transforms/MergeFunc/loop-metadata-same.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+; Test that same llvm.loop metadata doesn't prevents merging two functions which
+; don't otherwise differ. This is tricky because this type of metadata refer to
+; a metadata node that is guaranteed to be separate for each loop.
+
+; CHECK-LABEL: @enabled1(
+; CHECK-NOT: call
+define i32 @enabled1(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+; CHECK-LABEL: @enabled2(
+; CHECK: tail call i32 @enabled1
+define i32 @enabled2(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !2
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+!0 = !{!0, !1}
+!1 = !{!"llvm.loop.vectorize.enable", i1 1}
+!2 = !{!2, !3}
+!3 = !{!"llvm.loop.vectorize.enable", i1 1}

test/Transforms/MergeFunc/loop-metadata-self-ref.ll

+; RUN: opt -mergefunc -S < %s | FileCheck %s
+
+; Test that self-referencing llvm.loop metadata without other content doesn't
+; prevent merging two functions which don't otherwise differ. This is tricky
+; because this type of metadata refer to a metadata node that is guaranteed to
+; be separate for each loop.
+
+; CHECK-LABEL: @loop1(
+; CHECK-NOT: call
+define i32 @loop1(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+; CHECK-LABEL: @loop2(
+; CHECK: tail call i32 @loop1
+define i32 @loop2(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32 %N) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %for.body, %entry
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %b, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %add = add nsw i32 %0, %N
+  %arrayidx2 = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx2, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond = icmp eq i64 %indvars.iv.next, 64
+  br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !1
+
+for.end:                                          ; preds = %for.body
+  %1 = load i32, i32* %a, align 4
+  ret i32 %1
+}
+
+!0 = !{!0}
+!1 = !{!1}