LLVM  14.0.0git
WebAssemblySetP2AlignOperands.cpp
Go to the documentation of this file.
1 //=- WebAssemblySetP2AlignOperands.cpp - Set alignments on loads and stores -=//
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 /// \file
10 /// This file sets the p2align operands on load and store instructions.
11 ///
12 //===----------------------------------------------------------------------===//
13 
15 #include "WebAssembly.h"
16 #include "WebAssemblyInstrInfo.h"
20 #include "llvm/CodeGen/Passes.h"
21 #include "llvm/Support/Debug.h"
23 using namespace llvm;
24 
25 #define DEBUG_TYPE "wasm-set-p2align-operands"
26 
27 namespace {
28 class WebAssemblySetP2AlignOperands final : public MachineFunctionPass {
29 public:
30  static char ID; // Pass identification, replacement for typeid
31  WebAssemblySetP2AlignOperands() : MachineFunctionPass(ID) {}
32 
33  StringRef getPassName() const override {
34  return "WebAssembly Set p2align Operands";
35  }
36 
37  void getAnalysisUsage(AnalysisUsage &AU) const override {
38  AU.setPreservesCFG();
42  }
43 
44  bool runOnMachineFunction(MachineFunction &MF) override;
45 };
46 } // end anonymous namespace
47 
49 INITIALIZE_PASS(WebAssemblySetP2AlignOperands, DEBUG_TYPE,
50  "Set the p2align operands for WebAssembly loads and stores",
51  false, false)
52 
54  return new WebAssemblySetP2AlignOperands();
55 }
56 
57 static void rewriteP2Align(MachineInstr &MI, unsigned OperandNo) {
58  assert(MI.getOperand(OperandNo).getImm() == 0 &&
59  "ISel should set p2align operands to 0");
60  assert(MI.hasOneMemOperand() &&
61  "Load and store instructions have exactly one mem operand");
62  assert((*MI.memoperands_begin())->getSize() ==
63  (UINT64_C(1) << WebAssembly::GetDefaultP2Align(MI.getOpcode())) &&
64  "Default p2align value should be natural");
65  assert(MI.getDesc().OpInfo[OperandNo].OperandType ==
67  "Load and store instructions should have a p2align operand");
68  uint64_t P2Align = Log2((*MI.memoperands_begin())->getAlign());
69 
70  // WebAssembly does not currently support supernatural alignment.
71  P2Align = std::min(P2Align,
73 
74  MI.getOperand(OperandNo).setImm(P2Align);
75 }
76 
77 bool WebAssemblySetP2AlignOperands::runOnMachineFunction(MachineFunction &MF) {
78  LLVM_DEBUG({
79  dbgs() << "********** Set p2align Operands **********\n"
80  << "********** Function: " << MF.getName() << '\n';
81  });
82 
83  bool Changed = false;
84 
85  for (auto &MBB : MF) {
86  for (auto &MI : MBB) {
87  int16_t P2AlignOpNum = WebAssembly::getNamedOperandIdx(
88  MI.getOpcode(), WebAssembly::OpName::p2align);
89  if (P2AlignOpNum != -1) {
90  rewriteP2Align(MI, P2AlignOpNum);
91  Changed = true;
92  }
93  }
94  }
95 
96  return Changed;
97 }
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:103
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
WebAssembly.h
llvm::MachineFunctionPass
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Definition: MachineFunctionPass.h:30
llvm::MachineFunctionPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.
Definition: MachineFunctionPass.cpp:102
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::MachineBlockFrequencyInfo
MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...
Definition: MachineBlockFrequencyInfo.h:33
llvm::Log2
unsigned Log2(Align A)
Returns the log2 of the alignment.
Definition: Alignment.h:207
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
WebAssemblyInstrInfo.h
WebAssemblyMCTargetDesc.h
Passes.h
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
uint64_t
llvm::MachineFunction::getName
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
Definition: MachineFunction.cpp:541
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
WebAssemblyMachineFunctionInfo.h
llvm::MachineFunction
Definition: MachineFunction.h:230
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::AnalysisUsage::setPreservesCFG
void setPreservesCFG()
This function should be called by the pass, iff they do not:
Definition: Pass.cpp:253
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::AnalysisUsage::addPreservedID
AnalysisUsage & addPreservedID(const void *ID)
Definition: PassAnalysisSupport.h:88
llvm::AnalysisUsage::addPreserved
AnalysisUsage & addPreserved()
Add the specified Pass class to the set of analyses preserved by this pass.
Definition: PassAnalysisSupport.h:98
INITIALIZE_PASS
INITIALIZE_PASS(WebAssemblySetP2AlignOperands, DEBUG_TYPE, "Set the p2align operands for WebAssembly loads and stores", false, false) FunctionPass *llvm
Definition: WebAssemblySetP2AlignOperands.cpp:49
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
DEBUG_TYPE
#define DEBUG_TYPE
Definition: WebAssemblySetP2AlignOperands.cpp:25
llvm::WebAssembly::OPERAND_P2ALIGN
@ OPERAND_P2ALIGN
p2align immediate for load and store address alignment.
Definition: WebAssemblyMCTargetDesc.h:70
llvm::MachineDominatorsID
char & MachineDominatorsID
MachineDominators - This pass is a machine dominators analysis pass.
llvm::createWebAssemblySetP2AlignOperands
FunctionPass * createWebAssemblySetP2AlignOperands()
MachineMemOperand.h
rewriteP2Align
static void rewriteP2Align(MachineInstr &MI, unsigned OperandNo)
Definition: WebAssemblySetP2AlignOperands.cpp:57
llvm::FunctionPass
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
p2align
to esp esp setne al movzbw ax esp setg cl movzbw cx cmove cx cl jne LBB1_2 esp which is much esp edx eax decl edx jle L7 esp ret p2align
Definition: README.txt:658
raw_ostream.h
llvm::WebAssembly::getNamedOperandIdx
int16_t getNamedOperandIdx(uint16_t Opcode, uint16_t NamedIndex)
llvm::WebAssembly::GetDefaultP2Align
unsigned GetDefaultP2Align(unsigned Opc)
Definition: WebAssemblyMCTargetDesc.h:269
MachineBlockFrequencyInfo.h
Debug.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37