Calculate __builtin_object_size when pointer depends on a condition

[spetrovic]

Summary

This patch fixes calculating of builtin_object_size if it depends on condition. Before this patch compiler didn't know how to calculate the object size when it finds condition that cannot be eliminated. This patch enables calculating of builtin_object_size even in case when condition cannot be eliminated by choosing minimum or maximum value as result from condition. Choosing minimum or maximum value from condition is based on second argument of __builtin_object_size function.

[george.burgess.iv]

Hi! Thanks for doing this.

include/llvm/Analysis/MemoryBuiltins.h

36

Style nit: This should be CamelCase, not all caps.

39

These identifiers seem really general to be putting them into the llvm namespace. Can we make this an enum class instead? Or can we prefix them all with something like OSM_?

137–139

Please document what Mode does here.

lib/Analysis/MemoryBuiltins.cpp

560

Do we not need to handle Phis, as well?

Consider:

void sideeffect();
int foo(int N) {
  char Buf[100];
  char *Ptr = Buf;
  if (N > 0) {
    sideeffect();
    Ptr = Buf + 50;
  }
  return __builtin_object_size(Ptr, 0);
}

...Which turns into:

define i32 @foo(i32 %N) {
entry:
  %Buf = alloca [100 x i8], align 16
  %0 = getelementptr inbounds [100 x i8], [100 x i8]* %Buf, i64 0, i64 0
  %cmp = icmp sgt i32 %N, 0
  br i1 %cmp, label %if.then, label %if.end

if.then:                                          ; preds = %entry
  tail call void (...) @sideeffect() #4
  %add.ptr = getelementptr inbounds [100 x i8], [100 x i8]* %Buf, i64 0, i64 50
  br label %if.end

if.end:                                           ; preds = %if.then, %entry
  %Ptr.0 = phi i8* [ %add.ptr, %if.then ], [ %0, %entry ]
  %1 = call i64 @llvm.objectsize.i64.p0i8(i8* %Ptr.0, i1 false)
  %conv = trunc i64 %1 to i32
  ret i32 %conv
}

568

This seems like it would fail given:

int foo(int N) {
  char Big[20];
  char Small[10];
  char *Ptr = N ? Big + 10 : Small;
  return __bos(Ptr);
}

...And it looks like this was a bug in the original implementation, too. Yay bugs. :)

If you'd like to fix it, feel free; otherwise, I'll do it after your patch lands. If you decide to fix it, please add a test-case that doesn't go through CGP.

572

Is there a reason we can't just compare TrueSide.first and FalseSide.first directly?

572

Do we really want to ignore offsets here? It seems that doing would cause this to break on code like:

int foo(int N) {
  char Small[10];
  char Large[20];

  char *Ptr = N ? Small : Large + 19;
  return __bos(Ptr);
}

576

Same comments as the Mode == MIN conditional above

lib/CodeGen/CodeGenPrepare.cpp

1788

Style nit: Add another space of indentation please

1792

Can we just say Mode == MIN in the ternary here?

test/CodeGen/X86/builtin-condition.ll

2

I recommend using opt instead, so we don't have to compare against asm. Given that our test cases should be simple, you can probably get away with changing the run line to:

; RUN: opt -codegenprepare -S < %s | FileCheck %s

...And it will output LLVM IR with all of the objectsize calls lowered for you :)

35

Can we add a test-case for something like

int foo(int N) {
  char Small[10];
  char Large[20];

  char *Ptr = N ? Small : Large + 19;
  return __bos(Ptr);
}

Too, please?

[spetrovic]

Comments addressed. I was thinking to resolve handling Phis and including offset in calculating min and max values (for select and for phi) in next patch if it is OK with you.

[george.burgess.iv]

I was thinking to resolve handling Phis and including offset in calculating min and max values (for select and for phi) in next patch if it is OK with you.

Sorry, "next patch" meaning the next revision to this review, or a different patch after this is committed?

If the former: sounds good!

