LLVM  14.0.0git
LanaiInstrInfo.cpp
Go to the documentation of this file.
1 //===-- LanaiInstrInfo.cpp - Lanai Instruction Information ------*- C++ -*-===//
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 // This file contains the Lanai implementation of the TargetInstrInfo class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "LanaiInstrInfo.h"
14 #include "LanaiAluCode.h"
15 #include "LanaiCondCode.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallVector.h"
24 
25 using namespace llvm;
26 
27 #define GET_INSTRINFO_CTOR_DTOR
28 #include "LanaiGenInstrInfo.inc"
29 
31  : LanaiGenInstrInfo(Lanai::ADJCALLSTACKDOWN, Lanai::ADJCALLSTACKUP),
32  RegisterInfo() {}
33 
36  const DebugLoc &DL,
37  MCRegister DestinationRegister,
38  MCRegister SourceRegister,
39  bool KillSource) const {
40  if (!Lanai::GPRRegClass.contains(DestinationRegister, SourceRegister)) {
41  llvm_unreachable("Impossible reg-to-reg copy");
42  }
43 
44  BuildMI(MBB, Position, DL, get(Lanai::OR_I_LO), DestinationRegister)
45  .addReg(SourceRegister, getKillRegState(KillSource))
46  .addImm(0);
47 }
48 
51  Register SourceRegister, bool IsKill, int FrameIndex,
52  const TargetRegisterClass *RegisterClass,
53  const TargetRegisterInfo * /*RegisterInfo*/) const {
54  DebugLoc DL;
55  if (Position != MBB.end()) {
56  DL = Position->getDebugLoc();
57  }
58 
59  if (!Lanai::GPRRegClass.hasSubClassEq(RegisterClass)) {
60  llvm_unreachable("Can't store this register to stack slot");
61  }
62  BuildMI(MBB, Position, DL, get(Lanai::SW_RI))
63  .addReg(SourceRegister, getKillRegState(IsKill))
65  .addImm(0)
66  .addImm(LPAC::ADD);
67 }
68 
71  Register DestinationRegister, int FrameIndex,
72  const TargetRegisterClass *RegisterClass,
73  const TargetRegisterInfo * /*RegisterInfo*/) const {
74  DebugLoc DL;
75  if (Position != MBB.end()) {
76  DL = Position->getDebugLoc();
77  }
78 
79  if (!Lanai::GPRRegClass.hasSubClassEq(RegisterClass)) {
80  llvm_unreachable("Can't load this register from stack slot");
81  }
82  BuildMI(MBB, Position, DL, get(Lanai::LDW_RI), DestinationRegister)
84  .addImm(0)
85  .addImm(LPAC::ADD);
86 }
87 
89  const MachineInstr &MIa, const MachineInstr &MIb) const {
90  assert(MIa.mayLoadOrStore() && "MIa must be a load or store.");
91  assert(MIb.mayLoadOrStore() && "MIb must be a load or store.");
92 
95  return false;
96 
97  // Retrieve the base register, offset from the base register and width. Width
98  // is the size of memory that is being loaded/stored (e.g. 1, 2, 4). If
99  // base registers are identical, and the offset of a lower memory access +
100  // the width doesn't overlap the offset of a higher memory access,
101  // then the memory accesses are different.
103  const MachineOperand *BaseOpA = nullptr, *BaseOpB = nullptr;
104  int64_t OffsetA = 0, OffsetB = 0;
105  unsigned int WidthA = 0, WidthB = 0;
106  if (getMemOperandWithOffsetWidth(MIa, BaseOpA, OffsetA, WidthA, TRI) &&
107  getMemOperandWithOffsetWidth(MIb, BaseOpB, OffsetB, WidthB, TRI)) {
108  if (BaseOpA->isIdenticalTo(*BaseOpB)) {
109  int LowOffset = std::min(OffsetA, OffsetB);
110  int HighOffset = std::max(OffsetA, OffsetB);
111  int LowWidth = (LowOffset == OffsetA) ? WidthA : WidthB;
112  if (LowOffset + LowWidth <= HighOffset)
113  return true;
114  }
115  }
116  return false;
117 }
118 
120  return false;
121 }
122 
124  switch (CC) {
125  case LPCC::ICC_T: // true
126  return LPCC::ICC_F;
127  case LPCC::ICC_F: // false
128  return LPCC::ICC_T;
129  case LPCC::ICC_HI: // high
130  return LPCC::ICC_LS;
131  case LPCC::ICC_LS: // low or same
132  return LPCC::ICC_HI;
133  case LPCC::ICC_CC: // carry cleared
134  return LPCC::ICC_CS;
135  case LPCC::ICC_CS: // carry set
136  return LPCC::ICC_CC;
137  case LPCC::ICC_NE: // not equal
138  return LPCC::ICC_EQ;
139  case LPCC::ICC_EQ: // equal
140  return LPCC::ICC_NE;
141  case LPCC::ICC_VC: // oVerflow cleared
142  return LPCC::ICC_VS;
143  case LPCC::ICC_VS: // oVerflow set
144  return LPCC::ICC_VC;
145  case LPCC::ICC_PL: // plus (note: 0 is "minus" too here)
146  return LPCC::ICC_MI;
147  case LPCC::ICC_MI: // minus
148  return LPCC::ICC_PL;
149  case LPCC::ICC_GE: // greater than or equal
150  return LPCC::ICC_LT;
151  case LPCC::ICC_LT: // less than
152  return LPCC::ICC_GE;
153  case LPCC::ICC_GT: // greater than
154  return LPCC::ICC_LE;
155  case LPCC::ICC_LE: // less than or equal
156  return LPCC::ICC_GT;
157  default:
158  llvm_unreachable("Invalid condtional code");
159  }
160 }
161 
162 std::pair<unsigned, unsigned>
164  return std::make_pair(TF, 0u);
165 }
166 
169  using namespace LanaiII;
170  static const std::pair<unsigned, const char *> TargetFlags[] = {
171  {MO_ABS_HI, "lanai-hi"},
172  {MO_ABS_LO, "lanai-lo"},
173  {MO_NO_FLAG, "lanai-nf"}};
174  return makeArrayRef(TargetFlags);
175 }
176 
178  Register &SrcReg2, int &CmpMask,
179  int &CmpValue) const {
180  switch (MI.getOpcode()) {
181  default:
182  break;
183  case Lanai::SFSUB_F_RI_LO:
184  case Lanai::SFSUB_F_RI_HI:
185  SrcReg = MI.getOperand(0).getReg();
186  SrcReg2 = Register();
187  CmpMask = ~0;
188  CmpValue = MI.getOperand(1).getImm();
189  return true;
190  case Lanai::SFSUB_F_RR:
191  SrcReg = MI.getOperand(0).getReg();
192  SrcReg2 = MI.getOperand(1).getReg();
193  CmpMask = ~0;
194  CmpValue = 0;
195  return true;
196  }
197 
198  return false;
199 }
200 
201 // isRedundantFlagInstr - check whether the first instruction, whose only
202 // purpose is to update flags, can be made redundant.
203 // * SFSUB_F_RR can be made redundant by SUB_RI if the operands are the same.
204 // * SFSUB_F_RI can be made redundant by SUB_I if the operands are the same.
205 inline static bool isRedundantFlagInstr(MachineInstr *CmpI, unsigned SrcReg,
206  unsigned SrcReg2, int ImmValue,
207  MachineInstr *OI) {
208  if (CmpI->getOpcode() == Lanai::SFSUB_F_RR &&
209  OI->getOpcode() == Lanai::SUB_R &&
210  ((OI->getOperand(1).getReg() == SrcReg &&
211  OI->getOperand(2).getReg() == SrcReg2) ||
212  (OI->getOperand(1).getReg() == SrcReg2 &&
213  OI->getOperand(2).getReg() == SrcReg)))
214  return true;
215 
216  if (((CmpI->getOpcode() == Lanai::SFSUB_F_RI_LO &&
217  OI->getOpcode() == Lanai::SUB_I_LO) ||
218  (CmpI->getOpcode() == Lanai::SFSUB_F_RI_HI &&
219  OI->getOpcode() == Lanai::SUB_I_HI)) &&
220  OI->getOperand(1).getReg() == SrcReg &&
221  OI->getOperand(2).getImm() == ImmValue)
222  return true;
223  return false;
224 }
225 
226 inline static unsigned flagSettingOpcodeVariant(unsigned OldOpcode) {
227  switch (OldOpcode) {
228  case Lanai::ADD_I_HI:
229  return Lanai::ADD_F_I_HI;
230  case Lanai::ADD_I_LO:
231  return Lanai::ADD_F_I_LO;
232  case Lanai::ADD_R:
233  return Lanai::ADD_F_R;
234  case Lanai::ADDC_I_HI:
235  return Lanai::ADDC_F_I_HI;
236  case Lanai::ADDC_I_LO:
237  return Lanai::ADDC_F_I_LO;
238  case Lanai::ADDC_R:
239  return Lanai::ADDC_F_R;
240  case Lanai::AND_I_HI:
241  return Lanai::AND_F_I_HI;
242  case Lanai::AND_I_LO:
243  return Lanai::AND_F_I_LO;
244  case Lanai::AND_R:
245  return Lanai::AND_F_R;
246  case Lanai::OR_I_HI:
247  return Lanai::OR_F_I_HI;
248  case Lanai::OR_I_LO:
249  return Lanai::OR_F_I_LO;
250  case Lanai::OR_R:
251  return Lanai::OR_F_R;
252  case Lanai::SL_I:
253  return Lanai::SL_F_I;
254  case Lanai::SRL_R:
255  return Lanai::SRL_F_R;
256  case Lanai::SA_I:
257  return Lanai::SA_F_I;
258  case Lanai::SRA_R:
259  return Lanai::SRA_F_R;
260  case Lanai::SUB_I_HI:
261  return Lanai::SUB_F_I_HI;
262  case Lanai::SUB_I_LO:
263  return Lanai::SUB_F_I_LO;
264  case Lanai::SUB_R:
265  return Lanai::SUB_F_R;
266  case Lanai::SUBB_I_HI:
267  return Lanai::SUBB_F_I_HI;
268  case Lanai::SUBB_I_LO:
269  return Lanai::SUBB_F_I_LO;
270  case Lanai::SUBB_R:
271  return Lanai::SUBB_F_R;
272  case Lanai::XOR_I_HI:
273  return Lanai::XOR_F_I_HI;
274  case Lanai::XOR_I_LO:
275  return Lanai::XOR_F_I_LO;
276  case Lanai::XOR_R:
277  return Lanai::XOR_F_R;
278  default:
279  return Lanai::NOP;
280  }
281 }
282 
284  MachineInstr &CmpInstr, Register SrcReg, Register SrcReg2, int /*CmpMask*/,
285  int CmpValue, const MachineRegisterInfo *MRI) const {
286  // Get the unique definition of SrcReg.
287  MachineInstr *MI = MRI->getUniqueVRegDef(SrcReg);
288  if (!MI)
289  return false;
290 
291  // Get ready to iterate backward from CmpInstr.
292  MachineBasicBlock::iterator I = CmpInstr, E = MI,
293  B = CmpInstr.getParent()->begin();
294 
295  // Early exit if CmpInstr is at the beginning of the BB.
296  if (I == B)
297  return false;
298 
299  // There are two possible candidates which can be changed to set SR:
300  // One is MI, the other is a SUB instruction.
301  // * For SFSUB_F_RR(r1,r2), we are looking for SUB(r1,r2) or SUB(r2,r1).
302  // * For SFSUB_F_RI(r1, CmpValue), we are looking for SUB(r1, CmpValue).
303  MachineInstr *Sub = nullptr;
304  if (SrcReg2 != 0)
305  // MI is not a candidate to transform into a flag setting instruction.
306  MI = nullptr;
307  else if (MI->getParent() != CmpInstr.getParent() || CmpValue != 0) {
308  // Conservatively refuse to convert an instruction which isn't in the same
309  // BB as the comparison. Don't return if SFSUB_F_RI and CmpValue != 0 as Sub
310  // may still be a candidate.
311  if (CmpInstr.getOpcode() == Lanai::SFSUB_F_RI_LO)
312  MI = nullptr;
313  else
314  return false;
315  }
316 
317  // Check that SR isn't set between the comparison instruction and the
318  // instruction we want to change while searching for Sub.
320  for (--I; I != E; --I) {
321  const MachineInstr &Instr = *I;
322 
323  if (Instr.modifiesRegister(Lanai::SR, TRI) ||
324  Instr.readsRegister(Lanai::SR, TRI))
325  // This instruction modifies or uses SR after the one we want to change.
326  // We can't do this transformation.
327  return false;
328 
329  // Check whether CmpInstr can be made redundant by the current instruction.
330  if (isRedundantFlagInstr(&CmpInstr, SrcReg, SrcReg2, CmpValue, &*I)) {
331  Sub = &*I;
332  break;
333  }
334 
335  // Don't search outside the containing basic block.
336  if (I == B)
337  return false;
338  }
339 
340  // Return false if no candidates exist.
341  if (!MI && !Sub)
342  return false;
343 
344  // The single candidate is called MI.
345  if (!MI)
346  MI = Sub;
347 
348  if (flagSettingOpcodeVariant(MI->getOpcode()) != Lanai::NOP) {
349  bool isSafe = false;
350 
352  OperandsToUpdate;
353  I = CmpInstr;
354  E = CmpInstr.getParent()->end();
355  while (!isSafe && ++I != E) {
356  const MachineInstr &Instr = *I;
357  for (unsigned IO = 0, EO = Instr.getNumOperands(); !isSafe && IO != EO;
358  ++IO) {
359  const MachineOperand &MO = Instr.getOperand(IO);
360  if (MO.isRegMask() && MO.clobbersPhysReg(Lanai::SR)) {
361  isSafe = true;
362  break;
363  }
364  if (!MO.isReg() || MO.getReg() != Lanai::SR)
365  continue;
366  if (MO.isDef()) {
367  isSafe = true;
368  break;
369  }
370  // Condition code is after the operand before SR.
371  LPCC::CondCode CC;
372  CC = (LPCC::CondCode)Instr.getOperand(IO - 1).getImm();
373 
374  if (Sub) {
376  if (NewCC == LPCC::ICC_T)
377  return false;
378  // If we have SUB(r1, r2) and CMP(r2, r1), the condition code based on
379  // CMP needs to be updated to be based on SUB. Push the condition
380  // code operands to OperandsToUpdate. If it is safe to remove
381  // CmpInstr, the condition code of these operands will be modified.
382  if (SrcReg2 != 0 && Sub->getOperand(1).getReg() == SrcReg2 &&
383  Sub->getOperand(2).getReg() == SrcReg) {
384  OperandsToUpdate.push_back(
385  std::make_pair(&((*I).getOperand(IO - 1)), NewCC));
386  }
387  } else {
388  // No Sub, so this is x = <op> y, z; cmp x, 0.
389  switch (CC) {
390  case LPCC::ICC_EQ: // Z
391  case LPCC::ICC_NE: // Z
392  case LPCC::ICC_MI: // N
393  case LPCC::ICC_PL: // N
394  case LPCC::ICC_F: // none
395  case LPCC::ICC_T: // none
396  // SR can be used multiple times, we should continue.
397  break;
398  case LPCC::ICC_CS: // C
399  case LPCC::ICC_CC: // C
400  case LPCC::ICC_VS: // V
401  case LPCC::ICC_VC: // V
402  case LPCC::ICC_HI: // C Z
403  case LPCC::ICC_LS: // C Z
404  case LPCC::ICC_GE: // N V
405  case LPCC::ICC_LT: // N V
406  case LPCC::ICC_GT: // Z N V
407  case LPCC::ICC_LE: // Z N V
408  // The instruction uses the V bit or C bit which is not safe.
409  return false;
410  case LPCC::UNKNOWN:
411  return false;
412  }
413  }
414  }
415  }
416 
417  // If SR is not killed nor re-defined, we should check whether it is
418  // live-out. If it is live-out, do not optimize.
419  if (!isSafe) {
420  MachineBasicBlock *MBB = CmpInstr.getParent();
422  SE = MBB->succ_end();
423  SI != SE; ++SI)
424  if ((*SI)->isLiveIn(Lanai::SR))
425  return false;
426  }
427 
428  // Toggle the optional operand to SR.
429  MI->setDesc(get(flagSettingOpcodeVariant(MI->getOpcode())));
430  MI->addRegisterDefined(Lanai::SR);
431  CmpInstr.eraseFromParent();
432  return true;
433  }
434 
435  return false;
436 }
437 
440  unsigned &TrueOp, unsigned &FalseOp,
441  bool &Optimizable) const {
442  assert(MI.getOpcode() == Lanai::SELECT && "unknown select instruction");
443  // Select operands:
444  // 0: Def.
445  // 1: True use.
446  // 2: False use.
447  // 3: Condition code.
448  TrueOp = 1;
449  FalseOp = 2;
450  Cond.push_back(MI.getOperand(3));
451  Optimizable = true;
452  return false;
453 }
454 
455 // Identify instructions that can be folded into a SELECT instruction, and
456 // return the defining instruction.
458  const MachineRegisterInfo &MRI) {
459  if (!Reg.isVirtual())
460  return nullptr;
461  if (!MRI.hasOneNonDBGUse(Reg))
462  return nullptr;
464  if (!MI)
465  return nullptr;
466  // MI is folded into the SELECT by predicating it.
467  if (!MI->isPredicable())
468  return nullptr;
469  // Check if MI has any non-dead defs or physreg uses. This also detects
470  // predicated instructions which will be reading SR.
471  for (unsigned i = 1, e = MI->getNumOperands(); i != e; ++i) {
472  const MachineOperand &MO = MI->getOperand(i);
473  // Reject frame index operands.
474  if (MO.isFI() || MO.isCPI() || MO.isJTI())
475  return nullptr;
476  if (!MO.isReg())
477  continue;
478  // MI can't have any tied operands, that would conflict with predication.
479  if (MO.isTied())
480  return nullptr;
482  return nullptr;
483  if (MO.isDef() && !MO.isDead())
484  return nullptr;
485  }
486  bool DontMoveAcrossStores = true;
487  if (!MI->isSafeToMove(/*AliasAnalysis=*/nullptr, DontMoveAcrossStores))
488  return nullptr;
489  return MI;
490 }
491 
492 MachineInstr *
495  bool /*PreferFalse*/) const {
496  assert(MI.getOpcode() == Lanai::SELECT && "unknown select instruction");
497  MachineRegisterInfo &MRI = MI.getParent()->getParent()->getRegInfo();
498  MachineInstr *DefMI = canFoldIntoSelect(MI.getOperand(1).getReg(), MRI);
499  bool Invert = !DefMI;
500  if (!DefMI)
501  DefMI = canFoldIntoSelect(MI.getOperand(2).getReg(), MRI);
502  if (!DefMI)
503  return nullptr;
504 
505  // Find new register class to use.
506  MachineOperand FalseReg = MI.getOperand(Invert ? 1 : 2);
507  Register DestReg = MI.getOperand(0).getReg();
508  const TargetRegisterClass *PreviousClass = MRI.getRegClass(FalseReg.getReg());
509  if (!MRI.constrainRegClass(DestReg, PreviousClass))
510  return nullptr;
511 
512  // Create a new predicated version of DefMI.
513  MachineInstrBuilder NewMI =
514  BuildMI(*MI.getParent(), MI, MI.getDebugLoc(), DefMI->getDesc(), DestReg);
515 
516  // Copy all the DefMI operands, excluding its (null) predicate.
517  const MCInstrDesc &DefDesc = DefMI->getDesc();
518  for (unsigned i = 1, e = DefDesc.getNumOperands();
519  i != e && !DefDesc.OpInfo[i].isPredicate(); ++i)
520  NewMI.add(DefMI->getOperand(i));
521 
522  unsigned CondCode = MI.getOperand(3).getImm();
523  if (Invert)
525  else
526  NewMI.addImm(CondCode);
527  NewMI.copyImplicitOps(MI);
528 
529  // The output register value when the predicate is false is an implicit
530  // register operand tied to the first def. The tie makes the register
531  // allocator ensure the FalseReg is allocated the same register as operand 0.
532  FalseReg.setImplicit();
533  NewMI.add(FalseReg);
534  NewMI->tieOperands(0, NewMI->getNumOperands() - 1);
535 
536  // Update SeenMIs set: register newly created MI and erase removed DefMI.
537  SeenMIs.insert(NewMI);
538  SeenMIs.erase(DefMI);
539 
540  // If MI is inside a loop, and DefMI is outside the loop, then kill flags on
541  // DefMI would be invalid when transferred inside the loop. Checking for a
542  // loop is expensive, but at least remove kill flags if they are in different
543  // BBs.
544  if (DefMI->getParent() != MI.getParent())
545  NewMI->clearKillInfo();
546 
547  // The caller will erase MI, but not DefMI.
549  return NewMI;
550 }
551 
552 // The analyzeBranch function is used to examine conditional instructions and
553 // remove unnecessary instructions. This method is used by BranchFolder and
554 // IfConverter machine function passes to improve the CFG.
555 // - TrueBlock is set to the destination if condition evaluates true (it is the
556 // nullptr if the destination is the fall-through branch);
557 // - FalseBlock is set to the destination if condition evaluates to false (it
558 // is the nullptr if the branch is unconditional);
559 // - condition is populated with machine operands needed to generate the branch
560 // to insert in insertBranch;
561 // Returns: false if branch could successfully be analyzed.
563  MachineBasicBlock *&TrueBlock,
564  MachineBasicBlock *&FalseBlock,
566  bool AllowModify) const {
567  // Iterator to current instruction being considered.
569 
570  // Start from the bottom of the block and work up, examining the
571  // terminator instructions.
572  while (Instruction != MBB.begin()) {
573  --Instruction;
574 
575  // Skip over debug instructions.
576  if (Instruction->isDebugInstr())
577  continue;
578 
579  // Working from the bottom, when we see a non-terminator
580  // instruction, we're done.
581  if (!isUnpredicatedTerminator(*Instruction))
582  break;
583 
584  // A terminator that isn't a branch can't easily be handled
585  // by this analysis.
586  if (!Instruction->isBranch())
587  return true;
588 
589  // Handle unconditional branches.
590  if (Instruction->getOpcode() == Lanai::BT) {
591  if (!AllowModify) {
592  TrueBlock = Instruction->getOperand(0).getMBB();
593  continue;
594  }
595 
596  // If the block has any instructions after a branch, delete them.
597  while (std::next(Instruction) != MBB.end()) {
598  std::next(Instruction)->eraseFromParent();
599  }
600 
601  Condition.clear();
602  FalseBlock = nullptr;
603 
604  // Delete the jump if it's equivalent to a fall-through.
605  if (MBB.isLayoutSuccessor(Instruction->getOperand(0).getMBB())) {
606  TrueBlock = nullptr;
608  Instruction = MBB.end();
609  continue;
610  }
611 
612  // TrueBlock is used to indicate the unconditional destination.
613  TrueBlock = Instruction->getOperand(0).getMBB();
614  continue;
615  }
616 
617  // Handle conditional branches
618  unsigned Opcode = Instruction->getOpcode();
619  if (Opcode != Lanai::BRCC)
620  return true; // Unknown opcode.
621 
622  // Multiple conditional branches are not handled here so only proceed if
623  // there are no conditions enqueued.
624  if (Condition.empty()) {
625  LPCC::CondCode BranchCond =
626  static_cast<LPCC::CondCode>(Instruction->getOperand(1).getImm());
627 
628  // TrueBlock is the target of the previously seen unconditional branch.
629  FalseBlock = TrueBlock;
630  TrueBlock = Instruction->getOperand(0).getMBB();
631  Condition.push_back(MachineOperand::CreateImm(BranchCond));
632  continue;
633  }
634 
635  // Multiple conditional branches are not handled.
636  return true;
637  }
638 
639  // Return false indicating branch successfully analyzed.
640  return false;
641 }
642 
643 // reverseBranchCondition - Reverses the branch condition of the specified
644 // condition list, returning false on success and true if it cannot be
645 // reversed.
647  SmallVectorImpl<llvm::MachineOperand> &Condition) const {
648  assert((Condition.size() == 1) &&
649  "Lanai branch conditions should have one component.");
650 
651  LPCC::CondCode BranchCond =
652  static_cast<LPCC::CondCode>(Condition[0].getImm());
653  Condition[0].setImm(getOppositeCondition(BranchCond));
654  return false;
655 }
656 
657 // Insert the branch with condition specified in condition and given targets
658 // (TrueBlock and FalseBlock). This function returns the number of machine
659 // instructions inserted.
661  MachineBasicBlock *TrueBlock,
662  MachineBasicBlock *FalseBlock,
663  ArrayRef<MachineOperand> Condition,
664  const DebugLoc &DL,
665  int *BytesAdded) const {
666  // Shouldn't be a fall through.
667  assert(TrueBlock && "insertBranch must not be told to insert a fallthrough");
668  assert(!BytesAdded && "code size not handled");
669 
670  // If condition is empty then an unconditional branch is being inserted.
671  if (Condition.empty()) {
672  assert(!FalseBlock && "Unconditional branch with multiple successors!");
673  BuildMI(&MBB, DL, get(Lanai::BT)).addMBB(TrueBlock);
674  return 1;
675  }
676 
677  // Else a conditional branch is inserted.
678  assert((Condition.size() == 1) &&
679  "Lanai branch conditions should have one component.");
680  unsigned ConditionalCode = Condition[0].getImm();
681  BuildMI(&MBB, DL, get(Lanai::BRCC)).addMBB(TrueBlock).addImm(ConditionalCode);
682 
683  // If no false block, then false behavior is fall through and no branch needs
684  // to be inserted.
685  if (!FalseBlock)
686  return 1;
687 
688  BuildMI(&MBB, DL, get(Lanai::BT)).addMBB(FalseBlock);
689  return 2;
690 }
691 
693  int *BytesRemoved) const {
694  assert(!BytesRemoved && "code size not handled");
695 
697  unsigned Count = 0;
698 
699  while (Instruction != MBB.begin()) {
700  --Instruction;
701  if (Instruction->isDebugInstr())
702  continue;
703  if (Instruction->getOpcode() != Lanai::BT &&
704  Instruction->getOpcode() != Lanai::BRCC) {
705  break;
706  }
707 
708  // Remove the branch.
710  Instruction = MBB.end();
711  ++Count;
712  }
713 
714  return Count;
715 }
716 
718  int &FrameIndex) const {
719  if (MI.getOpcode() == Lanai::LDW_RI)
720  if (MI.getOperand(1).isFI() && MI.getOperand(2).isImm() &&
721  MI.getOperand(2).getImm() == 0) {
722  FrameIndex = MI.getOperand(1).getIndex();
723  return MI.getOperand(0).getReg();
724  }
725  return 0;
726 }
727 
729  int &FrameIndex) const {
730  if (MI.getOpcode() == Lanai::LDW_RI) {
731  unsigned Reg;
733  return Reg;
734  // Check for post-frame index elimination operations
736  if (hasLoadFromStackSlot(MI, Accesses)){
737  FrameIndex =
738  cast<FixedStackPseudoSourceValue>(Accesses.front()->getPseudoValue())
739  ->getFrameIndex();
740  return 1;
741  }
742  }
743  return 0;
744 }
745 
747  int &FrameIndex) const {
748  if (MI.getOpcode() == Lanai::SW_RI)
749  if (MI.getOperand(0).isFI() && MI.getOperand(1).isImm() &&
750  MI.getOperand(1).getImm() == 0) {
751  FrameIndex = MI.getOperand(0).getIndex();
752  return MI.getOperand(2).getReg();
753  }
754  return 0;
755 }
756 
758  const MachineInstr &LdSt, const MachineOperand *&BaseOp, int64_t &Offset,
759  unsigned &Width, const TargetRegisterInfo * /*TRI*/) const {
760  // Handle only loads/stores with base register followed by immediate offset
761  // and with add as ALU op.
762  if (LdSt.getNumOperands() != 4)
763  return false;
764  if (!LdSt.getOperand(1).isReg() || !LdSt.getOperand(2).isImm() ||
765  !(LdSt.getOperand(3).isImm() && LdSt.getOperand(3).getImm() == LPAC::ADD))
766  return false;
767 
768  switch (LdSt.getOpcode()) {
769  default:
770  return false;
771  case Lanai::LDW_RI:
772  case Lanai::LDW_RR:
773  case Lanai::SW_RR:
774  case Lanai::SW_RI:
775  Width = 4;
776  break;
777  case Lanai::LDHs_RI:
778  case Lanai::LDHz_RI:
779  case Lanai::STH_RI:
780  Width = 2;
781  break;
782  case Lanai::LDBs_RI:
783  case Lanai::LDBz_RI:
784  case Lanai::STB_RI:
785  Width = 1;
786  break;
787  }
788 
789  BaseOp = &LdSt.getOperand(1);
790  Offset = LdSt.getOperand(2).getImm();
791 
792  if (!BaseOp->isReg())
793  return false;
794 
795  return true;
796 }
797 
800  int64_t &Offset, bool &OffsetIsScalable, unsigned &Width,
801  const TargetRegisterInfo *TRI) const {
802  switch (LdSt.getOpcode()) {
803  default:
804  return false;
805  case Lanai::LDW_RI:
806  case Lanai::LDW_RR:
807  case Lanai::SW_RR:
808  case Lanai::SW_RI:
809  case Lanai::LDHs_RI:
810  case Lanai::LDHz_RI:
811  case Lanai::STH_RI:
812  case Lanai::LDBs_RI:
813  case Lanai::LDBz_RI:
814  const MachineOperand *BaseOp;
815  OffsetIsScalable = false;
816  if (!getMemOperandWithOffsetWidth(LdSt, BaseOp, Offset, Width, TRI))
817  return false;
818  BaseOps.push_back(BaseOp);
819  return true;
820  }
821 }
i
i
Definition: README.txt:29
llvm::LanaiInstrInfo::LanaiInstrInfo
LanaiInstrInfo()
Definition: LanaiInstrInfo.cpp:30
llvm::LPAC::ADD
@ ADD
Definition: LanaiAluCode.h:23
LanaiAluCode.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:102
llvm::MachineInstrBuilder::addImm
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
Definition: MachineInstrBuilder.h:131
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::MachineInstrBuilder::copyImplicitOps
const MachineInstrBuilder & copyImplicitOps(const MachineInstr &OtherMI) const
Copy all the implicit operands from OtherMI onto this one.
Definition: MachineInstrBuilder.h:315
Reg
unsigned Reg
Definition: MachineSink.cpp:1566
llvm::SmallPtrSetImpl::erase
bool erase(PtrType Ptr)
erase - If the set contains the specified pointer, remove it and return true, otherwise return false.
Definition: SmallPtrSet.h:378
llvm::LanaiInstrInfo::isLoadFromStackSlotPostFE
unsigned isLoadFromStackSlotPostFE(const MachineInstr &MI, int &FrameIndex) const override
Definition: LanaiInstrInfo.cpp:728
llvm::LanaiInstrInfo::insertBranch
unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TrueBlock, MachineBasicBlock *FalseBlock, ArrayRef< MachineOperand > Condition, const DebugLoc &DL, int *BytesAdded=nullptr) const override
Definition: LanaiInstrInfo.cpp:660
llvm::MachineRegisterInfo
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Definition: MachineRegisterInfo.h:52
llvm::MachineInstr::mayLoadOrStore
bool mayLoadOrStore(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly read or modify memory.
Definition: MachineInstr.h:1028
llvm::MachineInstrBuilder::add
const MachineInstrBuilder & add(const MachineOperand &MO) const
Definition: MachineInstrBuilder.h:224
LanaiGenInstrInfo
llvm::LPCC::ICC_LE
@ ICC_LE
Definition: LanaiCondCode.h:30
canFoldIntoSelect
static MachineInstr * canFoldIntoSelect(Register Reg, const MachineRegisterInfo &MRI)
Definition: LanaiInstrInfo.cpp:457
contains
return AArch64::GPR64RegClass contains(Reg)
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
LanaiBaseInfo.h
ErrorHandling.h
llvm::MachineOperand::isTied
bool isTied() const
Definition: MachineOperand.h:441
llvm::MachineRegisterInfo::getUniqueVRegDef
MachineInstr * getUniqueVRegDef(Register Reg) const
getUniqueVRegDef - Return the unique machine instr that defines the specified virtual register or nul...
Definition: MachineRegisterInfo.cpp:411
llvm::LanaiInstrInfo::storeRegToStackSlot
void storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator Position, Register SourceRegister, bool IsKill, int FrameIndex, const TargetRegisterClass *RegisterClass, const TargetRegisterInfo *RegisterInfo) const override
Definition: LanaiInstrInfo.cpp:49
llvm::LanaiInstrInfo::analyzeSelect
bool analyzeSelect(const MachineInstr &MI, SmallVectorImpl< MachineOperand > &Cond, unsigned &TrueOp, unsigned &FalseOp, bool &Optimizable) const override
Definition: LanaiInstrInfo.cpp:438
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:231
llvm::MachineOperand::isJTI
bool isJTI() const
isJTI - Tests if this is a MO_JumpTableIndex operand.
Definition: MachineOperand.h:337
llvm::MachineInstr::getDesc
const MCInstrDesc & getDesc() const
Returns the target instruction descriptor of this MachineInstr.
Definition: MachineInstr.h:486
llvm::LanaiInstrInfo::areMemAccessesTriviallyDisjoint
bool areMemAccessesTriviallyDisjoint(const MachineInstr &MIa, const MachineInstr &MIb) const override
Definition: LanaiInstrInfo.cpp:88
llvm::LanaiII::MO_ABS_LO
@ MO_ABS_LO
Definition: LanaiBaseInfo.h:36
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
STLExtras.h
llvm::MachineOperand::isFI
bool isFI() const
isFI - Tests if this is a MO_FrameIndex operand.
Definition: MachineOperand.h:331
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
llvm::LanaiInstrInfo::getMemOperandWithOffsetWidth
bool getMemOperandWithOffsetWidth(const MachineInstr &LdSt, const MachineOperand *&BaseOp, int64_t &Offset, unsigned &Width, const TargetRegisterInfo *TRI) const
Definition: LanaiInstrInfo.cpp:757
llvm::ArrayRef::empty
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:160
llvm::MachineInstr::hasOrderedMemoryRef
bool hasOrderedMemoryRef() const
Return true if this instruction may have an ordered or volatile memory reference, or if the informati...
Definition: MachineInstr.cpp:1376
MachineRegisterInfo.h
llvm::LPCC::ICC_EQ
@ ICC_EQ
Definition: LanaiCondCode.h:22
llvm::Instruction::getOpcode
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:160
llvm::LPCC::ICC_CC
@ ICC_CC
Definition: LanaiCondCode.h:17
llvm::MachineInstrBuilder::addMBB
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
Definition: MachineInstrBuilder.h:146
llvm::ISD::SELECT
@ SELECT
Select(COND, TRUEVAL, FALSEVAL).
Definition: ISDOpcodes.h:679
llvm::LanaiInstrInfo::optimizeCompareInstr
bool optimizeCompareInstr(MachineInstr &CmpInstr, Register SrcReg, Register SrcReg2, int CmpMask, int CmpValue, const MachineRegisterInfo *MRI) const override
Definition: LanaiInstrInfo.cpp:283
llvm::MachineOperand::CreateImm
static MachineOperand CreateImm(int64_t Val)
Definition: MachineOperand.h:773
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineOperand::getImm
int64_t getImm() const
Definition: MachineOperand.h:537
llvm::MachineBasicBlock::succ_end
succ_iterator succ_end()
Definition: MachineBasicBlock.h:334
llvm::MachineInstr::getOperand
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:499
llvm::MachineInstr::clearKillInfo
void clearKillInfo()
Clears kill flags on all operands.
Definition: MachineInstr.cpp:1202
llvm::LanaiInstrInfo::loadRegFromStackSlot
void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator Position, Register DestinationRegister, int FrameIndex, const TargetRegisterClass *RegisterClass, const TargetRegisterInfo *RegisterInfo) const override
Definition: LanaiInstrInfo.cpp:69
llvm::LPCC::CondCode
CondCode
Definition: LanaiCondCode.h:10
llvm::LanaiInstrInfo::getRegisterInfo
virtual const LanaiRegisterInfo & getRegisterInfo() const
Definition: LanaiInstrInfo.h:34
llvm::Register::isPhysicalRegister
static bool isPhysicalRegister(unsigned Reg)
Return true if the specified register number is in the physical register namespace.
Definition: Register.h:65
llvm::LPCC::ICC_GE
@ ICC_GE
Definition: LanaiCondCode.h:27
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:46
llvm::LPCC::ICC_LS
@ ICC_LS
Definition: LanaiCondCode.h:15
LanaiCondCode.h
llvm::LPCC::ICC_HI
@ ICC_HI
Definition: LanaiCondCode.h:13
llvm::MCInstrDesc
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:195
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
llvm::Instruction
Definition: Instruction.h:45
llvm::LPCC::ICC_LT
@ ICC_LT
Definition: LanaiCondCode.h:28
isRedundantFlagInstr
static bool isRedundantFlagInstr(MachineInstr *CmpI, unsigned SrcReg, unsigned SrcReg2, int ImmValue, MachineInstr *OI)
Definition: LanaiInstrInfo.cpp:205
llvm::LPCC::ICC_GT
@ ICC_GT
Definition: LanaiCondCode.h:29
llvm::MachineRegisterInfo::getVRegDef
MachineInstr * getVRegDef(Register Reg) const
getVRegDef - Return the machine instr that defines the specified virtual register or null if none is ...
Definition: MachineRegisterInfo.cpp:400
llvm::MachineBasicBlock
Definition: MachineBasicBlock.h:95
llvm::MachineRegisterInfo::getRegClass
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
Definition: MachineRegisterInfo.h:634
llvm::MCOperandInfo::isPredicate
bool isPredicate() const
Set if this is one of the operands that made up of the predicate operand that controls an isPredicabl...
Definition: MCInstrDesc.h:108
llvm::MachineBasicBlock::succ_iterator
std::vector< MachineBasicBlock * >::iterator succ_iterator
Definition: MachineBasicBlock.h:306
llvm::MachineInstrBuilder::addFrameIndex
const MachineInstrBuilder & addFrameIndex(int Idx) const
Definition: MachineInstrBuilder.h:152
llvm::MachineOperand::clobbersPhysReg
static bool clobbersPhysReg(const uint32_t *RegMask, MCRegister PhysReg)
clobbersPhysReg - Returns true if this RegMask clobbers PhysReg.
Definition: MachineOperand.h:617
llvm::Instruction::eraseFromParent
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:78
llvm::LPCC::ICC_MI
@ ICC_MI
Definition: LanaiCondCode.h:26
llvm::MachineOperand::isReg
bool isReg() const
isReg - Tests if this is a MO_Register operand.
Definition: MachineOperand.h:321
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::MachineInstrBuilder
Definition: MachineInstrBuilder.h:69
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::MachineOperand::isDead
bool isDead() const
Definition: MachineOperand.h:385
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::MachineOperand::isCPI
bool isCPI() const
isCPI - Tests if this is a MO_ConstantPoolIndex operand.
Definition: MachineOperand.h:333
llvm::AArch64II::MO_NO_FLAG
@ MO_NO_FLAG
Definition: AArch64BaseInfo.h:616
MachineFunctionPass.h
llvm::LanaiInstrInfo::isStoreToStackSlot
unsigned isStoreToStackSlot(const MachineInstr &MI, int &FrameIndex) const override
Definition: LanaiInstrInfo.cpp:746
llvm::LanaiInstrInfo::analyzeCompare
bool analyzeCompare(const MachineInstr &MI, Register &SrcReg, Register &SrcReg2, int &CmpMask, int &CmpValue) const override
Definition: LanaiInstrInfo.cpp:177
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::LPCC::ICC_PL
@ ICC_PL
Definition: LanaiCondCode.h:25
llvm::MachineBasicBlock::succ_begin
succ_iterator succ_begin()
Definition: MachineBasicBlock.h:332
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::ISD::CondCode
CondCode
ISD::CondCode enum - These are ordered carefully to make the bitfields below work out,...
Definition: ISDOpcodes.h:1355
llvm::MCInstrDesc::OpInfo
const MCOperandInfo * OpInfo
Definition: MCInstrDesc.h:206
llvm::LPCC::ICC_F
@ ICC_F
Definition: LanaiCondCode.h:12
llvm::MachineOperand::isRegMask
bool isRegMask() const
isRegMask - Tests if this is a MO_RegisterMask operand.
Definition: MachineOperand.h:345
llvm::MachineInstrBuilder::addReg
const MachineInstrBuilder & addReg(Register RegNo, unsigned flags=0, unsigned SubReg=0) const
Add a new virtual register operand.
Definition: MachineInstrBuilder.h:97
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:360
llvm::MachineInstr::readsRegister
bool readsRegister(Register Reg, const TargetRegisterInfo *TRI=nullptr) const
Return true if the MachineInstr reads the specified register.
Definition: MachineInstr.h:1368
getOppositeCondition
static LPCC::CondCode getOppositeCondition(LPCC::CondCode CC)
Definition: LanaiInstrInfo.cpp:123
llvm::LPCC::ICC_VS
@ ICC_VS
Definition: LanaiCondCode.h:24
llvm::LPCC::ICC_NE
@ ICC_NE
Definition: LanaiCondCode.h:21
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::LanaiInstrInfo::analyzeBranch
bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TrueBlock, MachineBasicBlock *&FalseBlock, SmallVectorImpl< MachineOperand > &Condition, bool AllowModify) const override
Definition: LanaiInstrInfo.cpp:562
llvm::LanaiInstrInfo::copyPhysReg
void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator Position, const DebugLoc &DL, MCRegister DestinationRegister, MCRegister SourceRegister, bool KillSource) const override
Definition: LanaiInstrInfo.cpp:34
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
Cond
SmallVector< MachineOperand, 4 > Cond
Definition: BasicBlockSections.cpp:179
llvm::MachineInstr::getOpcode
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:489
llvm::MachineRegisterInfo::hasOneNonDBGUse
bool hasOneNonDBGUse(Register RegNo) const
hasOneNonDBGUse - Return true if there is exactly one non-Debug use of the specified register.
Definition: MachineRegisterInfo.cpp:419
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::LanaiInstrInfo::getMemOperandsWithOffsetWidth
bool getMemOperandsWithOffsetWidth(const MachineInstr &LdSt, SmallVectorImpl< const MachineOperand * > &BaseOps, int64_t &Offset, bool &OffsetIsScalable, unsigned &Width, const TargetRegisterInfo *TRI) const override
Definition: LanaiInstrInfo.cpp:798
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::MachineOperand::isDef
bool isDef() const
Definition: MachineOperand.h:375
llvm::MachineInstr::getParent
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:286
llvm::LPCC::UNKNOWN
@ UNKNOWN
Definition: LanaiCondCode.h:31
MRI
unsigned const MachineRegisterInfo * MRI
Definition: AArch64AdvSIMDScalarPass.cpp:105
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::LanaiInstrInfo::removeBranch
unsigned removeBranch(MachineBasicBlock &MBB, int *BytesRemoved=nullptr) const override
Definition: LanaiInstrInfo.cpp:692
llvm::ISD::FrameIndex
@ FrameIndex
Definition: ISDOpcodes.h:80
llvm::MachineInstr::modifiesRegister
bool modifiesRegister(Register Reg, const TargetRegisterInfo *TRI=nullptr) const
Return true if the MachineInstr modifies (fully define or partially define) the specified register.
Definition: MachineInstr.h:1406
MBB
MachineBasicBlock & MBB
Definition: AArch64SLSHardening.cpp:74
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
llvm::MachineInstr::hasUnmodeledSideEffects
bool hasUnmodeledSideEffects() const
Return true if this instruction has side effects that are not modeled by mayLoad / mayStore,...
Definition: MachineInstr.cpp:1457
llvm::LanaiInstrInfo::optimizeSelect
MachineInstr * optimizeSelect(MachineInstr &MI, SmallPtrSetImpl< MachineInstr * > &SeenMIs, bool PreferFalse) const override
Definition: LanaiInstrInfo.cpp:493
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:585
llvm::MachineBasicBlock::isLayoutSuccessor
bool isLayoutSuccessor(const MachineBasicBlock *MBB) const
Return true if the specified MBB will be emitted immediately after this block, such that if this bloc...
Definition: MachineBasicBlock.cpp:912
llvm::MachineOperand::setImplicit
void setImplicit(bool Val=true)
Definition: MachineOperand.h:495
llvm::MachineOperand::isImm
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
Definition: MachineOperand.h:323
llvm::AMDGPU::Hwreg::Width
Width
Definition: SIDefines.h:403
llvm::LanaiInstrInfo::expandPostRAPseudo
bool expandPostRAPseudo(MachineInstr &MI) const override
Definition: LanaiInstrInfo.cpp:119
llvm::makeArrayRef
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:476
llvm::getKillRegState
unsigned getKillRegState(bool B)
Definition: MachineInstrBuilder.h:508
llvm::LPCC::ICC_CS
@ ICC_CS
Definition: LanaiCondCode.h:19
SmallVector.h
llvm::MachineBasicBlock::begin
iterator begin()
Definition: MachineBasicBlock.h:268
MachineInstrBuilder.h
flagSettingOpcodeVariant
static unsigned flagSettingOpcodeVariant(unsigned OldOpcode)
Definition: LanaiInstrInfo.cpp:226
BT
BitTracker BT
Definition: BitTracker.cpp:73
llvm::BuildMI
MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
Definition: MachineInstrBuilder.h:328
DefMI
MachineInstrBuilder MachineInstrBuilder & DefMI
Definition: AArch64ExpandPseudoInsts.cpp:103
llvm::MachineInstr::getNumOperands
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:492
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::MachineRegisterInfo::constrainRegClass
const TargetRegisterClass * constrainRegClass(Register Reg, const TargetRegisterClass *RC, unsigned MinNumRegs=0)
constrainRegClass - Constrain the register class of the specified virtual register to be a common sub...
Definition: MachineRegisterInfo.cpp:85
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:343
llvm::LanaiInstrInfo::isLoadFromStackSlot
unsigned isLoadFromStackSlot(const MachineInstr &MI, int &FrameIndex) const override
Definition: LanaiInstrInfo.cpp:717
llvm::LanaiInstrInfo::getSerializableDirectMachineOperandTargetFlags
ArrayRef< std::pair< unsigned, const char * > > getSerializableDirectMachineOperandTargetFlags() const override
Definition: LanaiInstrInfo.cpp:168
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
LanaiInstrInfo.h
llvm::LPCC::ICC_T
@ ICC_T
Definition: LanaiCondCode.h:11
llvm::LPCC::ICC_VC
@ ICC_VC
Definition: LanaiCondCode.h:23
llvm::MachineInstr::tieOperands
void tieOperands(unsigned DefIdx, unsigned UseIdx)
Add a tie between the register operands at DefIdx and UseIdx.
Definition: MachineInstr.cpp:1099
llvm::MachineInstr::eraseFromParent
void eraseFromParent()
Unlink 'this' from the containing basic block and delete it.
Definition: MachineInstr.cpp:677
llvm::MachineInstrBundleIterator< MachineInstr >
TargetRegistry.h
llvm::MCInstrDesc::getNumOperands
unsigned getNumOperands() const
Return the number of declared MachineOperands for this MachineInstruction.
Definition: MCInstrDesc.h:228
llvm::MachineBasicBlock::end
iterator end()
Definition: MachineBasicBlock.h:270
llvm::LanaiInstrInfo::decomposeMachineOperandsTargetFlags
std::pair< unsigned, unsigned > decomposeMachineOperandsTargetFlags(unsigned TF) const override
Definition: LanaiInstrInfo.cpp:163
llvm::LanaiII::MO_ABS_HI
@ MO_ABS_HI
Definition: LanaiBaseInfo.h:35
llvm::LanaiInstrInfo::reverseBranchCondition
bool reverseBranchCondition(SmallVectorImpl< MachineOperand > &Condition) const override
Definition: LanaiInstrInfo.cpp:646
llvm::MachineOperand::isIdenticalTo
bool isIdenticalTo(const MachineOperand &Other) const
Returns true if this operand is identical to the specified operand except for liveness related flags ...
Definition: MachineOperand.cpp:282
llvm::MCRegister
Wrapper class representing physical registers. Should be passed by value.
Definition: MCRegister.h:23
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:364