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 "Hexagon.h"
15 #include "llvm/CodeGen/StackProtector.h"
16 #include "llvm/CodeGen/ValueTypes.h"
17 #include "llvm/IR/Function.h"
18 #include "llvm/IR/Instructions.h"
19 #include "llvm/IR/IntrinsicInst.h"
20 #include "llvm/IR/IntrinsicsHexagon.h"
21 #include "llvm/Pass.h"
22 #include "llvm/Transforms/Scalar.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 = 0;
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().hasParamAttr(Idx, Attribute::SExt)) {
76       if (!isa<PointerType>(Arg.getType())) {
77         for (Use &U : llvm::make_early_inc_range(Arg.uses())) {
78           if (isa<SExtInst>(U)) {
79             Instruction* Use = cast<Instruction>(U);
80             SExtInst* SI = new SExtInst(&Arg, Use->getType());
81             assert (EVT::getEVT(SI->getType()) ==
82                     (EVT::getEVT(Use->getType())));
83             Use->replaceAllUsesWith(SI);
84             Instruction* First = &F.getEntryBlock().front();
85             SI->insertBefore(First);
86             Use->eraseFromParent();
87           }
88         }
89       }
90     }
91     ++Idx;
92   }
93 
94   // Try to remove redundant sext operations on Hexagon. The hardware
95   // already sign extends many 16 bit intrinsic operations to 32 bits.
96   // For example:
97   // %34 = tail call i32 @llvm.hexagon.A2.addh.l16.sat.ll(i32 %x, i32 %y)
98   // %sext233 = shl i32 %34, 16
99   // %conv52 = ashr exact i32 %sext233, 16
100   for (auto &B : F) {
101     for (auto &I : B) {
102       // Look for arithmetic shift right by 16.
103       BinaryOperator *Ashr = dyn_cast<BinaryOperator>(&I);
104       if (!(Ashr && Ashr->getOpcode() == Instruction::AShr))
105         continue;
106       Value *AshrOp1 = Ashr->getOperand(1);
107       ConstantInt *C = dyn_cast<ConstantInt>(AshrOp1);
108       // Right shifted by 16.
109       if (!(C && C->getSExtValue() == 16))
110         continue;
111 
112       // The first operand of Ashr comes from logical shift left.
113       Instruction *Shl = dyn_cast<Instruction>(Ashr->getOperand(0));
114       if (!(Shl && Shl->getOpcode() == Instruction::Shl))
115         continue;
116       Value *Intr = Shl->getOperand(0);
117       Value *ShlOp1 = Shl->getOperand(1);
118       C = dyn_cast<ConstantInt>(ShlOp1);
119       // Left shifted by 16.
120       if (!(C && C->getSExtValue() == 16))
121         continue;
122 
123       // The first operand of Shl comes from an intrinsic.
124       if (IntrinsicInst *I = dyn_cast<IntrinsicInst>(Intr)) {
125         if (!intrinsicAlreadySextended(I->getIntrinsicID()))
126           continue;
127         // All is well. Replace all uses of AShr with I.
128         for (auto UI = Ashr->user_begin(), UE = Ashr->user_end();
129              UI != UE; ++UI) {
130           const Use &TheUse = UI.getUse();
131           if (Instruction *J = dyn_cast<Instruction>(TheUse.getUser())) {
132             J->replaceUsesOfWith(Ashr, I);
133           }
134         }
135       }
136     }
137   }
138 
139   return true;
140 }
141 
142 
143 FunctionPass *llvm::createHexagonOptimizeSZextends() {
144   return new HexagonOptimizeSZextends();
145 }
146