Home | History | Annotate | Download | only in MCTargetDesc
      1 //===-- PTXBaseInfo.h - Top level definitions for PTX -------- --*- C++ -*-===//
      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 contains small standalone helper functions and enum definitions for
     11 // the PTX target useful for the compiler back-end and the MC libraries.
     12 // As such, it deliberately does not include references to LLVM core
     13 // code gen types, passes, etc..
     14 //
     15 //===----------------------------------------------------------------------===//
     16 
     17 #ifndef PTXBASEINFO_H
     18 #define PTXBASEINFO_H
     19 
     20 #include "PTXMCTargetDesc.h"
     21 #include "llvm/Support/ErrorHandling.h"
     22 #include "llvm/Support/raw_ostream.h"
     23 
     24 namespace llvm {
     25   namespace PTXStateSpace {
     26     enum {
     27       Global    = 0, // default to global state space
     28       Constant  = 1,
     29       Local     = 2,
     30       Parameter = 3,
     31       Shared    = 4
     32     };
     33   } // namespace PTXStateSpace
     34 
     35   namespace PTXPredicate {
     36     enum {
     37       Normal = 0,
     38       Negate = 1,
     39       None   = 2
     40     };
     41   } // namespace PTXPredicate
     42 
     43   /// Namespace to hold all target-specific flags.
     44   namespace PTXRoundingMode {
     45     // Instruction Flags
     46     enum {
     47       // Rounding Mode Flags
     48       RndMask             = 15,
     49       RndDefault          =  0, // ---
     50       RndNone             =  1, // <NONE>
     51       RndNearestEven      =  2, // .rn
     52       RndTowardsZero      =  3, // .rz
     53       RndNegInf           =  4, // .rm
     54       RndPosInf           =  5, // .rp
     55       RndApprox           =  6, // .approx
     56       RndNearestEvenInt   =  7, // .rni
     57       RndTowardsZeroInt   =  8, // .rzi
     58       RndNegInfInt        =  9, // .rmi
     59       RndPosInfInt        = 10  // .rpi
     60     };
     61   } // namespace PTXII
     62 
     63   namespace PTXRegisterType {
     64     // Register type encoded in MCOperands
     65     enum {
     66       Pred  = 0,
     67       B16,
     68       B32,
     69       B64,
     70       F32,
     71       F64
     72     };
     73   } // namespace PTXRegisterType
     74 
     75   namespace PTXRegisterSpace {
     76     // Register space encoded in MCOperands
     77     enum {
     78       Reg = 0,
     79       Local,
     80       Param,
     81       Argument,
     82       Return
     83     };
     84   }
     85 
     86   inline static void decodeRegisterName(raw_ostream &OS,
     87                                         unsigned EncodedReg) {
     88     OS << "%";
     89 
     90     unsigned RegSpace  = EncodedReg & 0x7;
     91     unsigned RegType   = (EncodedReg >> 3) & 0x7;
     92     unsigned RegOffset = EncodedReg >> 6;
     93 
     94     switch (RegSpace) {
     95     default:
     96       llvm_unreachable("Unknown register space!");
     97     case PTXRegisterSpace::Reg:
     98       switch (RegType) {
     99       default:
    100         llvm_unreachable("Unknown register type!");
    101       case PTXRegisterType::Pred:
    102         OS << "p";
    103         break;
    104       case PTXRegisterType::B16:
    105         OS << "rh";
    106         break;
    107       case PTXRegisterType::B32:
    108         OS << "r";
    109         break;
    110       case PTXRegisterType::B64:
    111         OS << "rd";
    112         break;
    113       case PTXRegisterType::F32:
    114         OS << "f";
    115         break;
    116       case PTXRegisterType::F64:
    117         OS << "fd";
    118         break;
    119       }
    120       break;
    121     case PTXRegisterSpace::Return:
    122       OS << "ret";
    123       break;
    124     case PTXRegisterSpace::Argument:
    125       OS << "arg";
    126       break;
    127     }
    128 
    129     OS << RegOffset;
    130   }
    131 } // namespace llvm
    132 
    133 #endif
    134 
    135