target-riscv.c

   1 #include "lib.h"
   2 #include "symbol.h"
   3 #include "target.h"
   4 #include "machine.h"
   5 #include <string.h>
   6
   7 #define RISCV_32BIT     (1 << 0)
   8 #define RISCV_64BIT     (1 << 1)
   9 #define RISCV_MUL       (1 << 2)
  10 #define RISCV_DIV       (1 << 3)
  11 #define RISCV_ATOMIC    (1 << 4)
  12 #define RISCV_FLOAT     (1 << 5)
  13 #define RISCV_DOUBLE    (1 << 6)
  14 #define RISCV_FDIV      (1 << 7)
  15 #define RISCV_COMP      (1 << 8)
  16 #define RISCV_EMBD      (1 << 9)
  17 #define RISCV_FPU       (RISCV_FLOAT|RISCV_DOUBLE|RISCV_FDIV)
  18 #define RISCV_GENERIC   (RISCV_MUL|RISCV_DIV|RISCV_ATOMIC|RISCV_FPU)
  19
  20 static unsigned int riscv_flags;
  21
  22 static void parse_march_riscv(const char *arg)
  23 {
  24         static struct {
  25                 const char *pattern;
  26                 unsigned int flags;
  27         } basic_sets[] = {
  28                 { "rv32i",      RISCV_32BIT },
  29                 { "rv32e",      RISCV_32BIT|RISCV_EMBD },
  30                 { "rv32g",      RISCV_32BIT|RISCV_GENERIC },
  31                 { "rv64i",      RISCV_64BIT },
  32                 { "rv64g",      RISCV_64BIT|RISCV_GENERIC },
  33         }, extensions[] = {
  34                 { "m",          RISCV_MUL|RISCV_DIV },
  35                 { "a",          RISCV_ATOMIC },
  36                 { "f",          RISCV_FLOAT|RISCV_FDIV },
  37                 { "d",          RISCV_DOUBLE|RISCV_FDIV },
  38                 { "g",          RISCV_GENERIC },
  39                 { "q",          0 },
  40                 { "l",          0 },
  41                 { "c",          RISCV_COMP },
  42                 { "b",          0 },
  43                 { "j",          0 },
  44                 { "t",          0 },
  45                 { "p",          0 },
  46                 { "v",          0 },
  47                 { "n",          0 },
  48                 { "h",          0 },
  49                 { "s",          0 },
  50         };
  51         int i;
  52
  53         for (i = 0; i < ARRAY_SIZE(basic_sets); i++) {
  54                 const char *pat = basic_sets[i].pattern;
  55                 size_t len = strlen(pat);
  56
  57                 if (!strncmp(arg, pat, len)) {
  58                         riscv_flags |= basic_sets[i].flags;
  59                         arg += len;
  60                         goto ext;
  61                 }
  62         }
  63         die("invalid argument to '-march': '%s'\n", arg);
  64
  65 ext:
  66         for (i = 0; i < ARRAY_SIZE(extensions); i++) {
  67                 const char *pat = extensions[i].pattern;
  68                 size_t len = strlen(pat);
  69
  70                 if (!strncmp(arg, pat, len)) {
  71                         riscv_flags |= extensions[i].flags;
  72                         arg += len;
  73                 }
  74         }
  75         if (arg[0])
  76                 die("invalid argument to '-march': '%s'\n", arg);
  77 }
  78
  79 static void init_riscv(const struct target *self)
  80 {
  81         if (arch_cmodel == CMODEL_UNKNOWN)
  82                 arch_cmodel = CMODEL_MEDLOW;
  83         if (fpic)
  84                 arch_cmodel = CMODEL_PIC;
  85
  86         if (riscv_flags == 0)
  87                 riscv_flags = self->flags;
  88 }
  89
  90 static void init_riscv32(const struct target *self)
  91 {
  92         fast16_ctype = &int_ctype;
  93         ufast16_ctype = &uint_ctype;
  94         fast32_ctype = &int_ctype;
  95         ufast32_ctype = &uint_ctype;
  96
  97         init_riscv(self);
  98 }
  99
 100 static void predefine_riscv(const struct target *self)
 101 {
 102         static const char *cmodels[CMODEL_LAST] = {
 103                 [CMODEL_MEDANY] = "medany",
 104                 [CMODEL_MEDLOW] = "medlow",
 105                 [CMODEL_PIC]    = "pic",
 106         };
 107         const char *cmodel = cmodels[arch_cmodel];
 108
 109         predefine("__riscv", 1, "1");
 110         predefine("__riscv_xlen", 1, "%d", ptr_ctype.bit_size);
 111
 112         if (riscv_flags & RISCV_ATOMIC)
 113                 predefine("__riscv_atomic", 1, "1");
 114         if (riscv_flags & RISCV_COMP)
 115                 predefine("__riscv_compressed", 1, "1");
 116         if (riscv_flags & RISCV_DIV)
 117                 predefine("__riscv_div", 1, "1");
 118         if (riscv_flags & RISCV_EMBD)
 119                 predefine("__riscv_32e", 1, "1");
 120         if (riscv_flags & RISCV_FPU)
 121                 predefine("__riscv_flen", 1, "%d", (riscv_flags & RISCV_DOUBLE) ? 64 : 32);
 122         if (riscv_flags & RISCV_FDIV)
 123                 predefine("__riscv_fdiv", 1, "1");
 124         if (riscv_flags & RISCV_FDIV)
 125                 predefine("__riscv_fsqrt", 1, "1");
 126         if (riscv_flags & RISCV_MUL)
 127                 predefine("__riscv_mul", 1, "1");
 128         if ((riscv_flags & RISCV_MUL) && (riscv_flags & RISCV_DIV))
 129                 predefine("__riscv_muldiv", 1, "1");
 130
 131         if (cmodel)
 132                 predefine_strong("__riscv_cmodel_%s", cmodel);
 133 }
 134
 135 const struct target target_riscv32 = {
 136         .mach = MACH_RISCV32,
 137         .bitness = ARCH_LP32,
 138         .big_endian = 0,
 139         .unsigned_char = 1,
 140         .flags = RISCV_32BIT|RISCV_GENERIC|RISCV_COMP,
 141
 142         .target_64bit = &target_riscv64,
 143
 144         .init = init_riscv32,
 145         .predefine = predefine_riscv,
 146         .parse_march = parse_march_riscv,
 147 };
 148
 149 const struct target target_riscv64 = {
 150         .mach = MACH_RISCV64,
 151         .bitness = ARCH_LP64,
 152         .big_endian = 0,
 153         .unsigned_char = 1,
 154         .has_int128 = 1,
 155         .flags = RISCV_64BIT|RISCV_GENERIC|RISCV_COMP,
 156
 157         .target_32bit = &target_riscv32,
 158
 159         .init = init_riscv,
 160         .predefine = predefine_riscv,
 161         .parse_march = parse_march_riscv,
 162 };