6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-17 21:29:20 +00:00
Code Issues Projects Releases Wiki Activity

1. Documentation upgrade.

Browse Source 
2. Have UpgradeInstrinicCall return an Instruction* instead of a CallInst*
   and return the needed CastInst* if the result of the upgraded call needs
   to be casted back to a signed type.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25446 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Spencer 2006-01-19 06:59:26 +00:00
parent 3e59546352
commit 0fc0ab7148
1 changed files with 16 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
include/llvm/Assembly/AutoUpgrade.h
View File

@ -19,6 +19,7 @@
namespace llvm {
class Function;
class CallInst;
class Instruction;
/// This function determines if the \p Name provides is a name for which the
/// auto-upgrade to a non-overloaded name applies.
@ -38,18 +39,26 @@ namespace llvm {
/// @brief Remove overloaded intrinsic function names.
Function* UpgradeIntrinsicFunction(Function* F);
/// This function inspects the CallInst \p CI to see if it is a call to an
/// old overloaded intrinsic. If it is, the CallInst's name is changed to add
/// a suffix that indicates the kind of arguments or result that it accepts.
/// In LLVM 1.7, the overloading of intrinsic functions was replaced with
/// separate functions for each of the various argument sizes. This function
/// implements the auto-upgrade feature from old overloaded names to the new
/// non-overloaded names.
/// non-overloaded names. This function inspects the CallInst \p CI to see
/// if it is a call to an old overloaded intrinsic. If it is, a new CallInst
/// is created that uses the correct Function and possibly casts the
/// argument and result to an unsigned type. The caller can use the
/// returned Instruction to replace the existing one. Note that the
/// Instruction* returned could be a CallInst or a CastInst depending on
/// whether casting was necessary.
/// @param CI The CallInst to potentially auto-upgrade.
/// @returns True if the call was upgraded, false otherwise.
/// @brief Replace overloaded intrinsic function calls.
CallInst* UpgradeIntrinsicCall(CallInst* CI);
/// @returns An instrution to replace \p CI with.
/// @brief Get replacement instruction for overloaded intrinsic function call.
Instruction* UpgradeIntrinsicCall(CallInst* CI);
/// Upgrade both the function and all the calls made to it, if that function
/// needs to be upgraded. This is like a combination of the above two
/// functions, UpgradeIntrinsicFunction and UpgradeIntrinsicCall. Note that
/// the calls are replaced so this should only be used in a post-processing
/// manner (i.e. after all assembly/bytecode has been read).
bool UpgradeCallsToIntrinsic(Function* F);
} // End llvm namespace