1 //===- HexagonOptimizeSZextends.cpp - Remove unnecessary argument extends -===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Pass that removes sign extends for function parameters. These parameters 10 // are already sign extended by the caller per Hexagon's ABI 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/CodeGen/StackProtector.h" 15 #include "llvm/IR/Function.h" 16 #include "llvm/IR/Instructions.h" 17 #include "llvm/IR/IntrinsicInst.h" 18 #include "llvm/IR/IntrinsicsHexagon.h" 19 #include "llvm/Pass.h" 20 #include "llvm/Transforms/Scalar.h" 21 22 #include "Hexagon.h" 23 24 using namespace llvm; 25 26 namespace llvm { 27 FunctionPass *createHexagonOptimizeSZextends(); 28 void initializeHexagonOptimizeSZextendsPass(PassRegistry&); 29 } 30 31 namespace { 32 struct HexagonOptimizeSZextends : public FunctionPass { 33 public: 34 static char ID; 35 HexagonOptimizeSZextends() : FunctionPass(ID) { 36 initializeHexagonOptimizeSZextendsPass(*PassRegistry::getPassRegistry()); 37 } 38 bool runOnFunction(Function &F) override; 39 40 StringRef getPassName() const override { return "Remove sign extends"; } 41 42 void getAnalysisUsage(AnalysisUsage &AU) const override { 43 AU.addPreserved<StackProtector>(); 44 FunctionPass::getAnalysisUsage(AU); 45 } 46 47 bool intrinsicAlreadySextended(Intrinsic::ID IntID); 48 }; 49 } 50 51 char HexagonOptimizeSZextends::ID = 0; 52 53 INITIALIZE_PASS(HexagonOptimizeSZextends, "reargs", 54 "Remove Sign and Zero Extends for Args", false, false) 55 56 bool HexagonOptimizeSZextends::intrinsicAlreadySextended(Intrinsic::ID IntID) { 57 switch(IntID) { 58 case llvm::Intrinsic::hexagon_A2_addh_l16_sat_ll: 59 return true; 60 default: 61 break; 62 } 63 return false; 64 } 65 66 bool HexagonOptimizeSZextends::runOnFunction(Function &F) { 67 if (skipFunction(F)) 68 return false; 69 70 unsigned Idx = 1; 71 // Try to optimize sign extends in formal parameters. It's relying on 72 // callee already sign extending the values. I'm not sure if our ABI 73 // requires callee to sign extend though. 74 for (auto &Arg : F.args()) { 75 if (F.getAttributes().hasAttribute(Idx, Attribute::SExt)) { 76 if (!isa<PointerType>(Arg.getType())) { 77 for (auto UI = Arg.use_begin(); UI != Arg.use_end();) { 78 if (isa<SExtInst>(*UI)) { 79 Instruction* Use = cast<Instruction>(*UI); 80 SExtInst* SI = new SExtInst(&Arg, Use->getType()); 81 assert (EVT::getEVT(SI->getType()) == 82 (EVT::getEVT(Use->getType()))); 83 ++UI; 84 Use->replaceAllUsesWith(SI); 85 Instruction* First = &F.getEntryBlock().front(); 86 SI->insertBefore(First); 87 Use->eraseFromParent(); 88 } else { 89 ++UI; 90 } 91 } 92 } 93 } 94 ++Idx; 95 } 96 97 // Try to remove redundant sext operations on Hexagon. The hardware 98 // already sign extends many 16 bit intrinsic operations to 32 bits. 99 // For example: 100 // %34 = tail call i32 @llvm.hexagon.A2.addh.l16.sat.ll(i32 %x, i32 %y) 101 // %sext233 = shl i32 %34, 16 102 // %conv52 = ashr exact i32 %sext233, 16 103 for (auto &B : F) { 104 for (auto &I : B) { 105 // Look for arithmetic shift right by 16. 106 BinaryOperator *Ashr = dyn_cast<BinaryOperator>(&I); 107 if (!(Ashr && Ashr->getOpcode() == Instruction::AShr)) 108 continue; 109 Value *AshrOp1 = Ashr->getOperand(1); 110 ConstantInt *C = dyn_cast<ConstantInt>(AshrOp1); 111 // Right shifted by 16. 112 if (!(C && C->getSExtValue() == 16)) 113 continue; 114 115 // The first operand of Ashr comes from logical shift left. 116 Instruction *Shl = dyn_cast<Instruction>(Ashr->getOperand(0)); 117 if (!(Shl && Shl->getOpcode() == Instruction::Shl)) 118 continue; 119 Value *Intr = Shl->getOperand(0); 120 Value *ShlOp1 = Shl->getOperand(1); 121 C = dyn_cast<ConstantInt>(ShlOp1); 122 // Left shifted by 16. 123 if (!(C && C->getSExtValue() == 16)) 124 continue; 125 126 // The first operand of Shl comes from an intrinsic. 127 if (IntrinsicInst *I = dyn_cast<IntrinsicInst>(Intr)) { 128 if (!intrinsicAlreadySextended(I->getIntrinsicID())) 129 continue; 130 // All is well. Replace all uses of AShr with I. 131 for (auto UI = Ashr->user_begin(), UE = Ashr->user_end(); 132 UI != UE; ++UI) { 133 const Use &TheUse = UI.getUse(); 134 if (Instruction *J = dyn_cast<Instruction>(TheUse.getUser())) { 135 J->replaceUsesOfWith(Ashr, I); 136 } 137 } 138 } 139 } 140 } 141 142 return true; 143 } 144 145 146 FunctionPass *llvm::createHexagonOptimizeSZextends() { 147 return new HexagonOptimizeSZextends(); 148 } 149