zig

fork of https://codeberg.org/ziglang/zig
Log | Files | Refs | README | LICENSE

blob b72f5fc7 (14316B) - Raw

      1 /*
      2  * Copyright (c) 2016 Andrew Kelley
      3  *
      4  * This file is part of zig, which is MIT licensed.
      5  * See http://opensource.org/licenses/MIT
      6  */
      7 
      8 #include "target.hpp"
      9 #include "util.hpp"
     10 #include "error.hpp"
     11 
     12 #include <stdio.h>
     13 
     14 static const ArchType arch_list[] = {
     15     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v8_2a},
     16     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v8_1a},
     17     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v8},
     18     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v8m_baseline},
     19     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v8m_mainline},
     20     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7},
     21     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7em},
     22     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7m},
     23     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7s},
     24     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7k},
     25     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6},
     26     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6m},
     27     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6k},
     28     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6t2},
     29     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v5},
     30     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v5te},
     31     {ZigLLVM_arm, ZigLLVM_ARMSubArch_v4t},
     32 
     33     {ZigLLVM_armeb, ZigLLVM_NoSubArch},
     34     {ZigLLVM_aarch64, ZigLLVM_NoSubArch},
     35     {ZigLLVM_aarch64_be, ZigLLVM_NoSubArch},
     36     {ZigLLVM_avr, ZigLLVM_NoSubArch},
     37     {ZigLLVM_bpfel, ZigLLVM_NoSubArch},
     38     {ZigLLVM_bpfeb, ZigLLVM_NoSubArch},
     39     {ZigLLVM_hexagon, ZigLLVM_NoSubArch},
     40     {ZigLLVM_mips, ZigLLVM_NoSubArch},
     41     {ZigLLVM_mipsel, ZigLLVM_NoSubArch},
     42     {ZigLLVM_mips64, ZigLLVM_NoSubArch},
     43     {ZigLLVM_mips64el, ZigLLVM_NoSubArch},
     44     {ZigLLVM_msp430, ZigLLVM_NoSubArch},
     45     {ZigLLVM_ppc, ZigLLVM_NoSubArch},
     46     {ZigLLVM_ppc64, ZigLLVM_NoSubArch},
     47     {ZigLLVM_ppc64le, ZigLLVM_NoSubArch},
     48     {ZigLLVM_r600, ZigLLVM_NoSubArch},
     49     {ZigLLVM_amdgcn, ZigLLVM_NoSubArch},
     50     {ZigLLVM_sparc, ZigLLVM_NoSubArch},
     51     {ZigLLVM_sparcv9, ZigLLVM_NoSubArch},
     52     {ZigLLVM_sparcel, ZigLLVM_NoSubArch},
     53     {ZigLLVM_systemz, ZigLLVM_NoSubArch},
     54     {ZigLLVM_tce, ZigLLVM_NoSubArch},
     55     {ZigLLVM_thumb, ZigLLVM_NoSubArch},
     56     {ZigLLVM_thumbeb, ZigLLVM_NoSubArch},
     57     {ZigLLVM_x86, ZigLLVM_NoSubArch},
     58     {ZigLLVM_x86_64, ZigLLVM_NoSubArch},
     59     {ZigLLVM_xcore, ZigLLVM_NoSubArch},
     60     {ZigLLVM_nvptx, ZigLLVM_NoSubArch},
     61     {ZigLLVM_nvptx64, ZigLLVM_NoSubArch},
     62     {ZigLLVM_le32, ZigLLVM_NoSubArch},
     63     {ZigLLVM_le64, ZigLLVM_NoSubArch},
     64     {ZigLLVM_amdil, ZigLLVM_NoSubArch},
     65     {ZigLLVM_amdil64, ZigLLVM_NoSubArch},
     66     {ZigLLVM_hsail, ZigLLVM_NoSubArch},
     67     {ZigLLVM_hsail64, ZigLLVM_NoSubArch},
     68     {ZigLLVM_spir, ZigLLVM_NoSubArch},
     69     {ZigLLVM_spir64, ZigLLVM_NoSubArch},
     70 
     71     {ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v3},
     72     {ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v4},
     73     {ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v5},
     74 
     75     {ZigLLVM_shave, ZigLLVM_NoSubArch},
     76     {ZigLLVM_lanai, ZigLLVM_NoSubArch},
     77     {ZigLLVM_wasm32, ZigLLVM_NoSubArch},
     78     {ZigLLVM_wasm64, ZigLLVM_NoSubArch},
     79     {ZigLLVM_renderscript32, ZigLLVM_NoSubArch},
     80     {ZigLLVM_renderscript64, ZigLLVM_NoSubArch},
     81 };
     82 
     83 static const ZigLLVM_VendorType vendor_list[] = {
     84     ZigLLVM_Apple,
     85     ZigLLVM_PC,
     86     ZigLLVM_SCEI,
     87     ZigLLVM_BGP,
     88     ZigLLVM_BGQ,
     89     ZigLLVM_Freescale,
     90     ZigLLVM_IBM,
     91     ZigLLVM_ImaginationTechnologies,
     92     ZigLLVM_MipsTechnologies,
     93     ZigLLVM_NVIDIA,
     94     ZigLLVM_CSR,
     95     ZigLLVM_Myriad,
     96     ZigLLVM_AMD,
     97     ZigLLVM_Mesa,
     98 };
     99 
    100 static const ZigLLVM_OSType os_list[] = {
    101     ZigLLVM_UnknownOS,
    102     ZigLLVM_CloudABI,
    103     ZigLLVM_Darwin,
    104     ZigLLVM_DragonFly,
    105     ZigLLVM_FreeBSD,
    106     ZigLLVM_IOS,
    107     ZigLLVM_KFreeBSD,
    108     ZigLLVM_Linux,
    109     ZigLLVM_Lv2,
    110     ZigLLVM_MacOSX,
    111     ZigLLVM_NetBSD,
    112     ZigLLVM_OpenBSD,
    113     ZigLLVM_Solaris,
    114     ZigLLVM_Win32,
    115     ZigLLVM_Haiku,
    116     ZigLLVM_Minix,
    117     ZigLLVM_RTEMS,
    118     ZigLLVM_NaCl,
    119     ZigLLVM_CNK,
    120     ZigLLVM_Bitrig,
    121     ZigLLVM_AIX,
    122     ZigLLVM_CUDA,
    123     ZigLLVM_NVCL,
    124     ZigLLVM_AMDHSA,
    125     ZigLLVM_PS4,
    126     ZigLLVM_ELFIAMCU,
    127     ZigLLVM_TvOS,
    128     ZigLLVM_WatchOS,
    129     ZigLLVM_Mesa3D,
    130 };
    131 
    132 static const ZigLLVM_EnvironmentType environ_list[] = {
    133     ZigLLVM_GNU,
    134     ZigLLVM_GNUABI64,
    135     ZigLLVM_GNUEABI,
    136     ZigLLVM_GNUEABIHF,
    137     ZigLLVM_GNUX32,
    138     ZigLLVM_CODE16,
    139     ZigLLVM_EABI,
    140     ZigLLVM_EABIHF,
    141     ZigLLVM_Android,
    142     ZigLLVM_Musl,
    143     ZigLLVM_MuslEABI,
    144     ZigLLVM_MuslEABIHF,
    145     ZigLLVM_MSVC,
    146     ZigLLVM_Itanium,
    147     ZigLLVM_Cygnus,
    148     ZigLLVM_AMDOpenCL,
    149     ZigLLVM_CoreCLR,
    150 };
    151 
    152 static const ZigLLVM_ObjectFormatType oformat_list[] = {
    153     ZigLLVM_UnknownObjectFormat,
    154     ZigLLVM_COFF,
    155     ZigLLVM_ELF,
    156     ZigLLVM_MachO,
    157 };
    158 
    159 int target_oformat_count(void) {
    160     return array_length(oformat_list);
    161 }
    162 
    163 const ZigLLVM_ObjectFormatType get_target_oformat(int index) {
    164     return oformat_list[index];
    165 }
    166 
    167 const char *get_target_oformat_name(ZigLLVM_ObjectFormatType oformat) {
    168     switch (oformat) {
    169         case ZigLLVM_UnknownObjectFormat: return "unknown";
    170         case ZigLLVM_COFF: return "coff";
    171         case ZigLLVM_ELF: return "elf";
    172         case ZigLLVM_MachO: return "macho";
    173     }
    174     zig_unreachable();
    175 }
    176 
    177 int target_arch_count(void) {
    178     return array_length(arch_list);
    179 }
    180 
    181 const ArchType *get_target_arch(int index) {
    182     return &arch_list[index];
    183 }
    184 
    185 int target_vendor_count(void) {
    186     return array_length(vendor_list);
    187 }
    188 
    189 ZigLLVM_VendorType get_target_vendor(int index) {
    190     return vendor_list[index];
    191 }
    192 
    193 int target_os_count(void) {
    194     return array_length(os_list);
    195 }
    196 ZigLLVM_OSType get_target_os(int index) {
    197     return os_list[index];
    198 }
    199 
    200 const char *get_target_os_name(ZigLLVM_OSType os_type) {
    201     return (os_type == ZigLLVM_UnknownOS) ? "freestanding" : ZigLLVMGetOSTypeName(os_type);
    202 }
    203 
    204 int target_environ_count(void) {
    205     return array_length(environ_list);
    206 }
    207 ZigLLVM_EnvironmentType get_target_environ(int index) {
    208     return environ_list[index];
    209 }
    210 
    211 void get_native_target(ZigTarget *target) {
    212     ZigLLVMGetNativeTarget(
    213             &target->arch.arch,
    214             &target->arch.sub_arch,
    215             &target->vendor,
    216             &target->os,
    217             &target->env_type,
    218             &target->oformat);
    219 }
    220 
    221 void get_unknown_target(ZigTarget *target) {
    222     target->arch.arch = ZigLLVM_UnknownArch;
    223     target->arch.sub_arch = ZigLLVM_NoSubArch;
    224     target->vendor = ZigLLVM_UnknownVendor;
    225     target->os = ZigLLVM_UnknownOS;
    226     target->env_type = ZigLLVM_UnknownEnvironment;
    227     target->oformat = ZigLLVM_UnknownObjectFormat;
    228 }
    229 
    230 static void get_arch_name_raw(char *out_str, ZigLLVM_ArchType arch, ZigLLVM_SubArchType sub_arch) {
    231     const char *sub_str = (sub_arch == ZigLLVM_NoSubArch) ? "" : ZigLLVMGetSubArchTypeName(sub_arch);
    232     sprintf(out_str, "%s%s", ZigLLVMGetArchTypeName(arch), sub_str);
    233 }
    234 
    235 void get_arch_name(char *out_str, const ArchType *arch) {
    236     return get_arch_name_raw(out_str, arch->arch, arch->sub_arch);
    237 }
    238 
    239 int parse_target_arch(const char *str, ArchType *out_arch) {
    240     for (int i = 0; i < array_length(arch_list); i += 1) {
    241         const ArchType *arch = &arch_list[i];
    242         char arch_name[50];
    243         get_arch_name_raw(arch_name, arch->arch, arch->sub_arch);
    244         if (strcmp(arch_name, str) == 0) {
    245             *out_arch = *arch;
    246             return 0;
    247         }
    248     }
    249     return ErrorFileNotFound;
    250 }
    251 
    252 int parse_target_os(const char *str, ZigLLVM_OSType *out_os) {
    253     for (int i = 0; i < array_length(os_list); i += 1) {
    254         ZigLLVM_OSType os = os_list[i];
    255         const char *os_name = get_target_os_name(os);
    256         if (strcmp(os_name, str) == 0) {
    257             *out_os = os;
    258             return 0;
    259         }
    260     }
    261     return ErrorFileNotFound;
    262 }
    263 
    264 int parse_target_environ(const char *str, ZigLLVM_EnvironmentType *out_environ) {
    265     for (int i = 0; i < array_length(environ_list); i += 1) {
    266         ZigLLVM_EnvironmentType env_type = environ_list[i];
    267         const char *environ_name = ZigLLVMGetEnvironmentTypeName(env_type);
    268         if (strcmp(environ_name, str) == 0) {
    269             *out_environ = env_type;
    270             return 0;
    271         }
    272     }
    273     return ErrorFileNotFound;
    274 }
    275 
    276 void init_all_targets(void) {
    277     LLVMInitializeAllTargets();
    278     LLVMInitializeAllTargetInfos();
    279     LLVMInitializeAllTargetMCs();
    280     LLVMInitializeAllAsmPrinters();
    281     LLVMInitializeAllAsmParsers();
    282 }
    283 
    284 void get_target_triple(Buf *triple, const ZigTarget *target) {
    285     ZigLLVMGetTargetTriple(triple, target->arch.arch, target->arch.sub_arch,
    286             target->vendor, target->os, target->env_type, target->oformat);
    287 }
    288 
    289 static bool is_os_darwin(ZigTarget *target) {
    290     switch (target->os) {
    291         case ZigLLVM_Darwin:
    292         case ZigLLVM_IOS:
    293         case ZigLLVM_MacOSX:
    294             return true;
    295         default:
    296             return false;
    297     }
    298 }
    299 
    300 void resolve_target_object_format(ZigTarget *target) {
    301     if (target->oformat != ZigLLVM_UnknownObjectFormat) {
    302         return;
    303     }
    304 
    305     switch (target->arch.arch) {
    306         case ZigLLVM_UnknownArch:
    307         case ZigLLVM_aarch64:
    308         case ZigLLVM_arm:
    309         case ZigLLVM_thumb:
    310         case ZigLLVM_x86:
    311         case ZigLLVM_x86_64:
    312             if (is_os_darwin(target)) {
    313                 target->oformat = ZigLLVM_MachO;
    314             } else if (target->os == ZigLLVM_Win32) {
    315                 target->oformat = ZigLLVM_COFF;
    316             } else {
    317                 target->oformat = ZigLLVM_ELF;
    318             }
    319             return;
    320 
    321         case ZigLLVM_aarch64_be:
    322         case ZigLLVM_amdgcn:
    323         case ZigLLVM_amdil:
    324         case ZigLLVM_amdil64:
    325         case ZigLLVM_armeb:
    326         case ZigLLVM_avr:
    327         case ZigLLVM_bpfeb:
    328         case ZigLLVM_bpfel:
    329         case ZigLLVM_hexagon:
    330         case ZigLLVM_lanai:
    331         case ZigLLVM_hsail:
    332         case ZigLLVM_hsail64:
    333         case ZigLLVM_kalimba:
    334         case ZigLLVM_le32:
    335         case ZigLLVM_le64:
    336         case ZigLLVM_mips:
    337         case ZigLLVM_mips64:
    338         case ZigLLVM_mips64el:
    339         case ZigLLVM_mipsel:
    340         case ZigLLVM_msp430:
    341         case ZigLLVM_nvptx:
    342         case ZigLLVM_nvptx64:
    343         case ZigLLVM_ppc64le:
    344         case ZigLLVM_r600:
    345         case ZigLLVM_renderscript32:
    346         case ZigLLVM_renderscript64:
    347         case ZigLLVM_shave:
    348         case ZigLLVM_sparc:
    349         case ZigLLVM_sparcel:
    350         case ZigLLVM_sparcv9:
    351         case ZigLLVM_spir:
    352         case ZigLLVM_spir64:
    353         case ZigLLVM_systemz:
    354         case ZigLLVM_tce:
    355         case ZigLLVM_thumbeb:
    356         case ZigLLVM_wasm32:
    357         case ZigLLVM_wasm64:
    358         case ZigLLVM_xcore:
    359             target->oformat= ZigLLVM_ELF;
    360             return;
    361 
    362         case ZigLLVM_ppc:
    363         case ZigLLVM_ppc64:
    364             if (is_os_darwin(target)) {
    365                 target->oformat = ZigLLVM_MachO;
    366             } else {
    367                 target->oformat= ZigLLVM_ELF;
    368             }
    369             return;
    370     }
    371 }
    372 
    373 // See lib/Support/Triple.cpp in LLVM for the source of this data.
    374 static int get_arch_pointer_bit_width(ZigLLVM_ArchType arch) {
    375     switch (arch) {
    376         case ZigLLVM_UnknownArch:
    377             return 0;
    378 
    379         case ZigLLVM_avr:
    380         case ZigLLVM_msp430:
    381             return 16;
    382 
    383         case ZigLLVM_arm:
    384         case ZigLLVM_armeb:
    385         case ZigLLVM_hexagon:
    386         case ZigLLVM_le32:
    387         case ZigLLVM_mips:
    388         case ZigLLVM_mipsel:
    389         case ZigLLVM_nvptx:
    390         case ZigLLVM_ppc:
    391         case ZigLLVM_r600:
    392         case ZigLLVM_sparc:
    393         case ZigLLVM_sparcel:
    394         case ZigLLVM_tce:
    395         case ZigLLVM_thumb:
    396         case ZigLLVM_thumbeb:
    397         case ZigLLVM_x86:
    398         case ZigLLVM_xcore:
    399         case ZigLLVM_amdil:
    400         case ZigLLVM_hsail:
    401         case ZigLLVM_spir:
    402         case ZigLLVM_kalimba:
    403         case ZigLLVM_lanai:
    404         case ZigLLVM_shave:
    405         case ZigLLVM_wasm32:
    406         case ZigLLVM_renderscript32:
    407             return 32;
    408 
    409         case ZigLLVM_aarch64:
    410         case ZigLLVM_aarch64_be:
    411         case ZigLLVM_amdgcn:
    412         case ZigLLVM_bpfel:
    413         case ZigLLVM_bpfeb:
    414         case ZigLLVM_le64:
    415         case ZigLLVM_mips64:
    416         case ZigLLVM_mips64el:
    417         case ZigLLVM_nvptx64:
    418         case ZigLLVM_ppc64:
    419         case ZigLLVM_ppc64le:
    420         case ZigLLVM_sparcv9:
    421         case ZigLLVM_systemz:
    422         case ZigLLVM_x86_64:
    423         case ZigLLVM_amdil64:
    424         case ZigLLVM_hsail64:
    425         case ZigLLVM_spir64:
    426         case ZigLLVM_wasm64:
    427         case ZigLLVM_renderscript64:
    428             return 64;
    429     }
    430     zig_unreachable();
    431 }
    432 
    433 int get_c_type_size_in_bits(const ZigTarget *target, CIntType id) {
    434     switch (target->os) {
    435         case ZigLLVM_UnknownOS:
    436             zig_unreachable();
    437         case ZigLLVM_Linux:
    438         case ZigLLVM_Darwin:
    439             switch (id) {
    440                 case CIntTypeShort:
    441                 case CIntTypeUShort:
    442                     return 16;
    443                 case CIntTypeInt:
    444                 case CIntTypeUInt:
    445                     return 32;
    446                 case CIntTypeLong:
    447                 case CIntTypeULong:
    448                     return get_arch_pointer_bit_width(target->arch.arch);
    449                 case CIntTypeLongLong:
    450                 case CIntTypeULongLong:
    451                     return 64;
    452                 case CIntTypeCount:
    453                     zig_unreachable();
    454             }
    455         case ZigLLVM_Win32:
    456             switch (id) {
    457                 case CIntTypeShort:
    458                 case CIntTypeUShort:
    459                     return 16;
    460                 case CIntTypeInt:
    461                 case CIntTypeUInt:
    462                 case CIntTypeLong:
    463                 case CIntTypeULong:
    464                     return 32;
    465                 case CIntTypeLongLong:
    466                 case CIntTypeULongLong:
    467                     return 64;
    468                 case CIntTypeCount:
    469                     zig_unreachable();
    470             }
    471         case ZigLLVM_CloudABI:
    472         case ZigLLVM_DragonFly:
    473         case ZigLLVM_FreeBSD:
    474         case ZigLLVM_IOS:
    475         case ZigLLVM_KFreeBSD:
    476         case ZigLLVM_Lv2:
    477         case ZigLLVM_MacOSX:
    478         case ZigLLVM_NetBSD:
    479         case ZigLLVM_OpenBSD:
    480         case ZigLLVM_Solaris:
    481         case ZigLLVM_Haiku:
    482         case ZigLLVM_Minix:
    483         case ZigLLVM_RTEMS:
    484         case ZigLLVM_NaCl:
    485         case ZigLLVM_CNK:
    486         case ZigLLVM_Bitrig:
    487         case ZigLLVM_AIX:
    488         case ZigLLVM_CUDA:
    489         case ZigLLVM_NVCL:
    490         case ZigLLVM_AMDHSA:
    491         case ZigLLVM_PS4:
    492         case ZigLLVM_ELFIAMCU:
    493         case ZigLLVM_TvOS:
    494         case ZigLLVM_WatchOS:
    495         case ZigLLVM_Mesa3D:
    496             zig_panic("TODO c type size in bits for this target");
    497     }
    498     zig_unreachable();
    499 }