lib/Target/CellSPU/SPU.h

   1 //===-- SPU.h - Top-level interface for Cell SPU Target ----------*- 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 the entry points for global functions defined in the LLVM
  11 // Cell SPU back-end.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_TARGET_IBMCELLSPU_H
  16 #define LLVM_TARGET_IBMCELLSPU_H
  17
  18 #include "llvm/Support/DataTypes.h"
  19 #include "llvm/Target/TargetMachine.h"
  20
  21 namespace llvm {
  22   class SPUTargetMachine;
  23   class FunctionPass;
  24   class raw_ostream;
  25
  26   FunctionPass *createSPUISelDag(SPUTargetMachine &TM);
  27   FunctionPass *createSPUAsmPrinterPass(raw_ostream &o,
  28                                         SPUTargetMachine &tm,
  29                                         bool verbose);
  30
  31   /*--== Utility functions/predicates/etc used all over the place: --==*/
  32   //! Predicate test for a signed 10-bit value
  33   /*!
  34     \param Value The input value to be tested
  35
  36     This predicate tests for a signed 10-bit value, returning the 10-bit value
  37     as a short if true.
  38    */
  39   template<typename T>
  40   inline bool isS10Constant(T Value);
  41
  42   template<>
  43   inline bool isS10Constant<short>(short Value) {
  44     int SExtValue = ((int) Value << (32 - 10)) >> (32 - 10);
  45     return ((Value > 0 && Value <= (1 << 9) - 1)
  46             || (Value < 0 && (short) SExtValue == Value));
  47   }
  48
  49   template<>
  50   inline bool isS10Constant<int>(int Value) {
  51     return (Value >= -(1 << 9) && Value <= (1 << 9) - 1);
  52   }
  53
  54   template<>
  55   inline bool isS10Constant<uint32_t>(uint32_t Value) {
  56     return (Value <= ((1 << 9) - 1));
  57   }
  58
  59   template<>
  60   inline bool isS10Constant<int64_t>(int64_t Value) {
  61     return (Value >= -(1 << 9) && Value <= (1 << 9) - 1);
  62   }
  63
  64   template<>
  65   inline bool isS10Constant<uint64_t>(uint64_t Value) {
  66     return (Value <= ((1 << 9) - 1));
  67   }
  68
  69   //! Predicate test for an unsigned 10-bit value
  70   /*!
  71     \param Value The input value to be tested
  72
  73     This predicate tests for an unsigned 10-bit value, returning the 10-bit value
  74     as a short if true.
  75    */
  76   inline bool isU10Constant(short Value) {
  77     return (Value == (Value & 0x3ff));
  78   }
  79
  80   inline bool isU10Constant(int Value) {
  81     return (Value == (Value & 0x3ff));
  82   }
  83
  84   inline bool isU10Constant(uint32_t Value) {
  85     return (Value == (Value & 0x3ff));
  86   }
  87
  88   inline bool isU10Constant(int64_t Value) {
  89     return (Value == (Value & 0x3ff));
  90   }
  91
  92   inline bool isU10Constant(uint64_t Value) {
  93     return (Value == (Value & 0x3ff));
  94   }
  95 }
  96
  97 // Defines symbolic names for the SPU instructions.
  98 //
  99 #include "SPUGenInstrNames.inc"
 100
 101 #endif /* LLVM_TARGET_IBMCELLSPU_H */