If the latter: I'm fine if you want to commit Phi handling separately, but the offset issue seems like it would introduce a bug that breaks existing, correct code. I don't think that would be good. :)

include/llvm/Analysis/MemoryBuiltins.h

139

Typo: "correspondig"

[spetrovic]

Ok, I will resolve offset problem in this revision. Handling Phis will be different patch after this is committed.
So, I have question about offset problem. For this example:

int foo(int N) {

char Small[10];
char Large[20];

char *Ptr = N ? Small : Large - 19;
return __builtin_object_size(Ptr,0);

}

int main() {

size_t ret;
ret = foo(0);
printf("\n%d\n", ret);
return 0;

}

gcc gives 39 as result, I don't think that is correct value, what is your opinion about this case and similar cases ?

[george.burgess.iv]

In clang's lib/AST/ExprConstant.cpp, it seems that we always return 0 if
our offset from the object's start is negative (or if the offset is greater
than the size of the object). I think this behavior is sane, and that it
would be odd if LLVM and clang acted differently here, so I'd just hand
back 0 bytes if our offset is negative.

[spetrovic]

Comments addressed.

[spetrovic]

lib/Analysis/MemoryBuiltins.cpp

575

What do you think if we return unknown value if one of sides (true or false) has offset out of bounds, or you have some advice to return something else? Second proposal is to return some invalid value in SizeOffsetType object?

[george.burgess.iv]

lib/Analysis/MemoryBuiltins.cpp

575

What do you think if we return unknown value if one of sides (true or false) has offset out of bounds

I think that the goal of this code is to basically turn:

__builtin_object_size(a ? b : c, N);

into

max(__builtin_object_size(b, N), __builtin_object_size(c, N));

(or min, if N is 2 or 3).

If this is correct, I would expect foo below to return 3 if it isn't inlined:

int foo(int i) {
  char c[3];
  return __builtin_object_size(i ? c : c + 5, 0);
}

...because __bos(c, 0) should hand back 3, __bos(c + 5, 0) should hand back 0, and max(3, 0) is 3. So, I don't see how returning unknown makes sense.

[spetrovic]

Comments addressed.

[george.burgess.iv]

Thanks for fixing the offset bug! Just a few rather small comments, and I think we're good.

lib/Analysis/MemoryBuiltins.cpp

390

Is there a reason this method needs to exist on the visitor? Either way, please take SizeOffsetType by const&.

391

Nit: Data.second.isNegative()

579

Nit: The braces serve no purpose, and I don't think they were here before. Please remove them. :)

585

And here

[spetrovic]

lib/Analysis/MemoryBuiltins.cpp

390

This part of code is called few times, and maybe will be called and for phi node case too, so I think it's OK to put it in a method.

[spetrovic]

Comments addressed.

[george.burgess.iv]

lib/Analysis/MemoryBuiltins.cpp

390

...But

1. It uses absolutely nothing from ObjectSizeOffsetVisitor
2. It's presumably useless outside of MemoryBuiltins.cpp

Because of point 1, it should ideally be a free function. Because of point 2, it should ideally be local to MemoryBuiltins.cpp. So I'm not seeing how it makes more sense to make this a public method.

[george.burgess.iv]

Sorry for the multiple comments -- one more thing:

test/CodeGen/X86/builtin-condition.ll

1

Nit: This should probably go into test/Transforms/CodeGenPrepare, now that it's no longer generating x86. :)

[george.burgess.iv]

This LGTM with two more comments. Thanks so much for the patch! :)

include/llvm/Analysis/MemoryBuiltins.h

146

This has no users outside of MemoryBuiltins.cpp, so we can remove this.

lib/Analysis/MemoryBuiltins.cpp

367

Please make this static APInt getSizeWithOverflow(const SizeOffsetType &Data) {, and move it above llvm::getObjectSize (so llvm::getObjectSize can use it :) ).

[nlopes]

lib/Analysis/MemoryBuiltins.cpp

560

We used to handle PHIs, but then we had a compile-time regression because alias analysis got too slow. We may introduce a switch, though, to be more or less aggressive.

