llvm/lib/Support/CSKYAttributeParser.cpp

   1 //===-- CSKYAttributeParser.cpp - CSKY Attribute Parser -----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Support/CSKYAttributeParser.h"
  10 #include "llvm/ADT/StringExtras.h"
  11 #include "llvm/Support/Errc.h"
  12
  13 using namespace llvm;
  14
  15 const CSKYAttributeParser::DisplayHandler
  16     CSKYAttributeParser::displayRoutines[] = {
  17         {
  18             CSKYAttrs::CSKY_ARCH_NAME,
  19             &ELFAttributeParser::stringAttribute,
  20         },
  21         {
  22             CSKYAttrs::CSKY_CPU_NAME,
  23             &ELFAttributeParser::stringAttribute,
  24         },
  25         {
  26             CSKYAttrs::CSKY_ISA_FLAGS,
  27             &ELFAttributeParser::integerAttribute,
  28         },
  29         {
  30             CSKYAttrs::CSKY_ISA_EXT_FLAGS,
  31             &ELFAttributeParser::integerAttribute,
  32         },
  33         {
  34             CSKYAttrs::CSKY_DSP_VERSION,
  35             &CSKYAttributeParser::dspVersion,
  36         },
  37         {
  38             CSKYAttrs::CSKY_VDSP_VERSION,
  39             &CSKYAttributeParser::vdspVersion,
  40         },
  41         {
  42             CSKYAttrs::CSKY_FPU_VERSION,
  43             &CSKYAttributeParser::fpuVersion,
  44         },
  45         {
  46             CSKYAttrs::CSKY_FPU_ABI,
  47             &CSKYAttributeParser::fpuABI,
  48         },
  49         {
  50             CSKYAttrs::CSKY_FPU_ROUNDING,
  51             &CSKYAttributeParser::fpuRounding,
  52         },
  53         {
  54             CSKYAttrs::CSKY_FPU_DENORMAL,
  55             &CSKYAttributeParser::fpuDenormal,
  56         },
  57         {
  58             CSKYAttrs::CSKY_FPU_EXCEPTION,
  59             &CSKYAttributeParser::fpuException,
  60         },
  61         {
  62             CSKYAttrs::CSKY_FPU_NUMBER_MODULE,
  63             &ELFAttributeParser::stringAttribute,
  64         },
  65         {
  66             CSKYAttrs::CSKY_FPU_HARDFP,
  67             &CSKYAttributeParser::fpuHardFP,
  68         }};
  69
  70 Error CSKYAttributeParser::handler(uint64_t tag, bool &handled) {
  71   handled = false;
  72   for (const auto &AH : displayRoutines) {
  73     if (uint64_t(AH.attribute) == tag) {
  74       if (Error e = (this->*AH.routine)(tag))
  75         return e;
  76       handled = true;
  77       break;
  78     }
  79   }
  80
  81   return Error::success();
  82 }
  83
  84 Error CSKYAttributeParser::dspVersion(unsigned tag) {
  85   static const char *const strings[] = {"Error", "DSP Extension", "DSP 2.0"};
  86   return parseStringAttribute("Tag_CSKY_DSP_VERSION", tag, ArrayRef(strings));
  87 }
  88
  89 Error CSKYAttributeParser::vdspVersion(unsigned tag) {
  90   static const char *const strings[] = {"Error", "VDSP Version 1",
  91                                         "VDSP Version 2"};
  92   return parseStringAttribute("Tag_CSKY_VDSP_VERSION", tag, ArrayRef(strings));
  93 }
  94
  95 Error CSKYAttributeParser::fpuVersion(unsigned tag) {
  96   static const char *const strings[] = {"Error", "FPU Version 1",
  97                                         "FPU Version 2", "FPU Version 3"};
  98   return parseStringAttribute("Tag_CSKY_FPU_VERSION", tag, ArrayRef(strings));
  99 }
 100
 101 Error CSKYAttributeParser::fpuABI(unsigned tag) {
 102   static const char *const strings[] = {"Error", "Soft", "SoftFP", "Hard"};
 103   return parseStringAttribute("Tag_CSKY_FPU_ABI", tag, ArrayRef(strings));
 104 }
 105
 106 Error CSKYAttributeParser::fpuRounding(unsigned tag) {
 107   static const char *const strings[] = {"None", "Needed"};
 108   return parseStringAttribute("Tag_CSKY_FPU_ROUNDING", tag, ArrayRef(strings));
 109 }
 110
 111 Error CSKYAttributeParser::fpuDenormal(unsigned tag) {
 112   static const char *const strings[] = {"None", "Needed"};
 113   return parseStringAttribute("Tag_CSKY_FPU_DENORMAL", tag, ArrayRef(strings));
 114 }
 115
 116 Error CSKYAttributeParser::fpuException(unsigned tag) {
 117   static const char *const strings[] = {"None", "Needed"};
 118   return parseStringAttribute("Tag_CSKY_FPU_EXCEPTION", tag, ArrayRef(strings));
 119 }
 120
 121 Error CSKYAttributeParser::fpuHardFP(unsigned tag) {
 122   uint64_t value = de.getULEB128(cursor);
 123   ListSeparator LS(" ");
 124
 125   std::string description;
 126
 127   if (value & 0x1) {
 128     description += LS;
 129     description += "Half";
 130   }
 131   if ((value >> 1) & 0x1) {
 132     description += LS;
 133     description += "Single";
 134   }
 135   if ((value >> 2) & 0x1) {
 136     description += LS;
 137     description += "Double";
 138   }
 139
 140   if (description.empty()) {
 141     printAttribute(tag, value, "");
 142     return createStringError(errc::invalid_argument,
 143                              "unknown Tag_CSKY_FPU_HARDFP value: " +
 144                                  Twine(value));
 145   }
 146
 147   printAttribute(tag, value, description);
 148   return Error::success();
 149 }