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/AutoUpgrade.h"
15 #include "llvm/DebugInfo.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DiagnosticInfo.h"
18 #include "llvm/IR/Function.h"
19 #include "llvm/IR/IRBuilder.h"
20 #include "llvm/IR/Instruction.h"
21 #include "llvm/IR/IntrinsicInst.h"
22 #include "llvm/IR/LLVMContext.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/Support/CFG.h"
25 #include "llvm/Support/CallSite.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.startswith("x86.xop.vpcom") && F->arg_size() == 2)) {
121 // SSE4.1 ptest functions may have an old signature.
122 if (Name.startswith("x86.sse41.ptest")) {
123 if (Name == "x86.sse41.ptestc")
124 return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestc, NewFn);
125 if (Name == "x86.sse41.ptestz")
126 return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestz, NewFn);
127 if (Name == "x86.sse41.ptestnzc")
128 return UpgradeSSE41Function(F, Intrinsic::x86_sse41_ptestnzc, NewFn);
130 // frcz.ss/sd may need to have an argument dropped
131 if (Name.startswith("x86.xop.vfrcz.ss") && F->arg_size() == 2) {
132 F->setName(Name + ".old");
133 NewFn = Intrinsic::getDeclaration(F->getParent(),
134 Intrinsic::x86_xop_vfrcz_ss);
137 if (Name.startswith("x86.xop.vfrcz.sd") && F->arg_size() == 2) {
138 F->setName(Name + ".old");
139 NewFn = Intrinsic::getDeclaration(F->getParent(),
140 Intrinsic::x86_xop_vfrcz_sd);
143 // Fix the FMA4 intrinsics to remove the 4
144 if (Name.startswith("x86.fma4.")) {
145 F->setName("llvm.x86.fma" + Name.substr(8));
153 // This may not belong here. This function is effectively being overloaded
154 // to both detect an intrinsic which needs upgrading, and to provide the
155 // upgraded form of the intrinsic. We should perhaps have two separate
156 // functions for this.
160 bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
162 bool Upgraded = UpgradeIntrinsicFunction1(F, NewFn);
164 // Upgrade intrinsic attributes. This does not change the function.
167 if (unsigned id = F->getIntrinsicID())
168 F->setAttributes(Intrinsic::getAttributes(F->getContext(),
173 bool llvm::UpgradeGlobalVariable(GlobalVariable *GV) {
174 // Nothing to do yet.
178 // UpgradeIntrinsicCall - Upgrade a call to an old intrinsic to be a call the
179 // upgraded intrinsic. All argument and return casting must be provided in
180 // order to seamlessly integrate with existing context.
181 void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
182 Function *F = CI->getCalledFunction();
183 LLVMContext &C = CI->getContext();
184 IRBuilder<> Builder(C);
185 Builder.SetInsertPoint(CI->getParent(), CI);
187 assert(F && "Intrinsic call is not direct?");
190 // Get the Function's name.
191 StringRef Name = F->getName();
194 // Upgrade packed integer vector compares intrinsics to compare instructions
195 if (Name.startswith("llvm.x86.sse2.pcmpeq.") ||
196 Name.startswith("llvm.x86.avx2.pcmpeq.")) {
197 Rep = Builder.CreateICmpEQ(CI->getArgOperand(0), CI->getArgOperand(1),
199 // need to sign extend since icmp returns vector of i1
200 Rep = Builder.CreateSExt(Rep, CI->getType(), "");
201 } else if (Name.startswith("llvm.x86.sse2.pcmpgt.") ||
202 Name.startswith("llvm.x86.avx2.pcmpgt.")) {
203 Rep = Builder.CreateICmpSGT(CI->getArgOperand(0), CI->getArgOperand(1),
205 // need to sign extend since icmp returns vector of i1
206 Rep = Builder.CreateSExt(Rep, CI->getType(), "");
207 } else if (Name == "llvm.x86.avx.movnt.dq.256" ||
208 Name == "llvm.x86.avx.movnt.ps.256" ||
209 Name == "llvm.x86.avx.movnt.pd.256") {
210 IRBuilder<> Builder(C);
211 Builder.SetInsertPoint(CI->getParent(), CI);
213 Module *M = F->getParent();
214 SmallVector<Value *, 1> Elts;
215 Elts.push_back(ConstantInt::get(Type::getInt32Ty(C), 1));
216 MDNode *Node = MDNode::get(C, Elts);
218 Value *Arg0 = CI->getArgOperand(0);
219 Value *Arg1 = CI->getArgOperand(1);
221 // Convert the type of the pointer to a pointer to the stored type.
222 Value *BC = Builder.CreateBitCast(Arg0,
223 PointerType::getUnqual(Arg1->getType()),
225 StoreInst *SI = Builder.CreateStore(Arg1, BC);
226 SI->setMetadata(M->getMDKindID("nontemporal"), Node);
227 SI->setAlignment(16);
230 CI->eraseFromParent();
232 } else if (Name.startswith("llvm.x86.xop.vpcom")) {
234 if (Name.endswith("ub"))
235 intID = Intrinsic::x86_xop_vpcomub;
236 else if (Name.endswith("uw"))
237 intID = Intrinsic::x86_xop_vpcomuw;
238 else if (Name.endswith("ud"))
239 intID = Intrinsic::x86_xop_vpcomud;
240 else if (Name.endswith("uq"))
241 intID = Intrinsic::x86_xop_vpcomuq;
242 else if (Name.endswith("b"))
243 intID = Intrinsic::x86_xop_vpcomb;
244 else if (Name.endswith("w"))
245 intID = Intrinsic::x86_xop_vpcomw;
246 else if (Name.endswith("d"))
247 intID = Intrinsic::x86_xop_vpcomd;
248 else if (Name.endswith("q"))
249 intID = Intrinsic::x86_xop_vpcomq;
251 llvm_unreachable("Unknown suffix");
253 Name = Name.substr(18); // strip off "llvm.x86.xop.vpcom"
255 if (Name.startswith("lt"))
257 else if (Name.startswith("le"))
259 else if (Name.startswith("gt"))
261 else if (Name.startswith("ge"))
263 else if (Name.startswith("eq"))
265 else if (Name.startswith("ne"))
267 else if (Name.startswith("true"))
269 else if (Name.startswith("false"))
272 llvm_unreachable("Unknown condition");
274 Function *VPCOM = Intrinsic::getDeclaration(F->getParent(), intID);
275 Rep = Builder.CreateCall3(VPCOM, CI->getArgOperand(0),
276 CI->getArgOperand(1), Builder.getInt8(Imm));
277 } else if (Name == "llvm.x86.sse42.crc32.64.8") {
278 Function *CRC32 = Intrinsic::getDeclaration(F->getParent(),
279 Intrinsic::x86_sse42_crc32_32_8);
280 Value *Trunc0 = Builder.CreateTrunc(CI->getArgOperand(0), Type::getInt32Ty(C));
281 Rep = Builder.CreateCall2(CRC32, Trunc0, CI->getArgOperand(1));
282 Rep = Builder.CreateZExt(Rep, CI->getType(), "");
284 bool PD128 = false, PD256 = false, PS128 = false, PS256 = false;
285 if (Name == "llvm.x86.avx.vpermil.pd.256")
287 else if (Name == "llvm.x86.avx.vpermil.pd")
289 else if (Name == "llvm.x86.avx.vpermil.ps.256")
291 else if (Name == "llvm.x86.avx.vpermil.ps")
294 if (PD256 || PD128 || PS256 || PS128) {
295 Value *Op0 = CI->getArgOperand(0);
296 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
297 SmallVector<Constant*, 8> Idxs;
300 for (unsigned i = 0; i != 2; ++i)
301 Idxs.push_back(Builder.getInt32((Imm >> i) & 0x1));
303 for (unsigned l = 0; l != 4; l+=2)
304 for (unsigned i = 0; i != 2; ++i)
305 Idxs.push_back(Builder.getInt32(((Imm >> (l+i)) & 0x1) + l));
307 for (unsigned i = 0; i != 4; ++i)
308 Idxs.push_back(Builder.getInt32((Imm >> (2 * i)) & 0x3));
310 for (unsigned l = 0; l != 8; l+=4)
311 for (unsigned i = 0; i != 4; ++i)
312 Idxs.push_back(Builder.getInt32(((Imm >> (2 * i)) & 0x3) + l));
314 llvm_unreachable("Unexpected function");
316 Rep = Builder.CreateShuffleVector(Op0, Op0, ConstantVector::get(Idxs));
318 llvm_unreachable("Unknown function for CallInst upgrade.");
322 CI->replaceAllUsesWith(Rep);
323 CI->eraseFromParent();
327 std::string Name = CI->getName().str();
328 CI->setName(Name + ".old");
330 switch (NewFn->getIntrinsicID()) {
332 llvm_unreachable("Unknown function for CallInst upgrade.");
334 case Intrinsic::ctlz:
335 case Intrinsic::cttz:
336 assert(CI->getNumArgOperands() == 1 &&
337 "Mismatch between function args and call args");
338 CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->getArgOperand(0),
339 Builder.getFalse(), Name));
340 CI->eraseFromParent();
343 case Intrinsic::objectsize:
344 CI->replaceAllUsesWith(Builder.CreateCall2(NewFn,
345 CI->getArgOperand(0),
346 CI->getArgOperand(1),
348 CI->eraseFromParent();
351 case Intrinsic::arm_neon_vclz: {
352 // Change name from llvm.arm.neon.vclz.* to llvm.ctlz.*
353 CI->replaceAllUsesWith(Builder.CreateCall2(NewFn, CI->getArgOperand(0),
355 "llvm.ctlz." + Name.substr(14)));
356 CI->eraseFromParent();
359 case Intrinsic::ctpop: {
360 CI->replaceAllUsesWith(Builder.CreateCall(NewFn, CI->getArgOperand(0)));
361 CI->eraseFromParent();
365 case Intrinsic::x86_xop_vfrcz_ss:
366 case Intrinsic::x86_xop_vfrcz_sd:
367 CI->replaceAllUsesWith(Builder.CreateCall(NewFn, CI->getArgOperand(1),
369 CI->eraseFromParent();
372 case Intrinsic::x86_sse41_ptestc:
373 case Intrinsic::x86_sse41_ptestz:
374 case Intrinsic::x86_sse41_ptestnzc: {
375 // The arguments for these intrinsics used to be v4f32, and changed
376 // to v2i64. This is purely a nop, since those are bitwise intrinsics.
377 // So, the only thing required is a bitcast for both arguments.
378 // First, check the arguments have the old type.
379 Value *Arg0 = CI->getArgOperand(0);
380 if (Arg0->getType() != VectorType::get(Type::getFloatTy(C), 4))
383 // Old intrinsic, add bitcasts
384 Value *Arg1 = CI->getArgOperand(1);
387 Builder.CreateBitCast(Arg0,
388 VectorType::get(Type::getInt64Ty(C), 2),
391 Builder.CreateBitCast(Arg1,
392 VectorType::get(Type::getInt64Ty(C), 2),
395 CallInst* NewCall = Builder.CreateCall2(NewFn, BC0, BC1, Name);
396 CI->replaceAllUsesWith(NewCall);
397 CI->eraseFromParent();
403 // This tests each Function to determine if it needs upgrading. When we find
404 // one we are interested in, we then upgrade all calls to reflect the new
406 void llvm::UpgradeCallsToIntrinsic(Function* F) {
407 assert(F && "Illegal attempt to upgrade a non-existent intrinsic.");
409 // Upgrade the function and check if it is a totaly new function.
411 if (UpgradeIntrinsicFunction(F, NewFn)) {
413 // Replace all uses to the old function with the new one if necessary.
414 for (Value::use_iterator UI = F->use_begin(), UE = F->use_end();
416 if (CallInst *CI = dyn_cast<CallInst>(*UI++))
417 UpgradeIntrinsicCall(CI, NewFn);
419 // Remove old function, no longer used, from the module.
420 F->eraseFromParent();
425 void llvm::UpgradeInstWithTBAATag(Instruction *I) {
426 MDNode *MD = I->getMetadata(LLVMContext::MD_tbaa);
427 assert(MD && "UpgradeInstWithTBAATag should have a TBAA tag");
428 // Check if the tag uses struct-path aware TBAA format.
429 if (isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3)
432 if (MD->getNumOperands() == 3) {
437 MDNode *ScalarType = MDNode::get(I->getContext(), Elts);
438 // Create a MDNode <ScalarType, ScalarType, offset 0, const>
440 ScalarType, ScalarType,
441 Constant::getNullValue(Type::getInt64Ty(I->getContext())),
444 I->setMetadata(LLVMContext::MD_tbaa, MDNode::get(I->getContext(), Elts2));
446 // Create a MDNode <MD, MD, offset 0>
447 Value *Elts[] = {MD, MD,
448 Constant::getNullValue(Type::getInt64Ty(I->getContext()))};
449 I->setMetadata(LLVMContext::MD_tbaa, MDNode::get(I->getContext(), Elts));
453 Instruction *llvm::UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy,
454 Instruction *&Temp) {
455 if (Opc != Instruction::BitCast)
459 Type *SrcTy = V->getType();
460 if (SrcTy->isPtrOrPtrVectorTy() && DestTy->isPtrOrPtrVectorTy() &&
461 SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace()) {
462 LLVMContext &Context = V->getContext();
464 // We have no information about target data layout, so we assume that
465 // the maximum pointer size is 64bit.
466 Type *MidTy = Type::getInt64Ty(Context);
467 Temp = CastInst::Create(Instruction::PtrToInt, V, MidTy);
469 return CastInst::Create(Instruction::IntToPtr, Temp, DestTy);
475 Value *llvm::UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy) {
476 if (Opc != Instruction::BitCast)
479 Type *SrcTy = C->getType();
480 if (SrcTy->isPtrOrPtrVectorTy() && DestTy->isPtrOrPtrVectorTy() &&
481 SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace()) {
482 LLVMContext &Context = C->getContext();
484 // We have no information about target data layout, so we assume that
485 // the maximum pointer size is 64bit.
486 Type *MidTy = Type::getInt64Ty(Context);
488 return ConstantExpr::getIntToPtr(ConstantExpr::getPtrToInt(C, MidTy),
495 /// Check the debug info version number, if it is out-dated, drop the debug
496 /// info. Return true if module is modified.
497 bool llvm::UpgradeDebugInfo(Module &M) {
498 unsigned Version = getDebugMetadataVersionFromModule(M);
499 if (Version == DEBUG_METADATA_VERSION)
502 bool RetCode = StripDebugInfo(M);
504 DiagnosticInfoDebugMetadataVersion DiagVersion(M, Version);
505 M.getContext().diagnose(DiagVersion);