[spetrovic]

Comments addressed. Thank you for review.

include/llvm/Analysis/MemoryBuiltins.h

 namespace llvm {
 class CallInst;
 class PointerType;
 class DataLayout;
 class TargetLibraryInfo;
 class Type;
 class Value;
 
+enum class ObjSizeMode {
+  Exact = 0,
+  Min = 1,
+  Max = 2
+};
 
 /// \brief Tests if a value is a call or invoke to a library function that
 /// allocates or reallocates memory (either malloc, calloc, realloc, or strdup
 /// like).
 bool isAllocationFn(const Value *V, const TargetLibraryInfo *TLI,
                     bool LookThroughBitCast = false);
 
 /// \brief Tests if a value is a call or invoke to a function that returns a

 //  Utility functions to compute size of objects.
 //
 
 /// \brief Compute the size of the object pointed by Ptr. Returns true and the
 /// object size in Size if successful, and false otherwise. In this context, by
 /// object we mean the region of memory starting at Ptr to the end of the
 /// underlying object pointed to by Ptr.
 /// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
 /// byval arguments, and global variables.
+/// If Mode is Min or Max the size will be evaluated even if it depends on
+/// a condition and corresponding value will be returned (min or max).
 bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL,
-                   const TargetLibraryInfo *TLI, bool RoundToAlign = false);
+                   const TargetLibraryInfo *TLI, bool RoundToAlign = false,
+                   ObjSizeMode Mode = ObjSizeMode::Exact);
 
 typedef std::pair<APInt, APInt> SizeOffsetType;
 
 /// \brief Evaluate the size and offset of an object pointed to by a Value*
 /// statically. Fails if size or offset are not known at compile time.
 class ObjectSizeOffsetVisitor
   : public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetType> {
 
   const DataLayout &DL;
   const TargetLibraryInfo *TLI;
   bool RoundToAlign;
+  ObjSizeMode Mode;
   unsigned IntTyBits;
   APInt Zero;
   SmallPtrSet<Instruction *, 8> SeenInsts;
 
   APInt align(APInt Size, uint64_t Align);
 
   SizeOffsetType unknown() {
     return std::make_pair(APInt(), APInt());
   }
 
 public:
   ObjectSizeOffsetVisitor(const DataLayout &DL, const TargetLibraryInfo *TLI,
-                          LLVMContext &Context, bool RoundToAlign = false);
+                          LLVMContext &Context, bool RoundToAlign = false,
+                          ObjSizeMode Mode = ObjSizeMode::Exact);
 
   SizeOffsetType compute(Value *V);
 
   static bool knownSize(const SizeOffsetType &SizeOffset) {
     return SizeOffset.first.getBitWidth() > 1;
   }
 
   static bool knownOffset(const SizeOffsetType &SizeOffset) {
     return SizeOffset.second.getBitWidth() > 1;
   }
 
   static bool bothKnown(const SizeOffsetType &SizeOffset) {
     return knownSize(SizeOffset) && knownOffset(SizeOffset);
   }
 
+  APInt getSizeWithOverflow(const SizeOffsetType &Data);
+
   // These are "private", except they can't actually be made private. Only
   // compute() should be used by external users.
   SizeOffsetType visitAllocaInst(AllocaInst &I);
   SizeOffsetType visitArgument(Argument &A);
   SizeOffsetType visitCallSite(CallSite CS);
   SizeOffsetType visitConstantPointerNull(ConstantPointerNull&);
   SizeOffsetType visitExtractElementInst(ExtractElementInst &I);
   SizeOffsetType visitExtractValueInst(ExtractValueInst &I);

lib/Analysis/MemoryBuiltins.cpp

 //
 
 
 /// \brief Compute the size of the object pointed by Ptr. Returns true and the
 /// object size in Size if successful, and false otherwise.
 /// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
 /// byval arguments, and global variables.
 bool llvm::getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL,
