Line data    Source code

       1             : //===-- AArch64BaseInfo.cpp - AArch64 Base encoding 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 provides basic encoding and assembly information for AArch64.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : #include "AArch64BaseInfo.h"
      14             : #include "llvm/ADT/ArrayRef.h"
      15             : #include "llvm/ADT/SmallVector.h"
      16             : #include "llvm/ADT/StringExtras.h"
      17             : #include "llvm/Support/Regex.h"
      18             : 
      19             : using namespace llvm;
      20             : 
      21             : namespace llvm {
      22             :   namespace AArch64AT {
      23             : #define GET_AT_IMPL
      24             : #include "AArch64GenSystemOperands.inc"
      25             :   }
      26             : }
      27             : 
      28             : 
      29             : namespace llvm {
      30             :   namespace AArch64DB {
      31             : #define GET_DB_IMPL
      32             : #include "AArch64GenSystemOperands.inc"
      33             :   }
      34             : }
      35             : 
      36             : namespace llvm {
      37             :   namespace AArch64DC {
      38             : #define GET_DC_IMPL
      39             : #include "AArch64GenSystemOperands.inc"
      40             :   }
      41             : }
      42             : 
      43             : namespace llvm {
      44             :   namespace AArch64IC {
      45             : #define GET_IC_IMPL
      46             : #include "AArch64GenSystemOperands.inc"
      47             :   }
      48             : }
      49             : 
      50             : namespace llvm {
      51             :   namespace AArch64ISB {
      52             : #define GET_ISB_IMPL
      53             : #include "AArch64GenSystemOperands.inc"
      54             :   }
      55             : }
      56             : 
      57             : namespace llvm {
      58             :   namespace AArch64TSB {
      59             : #define GET_TSB_IMPL
      60             : #include "AArch64GenSystemOperands.inc"
      61             :   }
      62             : }
      63             : 
      64             : namespace llvm {
      65             :   namespace AArch64PRCTX {
      66             : #define GET_PRCTX_IMPL
      67             : #include "AArch64GenSystemOperands.inc"
      68             :   }
      69             : }
      70             : 
      71             : namespace llvm {
      72             :   namespace AArch64PRFM {
      73             : #define GET_PRFM_IMPL
      74             : #include "AArch64GenSystemOperands.inc"
      75             :   }
      76             : }
      77             : 
      78             : namespace llvm {
      79             :   namespace AArch64SVEPRFM {
      80             : #define GET_SVEPRFM_IMPL
      81             : #include "AArch64GenSystemOperands.inc"
      82             :   }
      83             : }
      84             : 
      85             : namespace llvm {
      86             :   namespace AArch64SVEPredPattern {
      87             : #define GET_SVEPREDPAT_IMPL
      88             : #include "AArch64GenSystemOperands.inc"
      89             :   }
      90             : }
      91             : 
      92             : namespace llvm {
      93             :   namespace AArch64ExactFPImm {
      94             : #define GET_EXACTFPIMM_IMPL
      95             : #include "AArch64GenSystemOperands.inc"
      96             :   }
      97             : }
      98             : 
      99             : namespace llvm {
     100             :   namespace AArch64PState {
     101             : #define GET_PSTATE_IMPL
     102             : #include "AArch64GenSystemOperands.inc"
     103             :   }
     104             : }
     105             : 
     106             : namespace llvm {
     107             :   namespace AArch64PSBHint {
     108             : #define GET_PSB_IMPL
     109             : #include "AArch64GenSystemOperands.inc"
     110             :   }
     111             : }
     112             : 
     113             : namespace llvm {
     114             :   namespace AArch64BTIHint {
     115             : #define GET_BTI_IMPL
     116             : #include "AArch64GenSystemOperands.inc"
     117             :   }
     118             : }
     119             : 
     120             : namespace llvm {
     121             :   namespace AArch64SysReg {
     122             : #define GET_SYSREG_IMPL
     123             : #include "AArch64GenSystemOperands.inc"
     124             :   }
     125             : }
     126             : 
     127         348 : uint32_t AArch64SysReg::parseGenericRegister(StringRef Name) {
     128             :   // Try to parse an S<op0>_<op1>_<Cn>_<Cm>_<op2> register name
     129         696 :   Regex GenericRegPattern("^S([0-3])_([0-7])_C([0-9]|1[0-5])_C([0-9]|1[0-5])_([0-7])$");
     130             : 
     131         348 :   std::string UpperName = Name.upper();
     132             :   SmallVector<StringRef, 5> Ops;
     133         348 :   if (!GenericRegPattern.match(UpperName, &Ops))
     134             :     return -1;
     135             : 
     136          18 :   uint32_t Op0 = 0, Op1 = 0, CRn = 0, CRm = 0, Op2 = 0;
     137             :   uint32_t Bits;
     138          18 :   Ops[1].getAsInteger(10, Op0);
     139          18 :   Ops[2].getAsInteger(10, Op1);
     140          18 :   Ops[3].getAsInteger(10, CRn);
     141          18 :   Ops[4].getAsInteger(10, CRm);
     142          18 :   Ops[5].getAsInteger(10, Op2);
     143          18 :   Bits = (Op0 << 14) | (Op1 << 11) | (CRn << 7) | (CRm << 3) | Op2;
     144             : 
     145          18 :   return Bits;
     146             : }
     147             : 
     148         279 : std::string AArch64SysReg::genericRegisterString(uint32_t Bits) {
     149             :   assert(Bits < 0x10000);
     150         279 :   uint32_t Op0 = (Bits >> 14) & 0x3;
     151         279 :   uint32_t Op1 = (Bits >> 11) & 0x7;
     152         279 :   uint32_t CRn = (Bits >> 7) & 0xf;
     153         279 :   uint32_t CRm = (Bits >> 3) & 0xf;
     154         279 :   uint32_t Op2 = Bits & 0x7;
     155             : 
     156         558 :   return "S" + utostr(Op0) + "_" + utostr(Op1) + "_C" + utostr(CRn) + "_C" +
     157        1116 :          utostr(CRm) + "_" + utostr(Op2);
     158             : }
     159             : 
     160             : namespace llvm {
     161             :   namespace AArch64TLBI {
     162             : #define GET_TLBI_IMPL
     163             : #include "AArch64GenSystemOperands.inc"
     164             :   }
     165             : }