lib/Target/TargetInstrInfo.cpp

   1 //===-- TargetInstrInfo.cpp - Target Instruction Information --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the TargetInstrInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Target/TargetInstrInfo.h"
  15 #include "llvm/MC/MCAsmInfo.h"
  16 #include "llvm/Target/TargetInstrItineraries.h"
  17 #include "llvm/Target/TargetRegisterInfo.h"
  18 #include "llvm/Support/ErrorHandling.h"
  19 using namespace llvm;
  20
  21 //===----------------------------------------------------------------------===//
  22 //  TargetOperandInfo
  23 //===----------------------------------------------------------------------===//
  24
  25 /// getRegClass - Get the register class for the operand, handling resolution
  26 /// of "symbolic" pointer register classes etc.  If this is not a register
  27 /// operand, this returns null.
  28 const TargetRegisterClass *
  29 TargetOperandInfo::getRegClass(const TargetRegisterInfo *TRI) const {
  30   if (isLookupPtrRegClass())
  31     return TRI->getPointerRegClass(RegClass);
  32   // Instructions like INSERT_SUBREG do not have fixed register classes.
  33   if (RegClass < 0)
  34     return 0;
  35   // Otherwise just look it up normally.
  36   return TRI->getRegClass(RegClass);
  37 }
  38
  39 //===----------------------------------------------------------------------===//
  40 //  TargetInstrInfo
  41 //===----------------------------------------------------------------------===//
  42
  43 TargetInstrInfo::TargetInstrInfo(const TargetInstrDesc* Desc,
  44                                  unsigned numOpcodes)
  45   : Descriptors(Desc), NumOpcodes(numOpcodes) {
  46 }
  47
  48 TargetInstrInfo::~TargetInstrInfo() {
  49 }
  50
  51 unsigned
  52 TargetInstrInfo::getNumMicroOps(const MachineInstr *MI,
  53                                 const InstrItineraryData *ItinData) const {
  54   if (!ItinData || ItinData->isEmpty())
  55     return 1;
  56
  57   unsigned Class = MI->getDesc().getSchedClass();
  58   unsigned UOps = ItinData->Itineraries[Class].NumMicroOps;
  59   if (UOps)
  60     return UOps;
  61
  62   // The # of u-ops is dynamically determined. The specific target should
  63   // override this function to return the right number.
  64   return 1;
  65 }
  66
  67 /// insertNoop - Insert a noop into the instruction stream at the specified
  68 /// point.
  69 void TargetInstrInfo::insertNoop(MachineBasicBlock &MBB,
  70                                  MachineBasicBlock::iterator MI) const {
  71   llvm_unreachable("Target didn't implement insertNoop!");
  72 }
  73
  74
  75 bool TargetInstrInfo::isUnpredicatedTerminator(const MachineInstr *MI) const {
  76   const TargetInstrDesc &TID = MI->getDesc();
  77   if (!TID.isTerminator()) return false;
  78
  79   // Conditional branch is a special case.
  80   if (TID.isBranch() && !TID.isBarrier())
  81     return true;
  82   if (!TID.isPredicable())
  83     return true;
  84   return !isPredicated(MI);
  85 }
  86
  87
  88 /// Measure the specified inline asm to determine an approximation of its
  89 /// length.
  90 /// Comments (which run till the next SeparatorChar or newline) do not
  91 /// count as an instruction.
  92 /// Any other non-whitespace text is considered an instruction, with
  93 /// multiple instructions separated by SeparatorChar or newlines.
  94 /// Variable-length instructions are not handled here; this function
  95 /// may be overloaded in the target code to do that.
  96 unsigned TargetInstrInfo::getInlineAsmLength(const char *Str,
  97                                              const MCAsmInfo &MAI) const {
  98
  99
 100   // Count the number of instructions in the asm.
 101   bool atInsnStart = true;
 102   unsigned Length = 0;
 103   for (; *Str; ++Str) {
 104     if (*Str == '\n' || *Str == MAI.getSeparatorChar())
 105       atInsnStart = true;
 106     if (atInsnStart && !isspace(*Str)) {
 107       Length += MAI.getMaxInstLength();
 108       atInsnStart = false;
 109     }
 110     if (atInsnStart && strncmp(Str, MAI.getCommentString(),
 111                                strlen(MAI.getCommentString())) == 0)
 112       atInsnStart = false;
 113   }
 114
 115   return Length;
 116 }