-                         const TargetLibraryInfo *TLI, bool RoundToAlign) {
-  ObjectSizeOffsetVisitor Visitor(DL, TLI, Ptr->getContext(), RoundToAlign);
+                         const TargetLibraryInfo *TLI, bool RoundToAlign,
+                         llvm::ObjSizeMode Mode) {
+  ObjectSizeOffsetVisitor Visitor(DL, TLI, Ptr->getContext(),
+                                  RoundToAlign, Mode);
   SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr));
   if (!Visitor.bothKnown(Data))
     return false;
 
-  APInt ObjSize = Data.first, Offset = Data.second;
-  // check for overflow
-  if (Offset.slt(0) || ObjSize.ult(Offset))
-    Size = 0;
-  else
-    Size = (ObjSize - Offset).getZExtValue();
+  Size = Visitor.getSizeWithOverflow(Data).getZExtValue();
   return true;
 }
 
 
 STATISTIC(ObjectVisitorArgument,
           "Number of arguments with unsolved size and offset");
 STATISTIC(ObjectVisitorLoad,
           "Number of load instructions with unsolved size and offset");
 
 
 APInt ObjectSizeOffsetVisitor::align(APInt Size, uint64_t Align) {
   if (RoundToAlign && Align)
     return APInt(IntTyBits, alignTo(Size.getZExtValue(), Align));
   return Size;
 }
 
 ObjectSizeOffsetVisitor::ObjectSizeOffsetVisitor(const DataLayout &DL,
                                                  const TargetLibraryInfo *TLI,
                                                  LLVMContext &Context,
-                                                 bool RoundToAlign)
-    : DL(DL), TLI(TLI), RoundToAlign(RoundToAlign) {
+                                                 bool RoundToAlign,
+                                                 ObjSizeMode Mode)
+    : DL(DL), TLI(TLI), RoundToAlign(RoundToAlign), Mode(Mode) {
   // Pointer size must be rechecked for each object visited since it could have
   // a different address space.
 }
 
