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
24using namespace llvm;
25
26namespace llvm {
27  FunctionPass *createHexagonOptimizeSZextends();
28  void initializeHexagonOptimizeSZextendsPass(PassRegistry&);
29}
30
31namespace {
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
51char HexagonOptimizeSZextends::ID = 0;
52
53INITIALIZE_PASS(HexagonOptimizeSZextends, "reargs",
54                "Remove Sign and Zero Extends for Args", false, false)
55
56bool 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
66bool 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
143FunctionPass *llvm::createHexagonOptimizeSZextends() {
144  return new HexagonOptimizeSZextends();
145}
146