[IPSCCP] Constant fold struct argument/instructions when all the lattice values are constant

[davide]

Summary

This now should also work with the interprocedural variant of the pass. Slightly easier now that the yak is shaved.

[eli.friedman]

LGTM.

llvm/trunk/lib/Transforms/Scalar/SCCP.cpp

static bool runIPSCCP(Module &M, const DataLayout &DL,
 
   for (Function &F : M) {
     if (F.isDeclaration())
       continue;
 
     if (Solver.isBlockExecutable(&F.front())) {
       for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); AI != E;
            ++AI) {
-        if (AI->use_empty() || AI->getType()->isStructTy()) continue;
-
-        // TODO: Could use getStructLatticeValueFor to find out if the entire
-        // result is a constant and replace it entirely if so.
-
+        if (AI->use_empty())
+          continue;
         if (tryToReplaceWithConstant(Solver, &*AI))
           ++IPNumArgsElimed;
       }
     }
 
     for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
       if (!Solver.isBlockExecutable(&*BB)) {
         DEBUG(dbgs() << "  BasicBlock Dead:" << *BB);
 
         ++NumDeadBlocks;
         NumInstRemoved +=
             changeToUnreachable(BB->getFirstNonPHI(), /*UseLLVMTrap=*/false);
 
         MadeChanges = true;
 
         if (&*BB != &F.front())
           BlocksToErase.push_back(&*BB);
         continue;
       }
 
       for (BasicBlock::iterator BI = BB->begin(), E = BB->end(); BI != E; ) {
         Instruction *Inst = &*BI++;
-        if (Inst->getType()->isVoidTy() || Inst->getType()->isStructTy())
+        if (Inst->getType()->isVoidTy())
           continue;
-
-        // TODO: Could use getStructLatticeValueFor to find out if the entire
-        // result is a constant and replace it entirely if so.
-
         if (tryToReplaceInstWithConstant(
                 Solver, Inst,
                 !isa<CallInst>(Inst) &&
                     !isa<TerminatorInst>(Inst) /* shouldEraseFromParent */)) {
           // Hey, we just changed something!
           MadeChanges = true;
           ++IPNumInstRemoved;
         }

llvm/trunk/test/Transforms/SCCP/ipsccp-basic.ll

 ;;======================== test4
 
 define internal {i64,i64} @test4a() {
   %a = insertvalue {i64,i64} undef, i64 4, 1
   %b = insertvalue {i64,i64} %a, i64 5, 0
   ret {i64,i64} %b
 }
 
+; CHECK-LABEL: define internal { i64, i64 } @test4a(
+; CHECK-NEXT:   ret { i64, i64 } { i64 5, i64 4 }
+; CHECK-NEXT: }
+
 define i64 @test4b() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
   %a = invoke {i64,i64} @test4a()
           to label %A unwind label %B
 A:
   %b = extractvalue {i64,i64} %a, 0
   %c = call i64 @test4c(i64 %b)
   ret i64 %c
 B:

 B:
   %val = landingpad { i8*, i32 }
            catch i8* null
   ret i64 0
 }
 
 ; CHECK: define i64 @test5b()
 ; CHECK:     A:
-; CHECK-NEXT:  %c = call i64 @test5c({ i64, i64 } %a)
+; CHECK-NEXT:  %c = call i64 @test5c({ i64, i64 } { i64 5, i64 4 })
 ; CHECK-NEXT:  ret i64 5
 
 define internal i64 @test5c({i64,i64} %a) {
   %b = extractvalue {i64,i64} %a, 0
   ret i64 %b
 }
 
 

 %T = type {i32,i32}
 
 define internal %T @test7a(i32 %A) {
   %X = add i32 1, %A
   %mrv0 = insertvalue %T undef, i32 %X, 0
   %mrv1 = insertvalue %T %mrv0, i32 %A, 1
   ret %T %mrv1
 ; CHECK-LABEL: @test7a(
-; CHECK-NEXT: %mrv0 = insertvalue %T undef, i32 18, 0
-; CHECK-NEXT: %mrv1 = insertvalue %T %mrv0, i32 17, 1
+; CHECK-NEXT: ret %T { i32 18, i32 17 }
 }
 
 define i32 @test7b() {
   %X = call %T @test7a(i32 17)
         %Y = extractvalue %T %X, 0
   %Z = add i32 %Y, %Y
   ret i32 %Z
 ; CHECK-LABEL: define i32 @test7b(

 define void @test9() {
 entry:
         %local_foo = alloca {  }
         load {  }, {  }* @test9g
         store {  } %0, {  }* %local_foo
         ret void
 }
 
+; CHECK-LABEL: define void @test9(
+; CHECK-NEXT: entry:
+; CHECK-NEXT: %local_foo = alloca {}
+; CHECK-NEXT:  store {} zeroinitializer, {}* %local_foo
+; CHECK-NEXT: ret void
+
 declare i32 @__gxx_personality_v0(...)
 
 ;;======================== test10
 
 define i32 @test10a() nounwind {
 entry:
   %call = call i32 @test10b(i32 undef)
   ret i32 %call