+APInt ObjectSizeOffsetVisitor::getSizeWithOverflow(const SizeOffsetType &Data) {
+  if (Data.second.isNegative() || Data.first.ult(Data.second))
+    return APInt(Data.first.getBitWidth(), 0);
+  return Data.first - Data.second;
+}
+
 SizeOffsetType ObjectSizeOffsetVisitor::compute(Value *V) {
   IntTyBits = DL.getPointerTypeSizeInBits(V->getType());
   Zero = APInt::getNullValue(IntTyBits);
 
   V = V->stripPointerCasts();
   if (Instruction *I = dyn_cast<Instruction>(V)) {
     // If we have already seen this instruction, bail out. Cycles can happen in
     // unreachable code after constant propagation.

 }
 
 SizeOffsetType ObjectSizeOffsetVisitor::visitLoadInst(LoadInst&) {
   ++ObjectVisitorLoad;
   return unknown();
 }
 
 SizeOffsetType ObjectSizeOffsetVisitor::visitPHINode(PHINode&) {
   // too complex to analyze statically.
   return unknown();
 }
 
 SizeOffsetType ObjectSizeOffsetVisitor::visitSelectInst(SelectInst &I) {
   SizeOffsetType TrueSide  = compute(I.getTrueValue());
   SizeOffsetType FalseSide = compute(I.getFalseValue());
-  if (bothKnown(TrueSide) && bothKnown(FalseSide) && TrueSide == FalseSide)
+  if (bothKnown(TrueSide) && bothKnown(FalseSide)) {
+    if (TrueSide == FalseSide) {
+        return TrueSide;
+    }
+
+    APInt TrueResult = getSizeWithOverflow(TrueSide);
+    APInt FalseResult = getSizeWithOverflow(FalseSide);
+
+    if (TrueResult == FalseResult) {
+      return TrueSide;
+    }
+    if (Mode == ObjSizeMode::Min) {
+      if (TrueResult.slt(FalseResult))
         return TrueSide;
+      return FalseSide;
+    }
+    if (Mode == ObjSizeMode::Max) {
+      if (TrueResult.sgt(FalseResult))
+        return TrueSide;
+      return FalseSide;
+    }
+  }
   return unknown();
 }
 
 SizeOffsetType ObjectSizeOffsetVisitor::visitUndefValue(UndefValue&) {
   return std::make_pair(Zero, Zero);
 }
 
 SizeOffsetType ObjectSizeOffsetVisitor::visitInstruction(Instruction &I) {

lib/CodeGen/CodeGenPrepare.cpp

 #include "llvm/CodeGen/Passes.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
+#include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/IRBuilder.h"
if (!OptSize && CI->hasFnAttr(Attribute::Cold))
     }
 
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
   if (II) {
     switch (II->getIntrinsicID()) {
     default: break;
     case Intrinsic::objectsize: {
       // Lower all uses of llvm.objectsize.*
-      bool Min = (cast<ConstantInt>(II->getArgOperand(1))->getZExtValue() == 1);
+      uint64_t Size;
       Type *ReturnTy = CI->getType();
-      Constant *RetVal = ConstantInt::get(ReturnTy, Min ? 0 : -1ULL);
-
+      Constant *RetVal = nullptr;
+      ConstantInt *Op1 = cast<ConstantInt>(II->getArgOperand(1));
+      ObjSizeMode Mode = Op1->isZero() ? ObjSizeMode::Max : ObjSizeMode::Min;
+      if (getObjectSize(II->getArgOperand(0),
+                        Size, *DL, TLInfo, false, Mode)) {
+        RetVal = ConstantInt::get(ReturnTy, Size);
+      } else {
+        RetVal = ConstantInt::get(ReturnTy,
+                                  Mode == ObjSizeMode::Min ? 0 : -1ULL);
+      }
       // Substituting this can cause recursive simplifications, which can
       // invalidate our iterator.  Use a WeakVH to hold onto it in case this
       // happens.
       Value *CurValue = &*CurInstIterator;
       WeakVH IterHandle(CurValue);
 
       replaceAndRecursivelySimplify(CI, RetVal, TLInfo, nullptr);
 

test/CodeGen/X86/builtin-condition.ll

+; RUN: opt -codegenprepare -S  < %s | FileCheck %s
+
+; #include<stdlib.h>
+; #define STATIC_BUF_SIZE 10
+; #define LARGER_BUF_SIZE 30
+;
+; size_t foo1(int flag) {
+;   char *cptr;
+;   char chararray[LARGER_BUF_SIZE];
+;   char chararray2[STATIC_BUF_SIZE];
+;   if(flag)
+;     cptr = chararray2;
+;    else
+;     cptr = chararray;
+;
+;   return  __builtin_object_size(cptr, 2);
+; }
+;
+; size_t foo2(int n) {
+;   char Small[10];
+;   char Large[20];
+;   char *Ptr = n ? Small : Large + 19;
+;   return __builtin_object_size(Ptr, 0);
+; }
+;
+; void foo() {
+;   size_t ret;
+;   size_t ret1;
+;   ret = foo1(0);
+;   ret1 = foo2(0);
+;   printf("\n%d %d\n", ret, ret1);
+; }
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@.str = private unnamed_addr constant [8 x i8] c"\0A%d %d\0A\00", align 1
+
+define i64 @foo1(i32 %flag) {
+entry:
+  %chararray = alloca [30 x i8], align 16
+  %chararray2 = alloca [10 x i8], align 1
+  %0 = getelementptr inbounds [30 x i8], [30 x i8]* %chararray, i64 0, i64 0
+  call void @llvm.lifetime.start(i64 30, i8* %0)
+  %1 = getelementptr inbounds [10 x i8], [10 x i8]* %chararray2, i64 0, i64 0
+  call void @llvm.lifetime.start(i64 10, i8* %1)
+  %tobool = icmp eq i32 %flag, 0
+  %cptr.0 = select i1 %tobool, i8* %0, i8* %1
+  %2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cptr.0, i1 true)
+  call void @llvm.lifetime.end(i64 10, i8* %1)
+  call void @llvm.lifetime.end(i64 30, i8* %0)
+  ret i64 %2
+; CHECK-LABEL: foo1
+; CHECK:  ret i64 10
+}
+
+declare void @llvm.lifetime.start(i64, i8* nocapture)
+
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i1)
+
+declare void @llvm.lifetime.end(i64, i8* nocapture)
+
+define i64 @foo2(i32 %n) {
+entry:
+  %Small = alloca [10 x i8], align 1
+  %Large = alloca [20 x i8], align 16
+  %0 = getelementptr inbounds [10 x i8], [10 x i8]* %Small, i64 0, i64 0
+  call void @llvm.lifetime.start(i64 10, i8* %0)
+  %1 = getelementptr inbounds [20 x i8], [20 x i8]* %Large, i64 0, i64 0
+  call void @llvm.lifetime.start(i64 20, i8* %1)
+  %tobool = icmp ne i32 %n, 0
+  %add.ptr = getelementptr inbounds [20 x i8], [20 x i8]* %Large, i64 0, i64 19
+  %cond = select i1 %tobool, i8* %0, i8* %add.ptr
+  %2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cond, i1 false)
+  call void @llvm.lifetime.end(i64 20, i8* %1)
+  call void @llvm.lifetime.end(i64 10, i8* %0)
+  ret i64 %2
+; CHECK-LABEL: foo2
+; CHECK:  ret i64 10
+}
+
+define void @foo() {
+entry:
+  %call = tail call i64 @foo1(i32 0)
+  %call1 = tail call i64 @foo2(i32 0)
+  %call2 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 %call, i64 %call1)
+  ret void
+}
+
+declare i32 @printf(i8* nocapture readonly, ...)
 No newline at end of file

