Sparc.h revision 6788faa06ad77fbfb57db7bcf8bc6a79389775a6 
1//===-- SparcV8.h - Top-level interface for SparcV8 representation -*- C++ -*-//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file was developed by the LLVM research group and is distributed under
6// the University of Illinois Open Source License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file contains the entry points for global functions defined in the LLVM
11// SparcV8 back-end.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef TARGET_SPARCV8_H
16#define TARGET_SPARCV8_H
17
18#include <iosfwd>
19#include <cassert>
20
21namespace llvm {
22
23  class FunctionPass;
24  class TargetMachine;
25
26  FunctionPass *createSparcV8ISelDag(TargetMachine &TM);
27
28  FunctionPass *createSparcV8CodePrinterPass(std::ostream &OS,
29                                             TargetMachine &TM);
30  FunctionPass *createSparcV8DelaySlotFillerPass(TargetMachine &TM);
31  FunctionPass *createSparcV8FPMoverPass(TargetMachine &TM);
32} // end namespace llvm;
33
34// Defines symbolic names for SparcV8 registers.  This defines a mapping from
35// register name to register number.
36//
37#include "SparcV8GenRegisterNames.inc"
38
39// Defines symbolic names for the SparcV8 instructions.
40//
41#include "SparcV8GenInstrNames.inc"
42
43
44namespace llvm {
45  // Enums corresponding to SparcV8 condition codes, both icc's and fcc's.  These
46  // values must be kept in sync with the ones in the .td file.
47  namespace V8CC {
48    enum CondCodes {
49      //ICC_A   =  8   ,  // Always
50      //ICC_N   =  0   ,  // Never
51      ICC_NE  =  9   ,  // Not Equal
52      ICC_E   =  1   ,  // Equal
53      ICC_G   = 10   ,  // Greater
54      ICC_LE  =  2   ,  // Less or Equal
55      ICC_GE  = 11   ,  // Greater or Equal
56      ICC_L   =  3   ,  // Less
57      ICC_GU  = 12   ,  // Greater Unsigned
58      ICC_LEU =  4   ,  // Less or Equal Unsigned
59      ICC_CC  = 13   ,  // Carry Clear/Great or Equal Unsigned
60      ICC_CS  =  5   ,  // Carry Set/Less Unsigned
61      ICC_POS = 14   ,  // Positive
62      ICC_NEG =  6   ,  // Negative
63      ICC_VC  = 15   ,  // Overflow Clear
64      ICC_VS  =  7   ,  // Overflow Set
65
66      //FCC_A   =  8+16,  // Always
67      //FCC_N   =  0+16,  // Never
68      FCC_U   =  7+16,  // Unordered
69      FCC_G   =  6+16,  // Greater
70      FCC_UG  =  5+16,  // Unordered or Greater
71      FCC_L   =  4+16,  // Less
72      FCC_UL  =  3+16,  // Unordered or Less
73      FCC_LG  =  2+16,  // Less or Greater
74      FCC_NE  =  1+16,  // Not Equal
75      FCC_E   =  9+16,  // Equal
76      FCC_UE  = 10+16,  // Unordered or Equal
77      FCC_GE  = 11+16,  // Greater or Equal
78      FCC_UGE = 12+16,  // Unordered or Greater or Equal
79      FCC_LE  = 13+16,  // Less or Equal
80      FCC_ULE = 14+16,  // Unordered or Less or Equal
81      FCC_O   = 15+16,  // Ordered
82    };
83  }
84
85  static unsigned SPARCCondCodeToBranchInstr(V8CC::CondCodes CC) {
86    switch (CC) {
87    default: assert(0 && "Unknown condition code");
88    case V8CC::ICC_NE:  return V8::BNE;
89    case V8CC::ICC_E:   return V8::BE;
90    case V8CC::ICC_G:   return V8::BG;
91    case V8CC::ICC_LE:  return V8::BLE;
92    case V8CC::ICC_GE:  return V8::BGE;
93    case V8CC::ICC_L:   return V8::BL;
94    case V8CC::ICC_GU:  return V8::BGU;
95    case V8CC::ICC_LEU: return V8::BLEU;
96    case V8CC::ICC_CC:  return V8::BCC;
97    case V8CC::ICC_CS:  return V8::BCS;
98    case V8CC::ICC_POS: return V8::BPOS;
99    case V8CC::ICC_NEG: return V8::BNEG;
100    case V8CC::ICC_VC:  return V8::BVC;
101    case V8CC::ICC_VS:  return V8::BVS;
102    case V8CC::FCC_U:   return V8::FBU;
103    case V8CC::FCC_G:   return V8::FBG;
104    case V8CC::FCC_UG:  return V8::FBUG;
105    case V8CC::FCC_L:   return V8::FBL;
106    case V8CC::FCC_UL:  return V8::FBUL;
107    case V8CC::FCC_LG:  return V8::FBLG;
108    case V8CC::FCC_NE:  return V8::FBNE;
109    case V8CC::FCC_E:   return V8::FBE;
110    case V8CC::FCC_UE:  return V8::FBUE;
111    case V8CC::FCC_GE:  return V8::FBGE;
112    case V8CC::FCC_UGE: return V8::FBUGE;
113    case V8CC::FCC_LE:  return V8::FBLE;
114    case V8CC::FCC_ULE: return V8::FBULE;
115    case V8CC::FCC_O:   return V8::FBO;
116    }
117  }
118
119  static const char *SPARCCondCodeToString(V8CC::CondCodes CC) {
120    switch (CC) {
121    default: assert(0 && "Unknown condition code");
122    case V8CC::ICC_NE:  return "ne";
123    case V8CC::ICC_E:   return "e";
124    case V8CC::ICC_G:   return "g";
125    case V8CC::ICC_LE:  return "le";
126    case V8CC::ICC_GE:  return "ge";
127    case V8CC::ICC_L:   return "l";
128    case V8CC::ICC_GU:  return "gu";
129    case V8CC::ICC_LEU: return "leu";
130    case V8CC::ICC_CC:  return "cc";
131    case V8CC::ICC_CS:  return "cs";
132    case V8CC::ICC_POS: return "pos";
133    case V8CC::ICC_NEG: return "neg";
134    case V8CC::ICC_VC:  return "vc";
135    case V8CC::ICC_VS:  return "vs";
136    case V8CC::FCC_U:   return "u";
137    case V8CC::FCC_G:   return "g";
138    case V8CC::FCC_UG:  return "ug";
139    case V8CC::FCC_L:   return "l";
140    case V8CC::FCC_UL:  return "ul";
141    case V8CC::FCC_LG:  return "lg";
142    case V8CC::FCC_NE:  return "ne";
143    case V8CC::FCC_E:   return "e";
144    case V8CC::FCC_UE:  return "ue";
145    case V8CC::FCC_GE:  return "ge";
146    case V8CC::FCC_UGE: return "uge";
147    case V8CC::FCC_LE:  return "le";
148    case V8CC::FCC_ULE: return "ule";
149    case V8CC::FCC_O:   return "o";
150    }
151  }
152}  // end namespace llvm
153#endif
154