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 (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 }