Home | History | Annotate | Download | only in Script 
      1 //===- BinaryOp.h ---------------------------------------------------------===//
      2 //
      3 //                     The MCLinker Project
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 #ifndef MCLD_SCRIPT_BINARYOP_H_
     10 #define MCLD_SCRIPT_BINARYOP_H_
     11 
     12 #include "mcld/Script/Operator.h"
     13 
     14 #include <cstddef>
     15 
     16 namespace mcld {
     17 
     18 class Operand;
     19 class IntOperand;
     20 class Module;
     21 class TargetLDBackend;
     22 
     23 /** \class BinaryOP
     24  *  \brief This class defines the interfaces to an binary operator token.
     25  */
     26 
     27 template <Operator::Type TYPE>
     28 class BinaryOp : public Operator {
     29  private:
     30   friend class Operator;
     31 
     32   BinaryOp() : Operator(Operator::BINARY, TYPE), m_Size(0) {
     33     m_pOperand[0] = m_pOperand[1] = NULL;
     34   }
     35 
     36  public:
     37   ~BinaryOp() {}
     38 
     39   IntOperand* eval(const Module& pModule, const TargetLDBackend& pBackend);
     40 
     41   void appendOperand(Operand* pOperand) {
     42     m_pOperand[m_Size++] = pOperand;
     43     if (m_Size == 2)
     44       m_Size = 0;
     45   }
     46 
     47  private:
     48   size_t m_Size;
     49   Operand* m_pOperand[2];
     50 };
     51 
     52 template <>
     53 IntOperand* BinaryOp<Operator::MUL>::eval(const Module&,
     54                                           const TargetLDBackend&);
     55 template <>
     56 IntOperand* BinaryOp<Operator::DIV>::eval(const Module&,
     57                                           const TargetLDBackend&);
     58 template <>
     59 IntOperand* BinaryOp<Operator::MOD>::eval(const Module&,
     60                                           const TargetLDBackend&);
     61 template <>
     62 IntOperand* BinaryOp<Operator::ADD>::eval(const Module&,
     63                                           const TargetLDBackend&);
     64 template <>
     65 IntOperand* BinaryOp<Operator::SUB>::eval(const Module&,
     66                                           const TargetLDBackend&);
     67 template <>
     68 IntOperand* BinaryOp<Operator::LSHIFT>::eval(const Module&,
     69                                              const TargetLDBackend&);
     70 template <>
     71 IntOperand* BinaryOp<Operator::RSHIFT>::eval(const Module&,
     72                                              const TargetLDBackend&);
     73 template <>
     74 IntOperand* BinaryOp<Operator::LT>::eval(const Module&, const TargetLDBackend&);
     75 template <>
     76 IntOperand* BinaryOp<Operator::LE>::eval(const Module&, const TargetLDBackend&);
     77 template <>
     78 IntOperand* BinaryOp<Operator::GT>::eval(const Module&, const TargetLDBackend&);
     79 template <>
     80 IntOperand* BinaryOp<Operator::GE>::eval(const Module&, const TargetLDBackend&);
     81 template <>
     82 IntOperand* BinaryOp<Operator::EQ>::eval(const Module&, const TargetLDBackend&);
     83 template <>
     84 IntOperand* BinaryOp<Operator::NE>::eval(const Module&, const TargetLDBackend&);
     85 template <>
     86 IntOperand* BinaryOp<Operator::BITWISE_AND>::eval(const Module&,
     87                                                   const TargetLDBackend&);
     88 template <>
     89 IntOperand* BinaryOp<Operator::BITWISE_XOR>::eval(const Module&,
     90                                                   const TargetLDBackend&);
     91 template <>
     92 IntOperand* BinaryOp<Operator::BITWISE_OR>::eval(const Module&,
     93                                                  const TargetLDBackend&);
     94 template <>
     95 IntOperand* BinaryOp<Operator::LOGICAL_AND>::eval(const Module&,
     96                                                   const TargetLDBackend&);
     97 template <>
     98 IntOperand* BinaryOp<Operator::LOGICAL_OR>::eval(const Module&,
     99                                                  const TargetLDBackend&);
    100 
    101 template <>
    102 IntOperand* BinaryOp<Operator::ALIGN>::eval(const Module&,
    103                                             const TargetLDBackend&);
    104 template <>
    105 IntOperand* BinaryOp<Operator::DATA_SEGMENT_RELRO_END>::eval(
    106     const Module&,
    107     const TargetLDBackend&);
    108 template <>
    109 IntOperand* BinaryOp<Operator::MAX>::eval(const Module&,
    110                                           const TargetLDBackend&);
    111 template <>
    112 IntOperand* BinaryOp<Operator::MIN>::eval(const Module&,
    113                                           const TargetLDBackend&);
    114 template <>
    115 IntOperand* BinaryOp<Operator::SEGMENT_START>::eval(const Module&,
    116                                                     const TargetLDBackend&);
    117 
    118 }  // namespace mcld
    119 
    120 #endif  // MCLD_SCRIPT_BINARYOP_H_
    121