llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp

   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 }