test/Transforms/InstCombine/builtin-object-size-offset.ll

+; RUN: opt -instcombine -S < %s | FileCheck %s
+
+; #include <stdlib.h>
+; #include <stdio.h>
+;
+; int foo1(int N) {
+;   char Big[20];
+;   char Small[10];
+;   char *Ptr = N ? Big + 10 : Small;
+;   return __builtin_object_size(Ptr, 0);
+; }
+;
+; void foo() {
+;   size_t ret;
+;   ret = foo1(0);
+;   printf("\n %d", ret);
+; }
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@.str = private unnamed_addr constant [5 x i8] c"\0A %d\00", align 1
+
+define i32 @foo1(i32 %N) {
+entry:
+  %Big = alloca [20 x i8], align 16
+  %Small = alloca [10 x i8], align 1
+  %0 = getelementptr inbounds [20 x i8], [20 x i8]* %Big, i64 0, i64 0
+  call void @llvm.lifetime.start(i64 20, i8* %0)
+  %1 = getelementptr inbounds [10 x i8], [10 x i8]* %Small, i64 0, i64 0
+  call void @llvm.lifetime.start(i64 10, i8* %1)
+  %tobool = icmp ne i32 %N, 0
+  %add.ptr = getelementptr inbounds [20 x i8], [20 x i8]* %Big, i64 0, i64 10
+  %cond = select i1 %tobool, i8* %add.ptr, i8* %1
+  %2 = call i64 @llvm.objectsize.i64.p0i8(i8* %cond, i1 false)
+  %conv = trunc i64 %2 to i32
+  call void @llvm.lifetime.end(i64 10, i8* %1)
+  call void @llvm.lifetime.end(i64 20, i8* %0)
+  ret i32 %conv
+; CHECK: ret i32 10 
+}
+
+declare void @llvm.lifetime.start(i64, i8* nocapture)
+
+declare i64 @llvm.objectsize.i64.p0i8(i8*, i1)
+
+declare void @llvm.lifetime.end(i64, i8* nocapture)
+
+define void @foo() {
+entry:
+  %call = tail call i32 @foo1(i32 0)
+  %conv = sext i32 %call to i64
+  %call1 = tail call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i64 %conv)
+  ret void
+}
+
+declare i32 @printf(i8* nocapture readonly, ...)
+