//===- CodeExtractor.cpp - Pull code region into a new function -----------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the interface to tear out a code region, such as an
#include "llvm/ADT/StringExtras.h"
#include <algorithm>
#include <set>
+#include <iostream>
using namespace llvm;
// Provide a command-line option to aggregate function arguments into a struct
return true;
return false;
}
-
+
/// definedInCaller - Return true if the specified value is defined in the
/// function being code extracted, but not in the region being extracted.
/// These values must be passed in as live-ins to the function.
//
void CodeExtractor::findInputsOutputs(Values &inputs, Values &outputs) {
std::set<BasicBlock*> ExitBlocks;
- for (std::set<BasicBlock*>::const_iterator ci = BlocksToExtract.begin(),
+ for (std::set<BasicBlock*>::const_iterator ci = BlocksToExtract.begin(),
ce = BlocksToExtract.end(); ci != ce; ++ci) {
BasicBlock *BB = *ci;
for (User::op_iterator O = I->op_begin(), E = I->op_end(); O != E; ++O)
if (definedInCaller(*O))
inputs.push_back(*O);
-
+
// Consider uses of this instruction (outputs).
for (Value::use_iterator UI = I->use_begin(), E = I->use_end();
UI != E; ++UI)
if (AggregateArgs) {
std::vector<Value*> Indices;
Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantUInt::get(Type::UIntTy, i));
+ Indices.push_back(ConstantInt::get(Type::UIntTy, i));
std::string GEPname = "gep_" + inputs[i]->getName();
TerminatorInst *TI = newFunction->begin()->getTerminator();
GetElementPtrInst *GEP = new GetElementPtrInst(AI, Indices, GEPname, TI);
for (unsigned i = 0, e = inputs.size(); i != e; ++i, ++AI)
AI->setName(inputs[i]->getName());
for (unsigned i = 0, e = outputs.size(); i != e; ++i, ++AI)
- AI->setName(outputs[i]->getName()+".out");
+ AI->setName(outputs[i]->getName()+".out");
}
// Rewrite branches to basic blocks outside of the loop to new dummy blocks
// Allocate a struct at the beginning of this function
Type *StructArgTy = StructType::get(ArgTypes);
- Struct =
- new AllocaInst(StructArgTy, 0, "structArg",
+ Struct =
+ new AllocaInst(StructArgTy, 0, "structArg",
codeReplacer->getParent()->begin()->begin());
params.push_back(Struct);
for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
std::vector<Value*> Indices;
Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantUInt::get(Type::UIntTy, i));
+ Indices.push_back(ConstantInt::get(Type::UIntTy, i));
GetElementPtrInst *GEP =
new GetElementPtrInst(Struct, Indices,
"gep_" + StructValues[i]->getName());
StoreInst *SI = new StoreInst(StructValues[i], GEP);
codeReplacer->getInstList().push_back(SI);
}
- }
+ }
// Emit the call to the function
CallInst *call = new CallInst(newFunction, params,
if (AggregateArgs) {
std::vector<Value*> Indices;
Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantUInt::get(Type::UIntTy, FirstOut + i));
- GetElementPtrInst *GEP
+ Indices.push_back(ConstantInt::get(Type::UIntTy, FirstOut + i));
+ GetElementPtrInst *GEP
= new GetElementPtrInst(Struct, Indices,
"gep_reload_" + outputs[i]->getName());
codeReplacer->getInstList().push_back(GEP);
// Now we can emit a switch statement using the call as a value.
SwitchInst *TheSwitch =
- new SwitchInst(ConstantUInt::getNullValue(Type::UShortTy),
+ new SwitchInst(ConstantInt::getNullValue(Type::UShortTy),
codeReplacer, 0, codeReplacer);
// Since there may be multiple exits from the original region, make the new
case 0:
case 1: break; // No value needed.
case 2: // Conditional branch, return a bool
- brVal = SuccNum ? ConstantBool::False : ConstantBool::True;
+ brVal = ConstantBool::get(!SuccNum);
break;
default:
- brVal = ConstantUInt::get(Type::UShortTy, SuccNum);
+ brVal = ConstantInt::get(Type::UShortTy, SuccNum);
break;
}
ReturnInst *NTRet = new ReturnInst(brVal, NewTarget);
// Update the switch instruction.
- TheSwitch->addCase(ConstantUInt::get(Type::UShortTy, SuccNum),
+ TheSwitch->addCase(ConstantInt::get(Type::UShortTy, SuccNum),
OldTarget);
// Restore values just before we exit
if (AggregateArgs) {
std::vector<Value*> Indices;
Indices.push_back(Constant::getNullValue(Type::UIntTy));
- Indices.push_back(ConstantUInt::get(Type::UIntTy,FirstOut+out));
+ Indices.push_back(ConstantInt::get(Type::UIntTy,FirstOut+out));
GetElementPtrInst *GEP =
new GetElementPtrInst(OAI, Indices,
- "gep_" + outputs[out]->getName(),
+ "gep_" + outputs[out]->getName(),
NTRet);
new StoreInst(outputs[out], GEP, NTRet);
} else {
// There are no successors (the block containing the switch itself), which
// means that previously this was the last part of the function, and hence
// this should be rewritten as a `ret'
-
+
// Check if the function should return a value
if (OldFnRetTy == Type::VoidTy) {
new ReturnInst(0, TheSwitch); // Return void
///
/// find inputs and outputs for the region
///
-/// for inputs: add to function as args, map input instr* to arg#
-/// for outputs: add allocas for scalars,
+/// for inputs: add to function as args, map input instr* to arg#
+/// for outputs: add allocas for scalars,
/// add to func as args, map output instr* to arg#
///
/// rewrite func to use argument #s instead of instr*
///
-/// for each scalar output in the function: at every exit, store intermediate
+/// for each scalar output in the function: at every exit, store intermediate
/// computed result back into memory.
///
Function *CodeExtractor::
assert(BlocksToExtract.count(*PI) &&
"No blocks in this region may have entries from outside the region"
" except for the first block!");
-
+
// If we have to split PHI nodes or the entry block, do so now.
severSplitPHINodes(header);
// Construct new function based on inputs/outputs & add allocas for all defs.
Function *newFunction = constructFunction(inputs, outputs, header,
- newFuncRoot,
+ newFuncRoot,
codeReplacer, oldFunction,
oldFunction->getParent());
if (!BlocksToExtract.count(PN->getIncomingBlock(i)))
PN->setIncomingBlock(i, newFuncRoot);
}
-
+
// Look at all successors of the codeReplacer block. If any of these blocks
// had PHI nodes in them, we need to update the "from" block to be the code
// replacer, not the original block in the extracted region.
--i; --e;
}
}
-
+
//std::cerr << "NEW FUNCTION: " << *newFunction;
// verifyFunction(*newFunction);
Function* llvm::ExtractBasicBlock(BasicBlock *BB, bool AggregateArgs) {
std::vector<BasicBlock*> Blocks;
Blocks.push_back(BB);
- return CodeExtractor(0, AggregateArgs).ExtractCodeRegion(Blocks);
+ return CodeExtractor(0, AggregateArgs).ExtractCodeRegion(Blocks);
}
projects / oota-llvm.git / blobdiff