1 //===-- AutoUpgrade.cpp - Implement auto-upgrade helper functions ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the auto-upgrade helper functions
12 //===----------------------------------------------------------------------===//
14 #include "llvm/IR/AutoUpgrade.h"
15 #include "llvm/IR/CFG.h"
16 #include "llvm/IR/CallSite.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/DebugInfo.h"
19 #include "llvm/IR/DiagnosticInfo.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/IRBuilder.h"
22 #include "llvm/IR/Instruction.h"
23 #include "llvm/IR/IntrinsicInst.h"
24 #include "llvm/IR/LLVMContext.h"
25 #include "llvm/IR/Module.h"
26 #include "llvm/Support/ErrorHandling.h"
30 // Upgrade the declarations of the SSE4.1 functions whose arguments have
31 // changed their type from v4f32 to v2i64.
32 static bool UpgradeSSE41Function(Function* F, Intrinsic::ID IID,
34 // Check whether this is an old version of the function, which received
36 Type *Arg0Type = F->getFunctionType()->getParamType(0);
37 if (Arg0Type != VectorType::get(Type::getFloatTy(F->getContext()), 4))
40 // Yes, it's old, replace it with new version.
41 F->setName(F->getName() + ".old");
42 NewFn = Intrinsic::getDeclaration(F->getParent(), IID);
46 static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
47 assert(F && "Illegal to upgrade a non-existent Function.");
49 // Quickly eliminate it, if it's not a candidate.
50 StringRef Name = F->getName();
51 if (Name.size() <= 8 || !Name.startswith("llvm."))
53 Name = Name.substr(5); // Strip off "llvm."
58 if (Name.startswith("arm.neon.vclz")) {
60 F->arg_begin()->getType(),
61 Type::getInt1Ty(F->getContext())
63 // Can't use Intrinsic::getDeclaration here as it adds a ".i1" to
64 // the end of the name. Change name from llvm.arm.neon.vclz.* to
66 FunctionType* fType = FunctionType::get(F->getReturnType(), args, false);
67 NewFn = Function::Create(fType, F->getLinkage(),
68 "llvm.ctlz." + Name.substr(14), F->getParent());
71 if (Name.startswith("arm.neon.vcnt")) {
72 NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctpop,
73 F->arg_begin()->getType());
79 if (Name.startswith("ctlz.") && F->arg_size() == 1) {
80 F->setName(Name + ".old");
81 NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctlz,
82 F->arg_begin()->getType());
85 if (Name.startswith("cttz.") && F->arg_size() == 1) {
86 F->setName(Name + ".old");
87 NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::cttz,
88 F->arg_begin()->getType());
94 // We only need to change the name to match the mangling including the
96 if (F->arg_size() == 2 && Name.startswith("objectsize.")) {
97 Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() };
98 if (F->getName() != Intrinsic::getName(Intrinsic::objectsize, Tys)) {
99 F->setName(Name + ".old");
100 NewFn = Intrinsic::getDeclaration(F->getParent(),
101 Intrinsic::objectsize, Tys);
108 if (Name.startswith("x86.sse2.pcmpeq.") ||
109 Name.startswith("x86.sse2.pcmpgt.") ||
110 Name.startswith("x86.avx2.pcmpeq.") ||
111 Name.startswith("x86.avx2.pcmpgt.") ||
112 Name.startswith("x86.avx.vpermil.") ||
113 Name == "x86.avx.movnt.dq.256" ||
114 Name == "x86.avx.movnt.pd.256" ||
115 Name == "x86.avx.movnt.ps.256" ||
116 Name == "x86.sse42.crc32.64.8" ||
117 Name == "x86.avx.vbroadcast.ss" ||
118 Name == "x86.avx.vbroadcast.ss.256" ||
119 Name == "x86.avx.vbroadcast.sd.256" ||
120 (Name.startswith("x86.xop.vpcom") && F->arg_size() == 2)) {
124 // SSE4.1 ptest functions may have an old signature.
125 if (Name.startswith("x86.sse41.ptest")) {
126 if (Name == "x86.sse41.ptestc")
127 return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestc, NewFn);
128 if (Name == "x86.sse41.ptestz")
129 return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestz, NewFn);
130 if (Name == "x86.sse41.ptestnzc")
131 return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestnzc, NewFn);
133 // frcz.ss/sd may need to have an argument dropped
134 if (Name.startswith("x86.xop.vfrcz.ss") && F->arg_size() == 2) {
135 F->setName(Name + ".old");
136 NewFn = Intrinsic::getDeclaration(F->getParent(),
137 Intrinsic::x86_xop_vfrcz_ss);
140 if (Name.startswith("x86.xop.vfrcz.sd") && F->arg_size() == 2) {
141 F->setName(Name + ".old");
142 NewFn = Intrinsic::getDeclaration(F->getParent(),
143 Intrinsic::x86_xop_vfrcz_sd);
146 // Fix the FMA4 intrinsics to remove the 4
147 if (Name.startswith("x86.fma4.")) {
148 F->setName("llvm.x86.fma" + Name.substr(8));
156 // This may not belong here. This function is effectively being overloaded
157 // to both detect an intrinsic which needs upgrading, and to provide the
158 // upgraded form of the intrinsic. We should perhaps have two separate
159 // functions for this.
163 bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
165 bool Upgraded = UpgradeIntrinsicFunction1(F, NewFn);
167 // Upgrade intrinsic attributes. This does not change the function.
170 if (unsigned id = F->getIntrinsicID())
171 F->setAttributes(Intrinsic::getAttributes(F->getContext(),
176 bool llvm::UpgradeGlobalVariable(GlobalVariable *GV) {
177 // Nothing to do yet.
181 // UpgradeIntrinsicCall - Upgrade a call to an old intrinsic to be a call the
182 // upgraded intrinsic. All argument and return casting must be provided in
183 // order to seamlessly integrate with existing context.
184 void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
185 Function *F = CI->getCalledFunction();
186 LLVMContext &C = CI->getContext();
187 IRBuilder<> Builder(C);
188 Builder.SetInsertPoint(CI->getParent(), CI);
190 assert(F && "Intrinsic call is not direct?");
193 // Get the Function's name.
194 StringRef Name = F->getName();
197 // Upgrade packed integer vector compares intrinsics to compare instructions
198 if (Name.startswith("llvm.x86.sse2.pcmpeq.") ||
199 Name.startswith("llvm.x86.avx2.pcmpeq.")) {
200 Rep = Builder.CreateICmpEQ(CI->getArgOperand(0), CI->getArgOperand(1),
202 // need to sign extend since icmp returns vector of i1
203 Rep = Builder.CreateSExt(Rep, CI->getType(), "");
204 } else if (Name.startswith("llvm.x86.sse2.pcmpgt.") ||
205 Name.startswith("llvm.x86.avx2.pcmpgt.")) {
206 Rep = Builder.CreateICmpSGT(CI->getArgOperand(0), CI->getArgOperand(1),
208 // need to sign extend since icmp returns vector of i1
209 Rep = Builder.CreateSExt(Rep, CI->getType(), "");
210 } else if (Name == "llvm.x86.avx.movnt.dq.256" ||
211 Name == "llvm.x86.avx.movnt.ps.256" ||
212 Name == "llvm.x86.avx.movnt.pd.256") {
213 IRBuilder<> Builder(C);
214 Builder.SetInsertPoint(CI->getParent(), CI);
216 Module *M = F->getParent();
217 SmallVector<Value *, 1> Elts;
218 Elts.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
219 MDNode *Node = MDNode::get(C, Elts);
221 Value *Arg0 = CI->getArgOperand(0);
222 Value *Arg1 = CI->getArgOperand(1);
224 // Convert the type of the pointer to a pointer to the stored type.
225 Value *BC = Builder.CreateBitCast(Arg0,
226 PointerType::getUnqual(Arg1->getType()),
228 StoreInst *SI = Builder.CreateStore(Arg1, BC);
229 SI->setMetadata(M->getMDKindID("nontemporal"), Node);
230 SI->setAlignment(16);
233 CI->eraseFromParent();
235 } else if (Name.startswith("llvm.x86.xop.vpcom")) {
237 if (Name.endswith("ub"))
238 intID = Intrinsic::x86_xop_vpcomub;
239 else if (Name.endswith("uw"))
240 intID = Intrinsic::x86_xop_vpcomuw;
241 else if (Name.endswith("ud"))
242 intID = Intrinsic::x86_xop_vpcomud;
243 else if (Name.endswith("uq"))
244 intID = Intrinsic::x86_xop_vpcomuq;
245 else if (Name.endswith("b"))
246 intID = Intrinsic::x86_xop_vpcomb;
247 else if (Name.endswith("w"))
248 intID = Intrinsic::x86_xop_vpcomw;
249 else if (Name.endswith("d"))
250 intID = Intrinsic::x86_xop_vpcomd;
251 else if (Name.endswith("q"))
252 intID = Intrinsic::x86_xop_vpcomq;
254 llvm_unreachable("Unknown suffix");
256 Name = Name.substr(18); // strip off "llvm.x86.xop.vpcom"
258 if (Name.startswith("lt"))
260 else if (Name.startswith("le"))
262 else if (Name.startswith("gt"))
264 else if (Name.startswith("ge"))
266 else if (Name.startswith("eq"))
268 else if (Name.startswith("ne"))
270 else if (Name.startswith("true"))
272 else if (Name.startswith("false"))
275 llvm_unreachable("Unknown condition");
277 Function *VPCOM = Intrinsic::getDeclaration(F->getParent(), intID);
278 Rep = Builder.CreateCall3(VPCOM, CI->getArgOperand(0),
279 CI->getArgOperand(1), Builder.getInt8(Imm));
280 } else if (Name == "llvm.x86.sse42.crc32.64.8") {
281 Function *CRC32 = Intrinsic::getDeclaration(F->getParent(),
282 Intrinsic::x86_sse42_crc32_32_8);
283 Value *Trunc0 = Builder.CreateTrunc(CI->getArgOperand(0), Type::getInt32Ty(C));
284 Rep = Builder.CreateCall2(CRC32, Trunc0, CI->getArgOperand(1));
285 Rep = Builder.CreateZExt(Rep, CI->getType(), "");
286 } else if (Name.startswith("llvm.x86.avx.vbroadcast")) {
287 // Replace broadcasts with a series of insertelements.
288 Type *VecTy = CI->getType();
289 Type *EltTy = VecTy->getVectorElementType();
290 unsigned EltNum = VecTy->getVectorNumElements();
291 Value *Cast = Builder.CreateBitCast(CI->getArgOperand(0),
292 EltTy->getPointerTo());
293 Value *Load = Builder.CreateLoad(Cast);
294 Type *I32Ty = Type::getInt32Ty(C);
295 Rep = UndefValue::get(VecTy);
296 for (unsigned I = 0; I < EltNum; ++I)
297 Rep = Builder.CreateInsertElement(Rep, Load,
298 ConstantInt::get(I32Ty, I));
300 bool PD128 = false, PD256 = false, PS128 = false, PS256 = false;
301 if (Name == "llvm.x86.avx.vpermil.pd.256")
303 else if (Name == "llvm.x86.avx.vpermil.pd")
305 else if (Name == "llvm.x86.avx.vpermil.ps.256")
307 else if (Name == "llvm.x86.avx.vpermil.ps")
310 if (PD256 || PD128 || PS256 || PS128) {
311 Value *Op0 = CI->getArgOperand(0);
312 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
313 SmallVector<Constant*, 8> Idxs;
316 for (unsigned i = 0; i != 2; ++i)
317 Idxs.push_back(Builder.getInt32((Imm >> i) & 0x1));
319 for (unsigned l = 0; l != 4; l+=2)
320 for (unsigned i = 0; i != 2; ++i)
321 Idxs.push_back(Builder.getInt32(((Imm >> (l+i)) & 0x1) + l));
323 for (unsigned i = 0; i != 4; ++i)
324 Idxs.push_back(Builder.getInt32((Imm >> (2 * i)) & 0x3));
326 for (unsigned l = 0; l != 8; l+=4)
327 for (unsigned i = 0; i != 4; ++i)
328 Idxs.push_back(Builder.getInt32(((Imm >> (2 * i)) & 0x3) + l));
330 llvm_unreachable("Unexpected function");
332 Rep = Builder.CreateShuffleVector(Op0, Op0, ConstantVector::get(Idxs));
334 llvm_unreachable("Unknown function for CallInst upgrade.");
338 CI->replaceAllUsesWith(Rep);
339 CI->eraseFromParent();
343 std::string Name = CI->getName().str();
344 CI->setName(Name + ".old");
346 switch (NewFn->getIntrinsicID()) {
348 llvm_unreachable("Unknown function for CallInst upgrade.");
350 case Intrinsic::ctlz:
351 case Intrinsic::cttz:
352 assert(CI->getNumArgOperands() == 1 &&
353 "Mismatch between function args and call args");
354 CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->getArgOperand(0),
355 Builder.getFalse(), Name));
356 CI->eraseFromParent();
359 case Intrinsic::objectsize:
360 CI->replaceAllUsesWith(Builder.CreateCall2(NewFn,
361 CI->getArgOperand(0),
362 CI->getArgOperand(1),
364 CI->eraseFromParent();
367 case Intrinsic::arm_neon_vclz: {
368 // Change name from llvm.arm.neon.vclz.* to llvm.ctlz.*
369 CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->getArgOperand(0),
371 "llvm.ctlz." + Name.substr(14)));
372 CI->eraseFromParent();
375 case Intrinsic::ctpop: {
376 CI->replaceAllUsesWith(Builder.CreateCall(NewFn, CI->getArgOperand(0)));
377 CI->eraseFromParent();
381 case Intrinsic::x86_xop_vfrcz_ss:
382 case Intrinsic::x86_xop_vfrcz_sd:
383 CI->replaceAllUsesWith(Builder.CreateCall(NewFn, CI->getArgOperand(1),
385 CI->eraseFromParent();
388 case Intrinsic::x86_sse41_ptestc:
389 case Intrinsic::x86_sse41_ptestz:
390 case Intrinsic::x86_sse41_ptestnzc: {
391 // The arguments for these intrinsics used to be v4f32, and changed
392 // to v2i64. This is purely a nop, since those are bitwise intrinsics.
393 // So, the only thing required is a bitcast for both arguments.
394 // First, check the arguments have the old type.
395 Value *Arg0 = CI->getArgOperand(0);
396 if (Arg0->getType() != VectorType::get(Type::getFloatTy(C), 4))
399 // Old intrinsic, add bitcasts
400 Value *Arg1 = CI->getArgOperand(1);
403 Builder.CreateBitCast(Arg0,
404 VectorType::get(Type::getInt64Ty(C), 2),
407 Builder.CreateBitCast(Arg1,
408 VectorType::get(Type::getInt64Ty(C), 2),
411 CallInst* NewCall = Builder.CreateCall2(NewFn, BC0, BC1, Name);
412 CI->replaceAllUsesWith(NewCall);
413 CI->eraseFromParent();
419 // This tests each Function to determine if it needs upgrading. When we find
420 // one we are interested in, we then upgrade all calls to reflect the new
422 void llvm::UpgradeCallsToIntrinsic(Function* F) {
423 assert(F && "Illegal attempt to upgrade a non-existent intrinsic.");
425 // Upgrade the function and check if it is a totaly new function.
427 if (UpgradeIntrinsicFunction(F, NewFn)) {
429 // Replace all uses to the old function with the new one if necessary.
430 for (Value::user_iterator UI = F->user_begin(), UE = F->user_end();
432 if (CallInst *CI = dyn_cast<CallInst>(*UI++))
433 UpgradeIntrinsicCall(CI, NewFn);
435 // Remove old function, no longer used, from the module.
436 F->eraseFromParent();
441 void llvm::UpgradeInstWithTBAATag(Instruction *I) {
442 MDNode *MD = I->getMetadata(LLVMContext::MD_tbaa);
443 assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag");
444 // Check if the tag uses struct-path aware TBAA format.
445 if (isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3)
448 if (MD->getNumOperands() == 3) {
453 MDNode *ScalarType = MDNode::get(I->getContext(), Elts);
454 // Create a MDNode <ScalarType, ScalarType, offset 0, const>
456 ScalarType, ScalarType,
457 Constant::getNullValue(Type::getInt64Ty(I->getContext())),
460 I->setMetadata(LLVMContext::MD_tbaa, MDNode::get(I->getContext(), Elts2));
462 // Create a MDNode <MD, MD, offset 0>
463 Value *Elts[] = {MD, MD,
464 Constant::getNullValue(Type::getInt64Ty(I->getContext()))};
465 I->setMetadata(LLVMContext::MD_tbaa, MDNode::get(I->getContext(), Elts));
469 Instruction *llvm::UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy,
470 Instruction *&Temp) {
471 if (Opc != Instruction::BitCast)
475 Type *SrcTy = V->getType();
476 if (SrcTy->isPtrOrPtrVectorTy() && DestTy->isPtrOrPtrVectorTy() &&
477 SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace()) {
478 LLVMContext &Context = V->getContext();
480 // We have no information about target data layout, so we assume that
481 // the maximum pointer size is 64bit.
482 Type *MidTy = Type::getInt64Ty(Context);
483 Temp = CastInst::Create(Instruction::PtrToInt, V, MidTy);
485 return CastInst::Create(Instruction::IntToPtr, Temp, DestTy);
491 Value *llvm::UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy) {
492 if (Opc != Instruction::BitCast)
495 Type *SrcTy = C->getType();
496 if (SrcTy->isPtrOrPtrVectorTy() && DestTy->isPtrOrPtrVectorTy() &&
497 SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace()) {
498 LLVMContext &Context = C->getContext();
500 // We have no information about target data layout, so we assume that
501 // the maximum pointer size is 64bit.
502 Type *MidTy = Type::getInt64Ty(Context);
504 return ConstantExpr::getIntToPtr(ConstantExpr::getPtrToInt(C, MidTy),
511 /// Check the debug info version number, if it is out-dated, drop the debug
512 /// info. Return true if module is modified.
513 bool llvm::UpgradeDebugInfo(Module &M) {
514 unsigned Version = getDebugMetadataVersionFromModule(M);
515 if (Version == DEBUG_METADATA_VERSION)
518 bool RetCode = StripDebugInfo(M);
520 DiagnosticInfoDebugMetadataVersion DiagVersion(M, Version);
521 M.getContext().diagnose(DiagVersion);
526 void llvm::UpgradeMDStringConstant(std::string &String) {
527 const std::string OldPrefix = "llvm.vectorizer.";
528 if (String == "llvm.vectorizer.unroll") {
529 String = "llvm.loop.interleave.count";
530 } else if (String.find(OldPrefix) == 0) {
531 String.replace(0, OldPrefix.size(), "llvm.loop.vectorize.");