target.c

   1 #include <stdio.h>
   2 #include <string.h>
   3
   4 #include "symbol.h"
   5 #include "target.h"
   6 #include "machine.h"
   7
   8 struct symbol *size_t_ctype = &ulong_ctype;
   9 struct symbol *ssize_t_ctype = &long_ctype;
  10 struct symbol *intmax_ctype = &long_ctype;
  11 struct symbol *uintmax_ctype = &ulong_ctype;
  12 struct symbol *int64_ctype = &long_ctype;
  13 struct symbol *uint64_ctype = &ulong_ctype;
  14 struct symbol *int32_ctype = &int_ctype;
  15 struct symbol *uint32_ctype = &uint_ctype;
  16 struct symbol *wchar_ctype = &int_ctype;
  17 struct symbol *wint_ctype = &uint_ctype;
  18
  19 /*
  20  * For "__attribute__((aligned))"
  21  */
  22 int max_alignment = 16;
  23
  24 /*
  25  * Integer data types
  26  */
  27 int bits_in_bool = 1;
  28 int bits_in_char = 8;
  29 int bits_in_short = 16;
  30 int bits_in_int = 32;
  31 int bits_in_long = 64;
  32 int bits_in_longlong = 64;
  33 int bits_in_longlonglong = 128;
  34
  35 int max_int_alignment = 8;
  36
  37 /*
  38  * Floating point data types
  39  */
  40 int bits_in_float = 32;
  41 int bits_in_double = 64;
  42 int bits_in_longdouble = 128;
  43
  44 int max_fp_alignment = 16;
  45
  46 /*
  47  * Pointer data type
  48  */
  49 int bits_in_pointer = 64;
  50 int pointer_alignment = 8;
  51
  52 /*
  53  * Enum data types
  54  */
  55 int bits_in_enum = 32;
  56 int enum_alignment = 4;
  57
  58
  59 static const struct target *targets[] = {
  60         [MACH_ALPHA] =          &target_alpha,
  61         [MACH_ARM] =            &target_arm,
  62         [MACH_ARM64] =          &target_arm64,
  63         [MACH_I386] =           &target_i386,
  64         [MACH_BFIN] =           &target_bfin,
  65         [MACH_X86_64] =         &target_x86_64,
  66         [MACH_MICROBLAZE] =     &target_microblaze,
  67         [MACH_MIPS32] =         &target_mips32,
  68         [MACH_MIPS64] =         &target_mips64,
  69         [MACH_NIOS2] =          &target_nios2,
  70         [MACH_PPC32] =          &target_ppc32,
  71         [MACH_PPC64] =          &target_ppc64,
  72         [MACH_RISCV32] =        &target_riscv32,
  73         [MACH_RISCV64] =        &target_riscv64,
  74         [MACH_S390] =           &target_s390,
  75         [MACH_S390X] =          &target_s390x,
  76         [MACH_SPARC32] =        &target_sparc32,
  77         [MACH_SPARC64] =        &target_sparc64,
  78         [MACH_M68K] =           &target_m68k,
  79         [MACH_UNKNOWN] =        &target_default,
  80 };
  81 const struct target *arch_target = &target_default;
  82
  83 enum machine target_parse(const char *name)
  84 {
  85         static const struct arch {
  86                 const char *name;
  87                 enum machine mach;
  88                 char bits;
  89         } archs[] = {
  90                 { "alpha",      MACH_ALPHA,     64, },
  91                 { "aarch64",    MACH_ARM64,     64, },
  92                 { "arm64",      MACH_ARM64,     64, },
  93                 { "arm",        MACH_ARM,       32, },
  94                 { "i386",       MACH_I386,      32, },
  95                 { "bfin",       MACH_BFIN,      32, },
  96                 { "m68k",       MACH_M68K,      32, },
  97                 { "microblaze", MACH_MICROBLAZE,32, },
  98                 { "mips",       MACH_MIPS32,    0,  },
  99                 { "nios2",      MACH_NIOS2,     32, },
 100                 { "powerpc",    MACH_PPC32,     0,  },
 101                 { "ppc",        MACH_PPC32,     0,  },
 102                 { "riscv",      MACH_RISCV32,   0,  },
 103                 { "s390x",      MACH_S390X,     64, },
 104                 { "s390",       MACH_S390,      32, },
 105                 { "sparc",      MACH_SPARC32,   0,  },
 106                 { "x86_64",     MACH_X86_64,    64, },
 107                 { "x86-64",     MACH_X86_64,    64, },
 108                 { NULL },
 109         };
 110         const struct arch *p;
 111
 112         for (p = &archs[0]; p->name; p++) {
 113                 size_t len = strlen(p->name);
 114                 if (strncmp(p->name, name, len) == 0) {
 115                         enum machine mach = p->mach;
 116                         const char *suf = name + len;
 117                         int bits = p->bits;
 118
 119                         if (bits == 0) {
 120                                 if (!strcmp(suf, "") || !strcmp(suf, "32")) {
 121                                         ;
 122                                 } else if (!strcmp(suf, "64")) {
 123                                         mach += 1;
 124                                 } else {
 125                                         die("invalid architecture: %s", name);
 126                                 }
 127                         } else {
 128                                 if (strcmp(suf, ""))
 129                                         die("invalid architecture: %s", name);
 130                         }
 131
 132                         return mach;
 133                 }
 134         }
 135
 136         return MACH_UNKNOWN;
 137 }
 138
 139
 140 void target_config(enum machine mach)
 141 {
 142         const struct target *target = targets[mach];
 143
 144         arch_target = target;
 145         arch_m64 = target->bitness;
 146         arch_big_endian = target->big_endian;
 147
 148         funsigned_char = target->unsigned_char;
 149 }
 150
 151
 152 void target_init(void)
 153 {
 154         const struct target *target = arch_target;
 155
 156         switch (arch_m64) {
 157         case ARCH_LP32:
 158                 max_int_alignment = 4;
 159                 /* fallthrough */
 160         case ARCH_X32:
 161                 bits_in_long = 32;
 162                 bits_in_pointer = 32;
 163                 pointer_alignment = 4;
 164                 size_t_ctype = &uint_ctype;
 165                 ssize_t_ctype = &int_ctype;
 166                 int64_ctype = &llong_ctype;
 167                 uint64_ctype = &ullong_ctype;
 168                 intmax_ctype = &llong_ctype;
 169                 uintmax_ctype = &ullong_ctype;
 170                 if (target->target_32bit)
 171                         target = target->target_32bit;
 172                 break;
 173
 174         case ARCH_LLP64:
 175                 bits_in_long = 32;
 176                 size_t_ctype = &ullong_ctype;
 177                 ssize_t_ctype = &llong_ctype;
 178                 int64_ctype = &llong_ctype;
 179                 uint64_ctype = &ullong_ctype;
 180                 intmax_ctype = &llong_ctype;
 181                 uintmax_ctype = &ullong_ctype;
 182                 /* fallthrough */
 183         case ARCH_LP64:
 184                 if (target->target_64bit)
 185                         target = target->target_64bit;
 186                 break;
 187         }
 188         arch_target = target;
 189
 190         if (fpie > fpic)
 191                 fpic = fpie;
 192
 193         if (target->wchar)
 194                 wchar_ctype = target->wchar;
 195         if (target->wint)
 196                 wint_ctype = target->wint;
 197         if (target->bits_in_longdouble)
 198                 bits_in_longdouble = target->bits_in_longdouble;
 199         if (target->max_fp_alignment)
 200                 max_fp_alignment = target->max_fp_alignment;
 201
 202         if (target->init)
 203                 target->init(target);
 204
 205         if (arch_msize_long || target->size_t_long) {
 206                 size_t_ctype = &ulong_ctype;
 207                 ssize_t_ctype = &long_ctype;
 208         }
 209         if (fshort_wchar)
 210                 wchar_ctype = &ushort_ctype;
 211 }