llvm-6502/lib/VMCore/AutoUpgrade.cpp
Chris Lattner ffa987d3ee Split memcpy/memset/memmove intrinsics into i32/i64 versions, resolving
PR709, and paving the way for future progress.

Significantly refactor autoupgrading code, to handle the more complex case
(where we upgrade one argument in a function), and fix some bugs in it.

Testcase here: llvm/test/Regression/Bytecode/memcpy.ll


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26474 91177308-0d34-0410-b5e6-96231b3b80d8
2006-03-02 23:58:40 +00:00

249 lines
8.4 KiB
C++

//===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the auto-upgrade helper functions
//
//===----------------------------------------------------------------------===//
#include "llvm/Assembly/AutoUpgrade.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/SymbolTable.h"
#include <iostream>
using namespace llvm;
// Utility function for getting the correct suffix given a type
static inline const char *getTypeSuffix(const Type* Ty) {
switch (Ty->getTypeID()) {
case Type::ULongTyID: return ".i64";
case Type::UIntTyID: return ".i32";
case Type::UShortTyID: return ".i16";
case Type::UByteTyID: return ".i8";
case Type::FloatTyID: return ".f32";
case Type::DoubleTyID: return ".f64";
default: break;
}
return 0;
}
static Function *getUpgradedUnaryFn(Function *F) {
std::string Name = F->getName()+getTypeSuffix(F->getReturnType());
Module *M = F->getParent();
switch (F->getReturnType()->getTypeID()) {
default: return 0;
case Type::UByteTyID:
case Type::SByteTyID:
return M->getOrInsertFunction(Name,
Type::UByteTy, Type::UByteTy, NULL);
case Type::UShortTyID:
case Type::ShortTyID:
return M->getOrInsertFunction(Name,
Type::UShortTy, Type::UShortTy, NULL);
case Type::UIntTyID:
case Type::IntTyID:
return M->getOrInsertFunction(Name,
Type::UIntTy, Type::UIntTy, NULL);
case Type::ULongTyID:
case Type::LongTyID:
return M->getOrInsertFunction(Name,
Type::ULongTy, Type::ULongTy, NULL);
}
}
static Function *getUpgradedIntrinsic(Function *F) {
// If there's no function, we can't get the argument type.
if (!F) return 0;
// Get the Function's name.
const std::string& Name = F->getName();
// Quickly eliminate it, if it's not a candidate.
if (Name.length() <= 8 || Name[0] != 'l' || Name[1] != 'l' ||
Name[2] != 'v' || Name[3] != 'm' || Name[4] != '.')
return 0;
Module *M = F->getParent();
switch (Name[5]) {
default: break;
case 'b':
if (Name == "llvm.bswap") return getUpgradedUnaryFn(F);
break;
case 'c':
if (Name == "llvm.ctpop" || Name == "llvm.ctlz" || Name == "llvm.cttz")
return getUpgradedUnaryFn(F);
break;
case 'i':
if (Name == "llvm.isunordered" && F->arg_begin() != F->arg_end()) {
if (F->arg_begin()->getType() == Type::FloatTy)
return M->getOrInsertFunction(Name+".f32", F->getFunctionType());
if (F->arg_begin()->getType() == Type::DoubleTy)
return M->getOrInsertFunction(Name+".f64", F->getFunctionType());
}
break;
case 'm':
if (Name == "llvm.memcpy" || Name == "llvm.memset" ||
Name == "llvm.memmove") {
if (F->getFunctionType()->getParamType(2) == Type::UIntTy)
return M->getOrInsertFunction(Name+".i32", F->getFunctionType());
if (F->getFunctionType()->getParamType(2) == Type::ULongTy)
return M->getOrInsertFunction(Name+".i64", F->getFunctionType());
}
break;
case 's':
if (Name == "llvm.sqrt")
return getUpgradedUnaryFn(F);
break;
}
return 0;
}
// This assumes the Function is one of the intrinsics we upgraded.
static inline const Type* getTypeFromFunction(Function *F) {
const Type* Ty = F->getReturnType();
if (Ty->isFloatingPoint())
return Ty;
if (Ty->isSigned())
return Ty->getUnsignedVersion();
if (Ty->isInteger())
return Ty;
if (Ty == Type::BoolTy) {
Function::const_arg_iterator ArgIt = F->arg_begin();
if (ArgIt != F->arg_end())
return ArgIt->getType();
}
return 0;
}
// UpgradeIntrinsicFunction - Convert overloaded intrinsic function names to
// their non-overloaded variants by appending the appropriate suffix based on
// the argument types.
Function *llvm::UpgradeIntrinsicFunction(Function* F) {
// See if its one of the name's we're interested in.
if (Function *R = getUpgradedIntrinsic(F)) {
std::cerr << "WARNING: change " << F->getName() << " to "
<< R->getName() << "\n";
return R;
}
return 0;
}
Instruction* llvm::MakeUpgradedCall(Function *F,
const std::vector<Value*> &Params,
BasicBlock *BB, bool isTailCall,
unsigned CallingConv) {
assert(F && "Need a Function to make a CallInst");
assert(BB && "Need a BasicBlock to make a CallInst");
// Convert the params
bool signedArg = false;
std::vector<Value*> Oprnds;
for (std::vector<Value*>::const_iterator PI = Params.begin(),
PE = Params.end(); PI != PE; ++PI) {
const Type* opTy = (*PI)->getType();
if (opTy->isSigned()) {
signedArg = true;
CastInst* cast =
new CastInst(*PI,opTy->getUnsignedVersion(), "autoupgrade_cast");
BB->getInstList().push_back(cast);
Oprnds.push_back(cast);
}
else
Oprnds.push_back(*PI);
}
Instruction *result = new CallInst(F, Oprnds);
if (result->getType() != Type::VoidTy) result->setName("autoupgrade_call");
if (isTailCall) cast<CallInst>(result)->setTailCall();
if (CallingConv) cast<CallInst>(result)->setCallingConv(CallingConv);
if (signedArg) {
const Type* newTy = F->getReturnType()->getUnsignedVersion();
CastInst* final = new CastInst(result, newTy, "autoupgrade_uncast");
BB->getInstList().push_back(result);
result = final;
}
return result;
}
// UpgradeIntrinsicCall - In the BC reader, change a call to some intrinsic to
// be a called to the specified intrinsic. We expect the callees to have the
// same number of arguments, but their types may be different.
void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
Function *F = CI->getCalledFunction();
const FunctionType *NewFnTy = NewFn->getFunctionType();
std::vector<Value*> Oprnds;
for (unsigned i = 1, e = CI->getNumOperands(); i != e; ++i) {
Value *V = CI->getOperand(i);
if (V->getType() != NewFnTy->getParamType(i-1))
V = new CastInst(V, NewFnTy->getParamType(i-1), V->getName(), CI);
Oprnds.push_back(V);
}
CallInst *NewCI = new CallInst(NewFn, Oprnds, CI->getName(), CI);
NewCI->setTailCall(CI->isTailCall());
NewCI->setCallingConv(CI->getCallingConv());
if (!CI->use_empty()) {
Instruction *RetVal = NewCI;
if (F->getReturnType() != NewFn->getReturnType()) {
RetVal = new CastInst(NewCI, NewFn->getReturnType(),
NewCI->getName(), CI);
NewCI->moveBefore(RetVal);
}
CI->replaceAllUsesWith(RetVal);
}
CI->eraseFromParent();
}
bool llvm::UpgradeCallsToIntrinsic(Function* F) {
if (Function* newF = UpgradeIntrinsicFunction(F)) {
for (Value::use_iterator UI = F->use_begin(), UE = F->use_end();
UI != UE; ) {
if (CallInst* CI = dyn_cast<CallInst>(*UI++)) {
std::vector<Value*> Oprnds;
User::op_iterator OI = CI->op_begin();
++OI;
for (User::op_iterator OE = CI->op_end(); OI != OE; ++OI) {
const Type* opTy = OI->get()->getType();
if (opTy->isSigned()) {
Oprnds.push_back(
new CastInst(OI->get(),opTy->getUnsignedVersion(),
"autoupgrade_cast",CI));
} else {
Oprnds.push_back(*OI);
}
}
CallInst* newCI = new CallInst(newF, Oprnds,
CI->hasName() ? "autoupcall" : "", CI);
newCI->setTailCall(CI->isTailCall());
newCI->setCallingConv(CI->getCallingConv());
if (CI->use_empty()) {
// noop
} else if (CI->getType() != newCI->getType()) {
CastInst *final = new CastInst(newCI, CI->getType(),
"autoupgrade_uncast", newCI);
newCI->moveBefore(final);
CI->replaceAllUsesWith(final);
} else {
CI->replaceAllUsesWith(newCI);
}
CI->eraseFromParent();
}
}
if (newF != F)
F->eraseFromParent();
return true;
}
return false;
}