Ekdohibs/zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleanup target data organization

Browse Source
This commit is contained in:
Andrew Kelley 2016-02-10 16:58:15 -07:00
parent b642604691
commit 54a8b6a110
5 changed files with 172 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/main.cpp
View File

@ -54,34 +54,29 @@ static int print_target_list(FILE *f) {
fprintf(f, "Architectures:\n"); fprintf(f, "Architectures:\n");
int arch_count = target_arch_count(); int arch_count = target_arch_count();
int sub_arch_count = target_sub_arch_count();
for (int arch_i = 0; arch_i < arch_count; arch_i += 1) { for (int arch_i = 0; arch_i < arch_count; arch_i += 1) {
const ArchType *arch = get_target_arch(arch_i); const ArchType *arch = get_target_arch(arch_i);
const char *native_str = (native_arch_type == arch->llvm_arch) ? " (native)" : ""; const char *sub_arch_str = (arch->sub_arch == ZigLLVM_NoSubArch) ?
fprintf(f, " %s%s\n", ZigLLVMGetArchTypeName(arch->llvm_arch), native_str); "" : ZigLLVMGetSubArchTypeName(arch->sub_arch);
for (int sub_arch_i = 0; sub_arch_i < sub_arch_count; sub_arch_i += 1) { const char *native_str = (native_arch_type == arch->arch && native_sub_arch_type == arch->sub_arch) ?
const SubArchType *sub_arch = get_target_sub_arch(sub_arch_i); " (native)" : "";
if (sub_arch->arch == arch->llvm_arch) { fprintf(f, " %s%s%s\n", ZigLLVMGetArchTypeName(arch->arch), sub_arch_str, native_str);
const char *native_str = (native_sub_arch_type == sub_arch->sub_arch) ? " (native)" : "";
fprintf(f, " %s%s\n", sub_arch->name, native_str);
}
}
} }
fprintf(f, "\nOperating Systems:\n"); fprintf(f, "\nOperating Systems:\n");
int os_count = target_os_count(); int os_count = target_os_count();
for (int i = 0; i < os_count; i += 1) { for (int i = 0; i < os_count; i += 1) {
const OsType *os_type = get_target_os(i); ZigLLVM_OSType os_type = get_target_os(i);
const char *native_str = (native_os_type == os_type->llvm_os) ? " (native)" : ""; const char *native_str = (native_os_type == os_type) ? " (native)" : "";
fprintf(f, " %s%s\n", get_target_os_name(os_type), native_str); fprintf(f, " %s%s\n", get_target_os_name(os_type), native_str);
} }
fprintf(f, "\nABIs:\n"); fprintf(f, "\nABIs:\n");
int environ_count = target_environ_count(); int environ_count = target_environ_count();
for (int i = 0; i < environ_count; i += 1) { for (int i = 0; i < environ_count; i += 1) {
const EnvironmentType *environ_type = get_target_environ(i); ZigLLVM_EnvironmentType environ_type = get_target_environ(i);
const char *native_str = (native_environ_type == environ_type->llvm_environment) ? " (native)" : ""; const char *native_str = (native_environ_type == environ_type) ? " (native)" : "";
fprintf(f, " %s%s\n", ZigLLVMGetEnvironmentTypeName(environ_type->llvm_environment), native_str); fprintf(f, " %s%s\n", ZigLLVMGetEnvironmentTypeName(environ_type), native_str);
} }
return EXIT_SUCCESS; return EXIT_SUCCESS;

243
src/target.cpp
View File

@ -9,123 +9,120 @@
#include "util.hpp" #include "util.hpp"
static const ArchType arch_list[] = { static const ArchType arch_list[] = {
{ZigLLVM_arm}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v8_1a},
{ZigLLVM_armeb}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v8},
{ZigLLVM_aarch64}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7},
{ZigLLVM_aarch64_be}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7em},
{ZigLLVM_bpfel}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7m},
{ZigLLVM_bpfeb}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v7s},
{ZigLLVM_hexagon}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6},
{ZigLLVM_mips}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6m},
{ZigLLVM_mipsel}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6k},
{ZigLLVM_mips64}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v6t2},
{ZigLLVM_mips64el}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v5},
{ZigLLVM_msp430}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v5te},
{ZigLLVM_ppc}, {ZigLLVM_arm, ZigLLVM_ARMSubArch_v4t},
{ZigLLVM_ppc64},
{ZigLLVM_ppc64le}, {ZigLLVM_armeb, ZigLLVM_NoSubArch},
{ZigLLVM_r600}, {ZigLLVM_aarch64, ZigLLVM_NoSubArch},
{ZigLLVM_amdgcn}, {ZigLLVM_aarch64_be, ZigLLVM_NoSubArch},
{ZigLLVM_sparc}, {ZigLLVM_bpfel, ZigLLVM_NoSubArch},
{ZigLLVM_sparcv9}, {ZigLLVM_bpfeb, ZigLLVM_NoSubArch},
{ZigLLVM_sparcel}, {ZigLLVM_hexagon, ZigLLVM_NoSubArch},
{ZigLLVM_systemz}, {ZigLLVM_mips, ZigLLVM_NoSubArch},
{ZigLLVM_tce}, {ZigLLVM_mipsel, ZigLLVM_NoSubArch},
{ZigLLVM_thumb}, {ZigLLVM_mips64, ZigLLVM_NoSubArch},
{ZigLLVM_thumbeb}, {ZigLLVM_mips64el, ZigLLVM_NoSubArch},
{ZigLLVM_x86}, {ZigLLVM_msp430, ZigLLVM_NoSubArch},
{ZigLLVM_x86_64}, {ZigLLVM_ppc, ZigLLVM_NoSubArch},
{ZigLLVM_xcore}, {ZigLLVM_ppc64, ZigLLVM_NoSubArch},
{ZigLLVM_nvptx}, {ZigLLVM_ppc64le, ZigLLVM_NoSubArch},
{ZigLLVM_nvptx64}, {ZigLLVM_r600, ZigLLVM_NoSubArch},
{ZigLLVM_le32}, {ZigLLVM_amdgcn, ZigLLVM_NoSubArch},
{ZigLLVM_le64}, {ZigLLVM_sparc, ZigLLVM_NoSubArch},
{ZigLLVM_amdil}, {ZigLLVM_sparcv9, ZigLLVM_NoSubArch},
{ZigLLVM_amdil64}, {ZigLLVM_sparcel, ZigLLVM_NoSubArch},
{ZigLLVM_hsail}, {ZigLLVM_systemz, ZigLLVM_NoSubArch},
{ZigLLVM_hsail64}, {ZigLLVM_tce, ZigLLVM_NoSubArch},
{ZigLLVM_spir}, {ZigLLVM_thumb, ZigLLVM_NoSubArch},
{ZigLLVM_spir64}, {ZigLLVM_thumbeb, ZigLLVM_NoSubArch},
{ZigLLVM_kalimba}, {ZigLLVM_x86, ZigLLVM_NoSubArch},
{ZigLLVM_shave}, {ZigLLVM_x86_64, ZigLLVM_NoSubArch},
{ZigLLVM_wasm32}, {ZigLLVM_xcore, ZigLLVM_NoSubArch},
{ZigLLVM_wasm64}, {ZigLLVM_nvptx, ZigLLVM_NoSubArch},
{ZigLLVM_nvptx64, ZigLLVM_NoSubArch},
{ZigLLVM_le32, ZigLLVM_NoSubArch},
{ZigLLVM_le64, ZigLLVM_NoSubArch},
{ZigLLVM_amdil, ZigLLVM_NoSubArch},
{ZigLLVM_amdil64, ZigLLVM_NoSubArch},
{ZigLLVM_hsail, ZigLLVM_NoSubArch},
{ZigLLVM_hsail64, ZigLLVM_NoSubArch},
{ZigLLVM_spir, ZigLLVM_NoSubArch},
{ZigLLVM_spir64, ZigLLVM_NoSubArch},
{ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v3},
{ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v4},
{ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v5},
{ZigLLVM_shave, ZigLLVM_NoSubArch},
{ZigLLVM_wasm32, ZigLLVM_NoSubArch},
{ZigLLVM_wasm64, ZigLLVM_NoSubArch},
}; };
static const SubArchType sub_arch_list[] = { static const ZigLLVM_VendorType vendor_list[] = {
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v8_1a, "v8_1a"}, ZigLLVM_Apple,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v8, "v8"}, ZigLLVM_PC,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v7, "v7"}, ZigLLVM_SCEI,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v7em, "v7em"}, ZigLLVM_BGP,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v7m, "v7m"}, ZigLLVM_BGQ,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v7s, "v7s"}, ZigLLVM_Freescale,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v6, "v6"}, ZigLLVM_IBM,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v6m, "v6m"}, ZigLLVM_ImaginationTechnologies,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v6k, "v6k"}, ZigLLVM_MipsTechnologies,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v6t2, "v6t2"}, ZigLLVM_NVIDIA,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v5, "v5"}, ZigLLVM_CSR,
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v5te, "v5te"},
{ZigLLVM_arm, ZigLLVM_ARMSubArch_v4t, "v4t"},
{ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v3, "v3"},
{ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v4, "v4"},
{ZigLLVM_kalimba, ZigLLVM_KalimbaSubArch_v5, "v5"},
}; };
static const VendorType vendor_list[] = { static const ZigLLVM_OSType os_list[] = {
{ZigLLVM_Apple}, ZigLLVM_UnknownOS,
{ZigLLVM_PC}, ZigLLVM_CloudABI,
{ZigLLVM_SCEI}, ZigLLVM_Darwin,
{ZigLLVM_BGP}, ZigLLVM_DragonFly,
{ZigLLVM_BGQ}, ZigLLVM_FreeBSD,
{ZigLLVM_Freescale}, ZigLLVM_IOS,
{ZigLLVM_IBM}, ZigLLVM_KFreeBSD,
{ZigLLVM_ImaginationTechnologies}, ZigLLVM_Linux,
{ZigLLVM_MipsTechnologies}, ZigLLVM_Lv2,
{ZigLLVM_NVIDIA}, ZigLLVM_MacOSX,
{ZigLLVM_CSR}, ZigLLVM_NetBSD,
ZigLLVM_OpenBSD,
ZigLLVM_Solaris,
ZigLLVM_Win32,
ZigLLVM_Haiku,
ZigLLVM_Minix,
ZigLLVM_RTEMS,
ZigLLVM_NaCl,
ZigLLVM_CNK,
ZigLLVM_Bitrig,
ZigLLVM_AIX,
ZigLLVM_CUDA,
ZigLLVM_NVCL,
ZigLLVM_AMDHSA,
ZigLLVM_PS4,
}; };
static const OsType os_list[] = { static const ZigLLVM_EnvironmentType environ_list[] = {
{ZigLLVM_UnknownOS}, ZigLLVM_GNU,
{ZigLLVM_CloudABI}, ZigLLVM_GNUEABI,
{ZigLLVM_Darwin}, ZigLLVM_GNUEABIHF,
{ZigLLVM_DragonFly}, ZigLLVM_GNUX32,
{ZigLLVM_FreeBSD}, ZigLLVM_CODE16,
{ZigLLVM_IOS}, ZigLLVM_EABI,
{ZigLLVM_KFreeBSD}, ZigLLVM_EABIHF,
{ZigLLVM_Linux}, ZigLLVM_Android,
{ZigLLVM_Lv2}, ZigLLVM_MSVC,
{ZigLLVM_MacOSX}, ZigLLVM_Itanium,
{ZigLLVM_NetBSD}, ZigLLVM_Cygnus,
{ZigLLVM_OpenBSD},
{ZigLLVM_Solaris},
{ZigLLVM_Win32},
{ZigLLVM_Haiku},
{ZigLLVM_Minix},
{ZigLLVM_RTEMS},
{ZigLLVM_NaCl},
{ZigLLVM_CNK},
{ZigLLVM_Bitrig},
{ZigLLVM_AIX},
{ZigLLVM_CUDA},
{ZigLLVM_NVCL},
{ZigLLVM_AMDHSA},
{ZigLLVM_PS4},
};
static const EnvironmentType environ_list[] = {
{ZigLLVM_GNU},
{ZigLLVM_GNUEABI},
{ZigLLVM_GNUEABIHF},
{ZigLLVM_GNUX32},
{ZigLLVM_CODE16},
{ZigLLVM_EABI},
{ZigLLVM_EABIHF},
{ZigLLVM_Android},
{ZigLLVM_MSVC},
{ZigLLVM_Itanium},
{ZigLLVM_Cygnus},
}; };
int target_arch_count(void) { int target_arch_count(void) {
@ -136,34 +133,28 @@ const ArchType *get_target_arch(int index) {
return &arch_list[index]; return &arch_list[index];
} }
int target_sub_arch_count(void) {
return array_length(sub_arch_list);
}
const SubArchType *get_target_sub_arch(int index) {
return &sub_arch_list[index];
}
int target_vendor_count(void) { int target_vendor_count(void) {
return array_length(vendor_list); return array_length(vendor_list);
} }
const VendorType *get_target_vendor(int index) { ZigLLVM_VendorType get_target_vendor(int index) {
return &vendor_list[index]; return vendor_list[index];
} }
int target_os_count(void) { int target_os_count(void) {
return array_length(os_list); return array_length(os_list);
} }
const OsType *get_target_os(int index) { ZigLLVM_OSType get_target_os(int index) {
return &os_list[index]; return os_list[index];
} }
const char *get_target_os_name(const OsType *os_type) {
return (os_type->llvm_os == ZigLLVM_UnknownOS) ? "freestanding" : ZigLLVMGetOSTypeName(os_type->llvm_os); const char *get_target_os_name(ZigLLVM_OSType os_type) {
return (os_type == ZigLLVM_UnknownOS) ? "freestanding" : ZigLLVMGetOSTypeName(os_type);
} }
int target_environ_count(void) { int target_environ_count(void) {
return array_length(environ_list); return array_length(environ_list);
} }
const EnvironmentType *get_target_environ(int index) { ZigLLVM_EnvironmentType get_target_environ(int index) {
return &environ_list[index]; return environ_list[index];
} }

30
src/target.hpp
View File

@ -11,41 +11,21 @@
#include <zig_llvm.hpp> #include <zig_llvm.hpp>
struct ArchType { struct ArchType {
ZigLLVM_ArchType llvm_arch; ZigLLVM_ArchType arch;
};
struct SubArchType {
ZigLLVM_ArchType arch; // which arch it applies to
ZigLLVM_SubArchType sub_arch; ZigLLVM_SubArchType sub_arch;
const char *name;
};
struct VendorType {
ZigLLVM_VendorType llvm_vendor;
};
struct OsType {
ZigLLVM_OSType llvm_os;
};
struct EnvironmentType {
ZigLLVM_EnvironmentType llvm_environment;
}; };
int target_arch_count(void); int target_arch_count(void);
const ArchType *get_target_arch(int index); const ArchType *get_target_arch(int index);
int target_sub_arch_count(void);
const SubArchType *get_target_sub_arch(int index);
int target_vendor_count(void); int target_vendor_count(void);
const VendorType *get_target_vendor(int index); ZigLLVM_VendorType get_target_vendor(int index);
int target_os_count(void); int target_os_count(void);
const OsType *get_target_os(int index); ZigLLVM_OSType get_target_os(int index);
const char *get_target_os_name(const OsType *os_type); const char *get_target_os_name(ZigLLVM_OSType os_type);
int target_environ_count(void); int target_environ_count(void);
const EnvironmentType *get_target_environ(int index); ZigLLVM_EnvironmentType get_target_environ(int index);
#endif #endif

39
src/zig_llvm.cpp
View File

@ -551,6 +551,45 @@ void ZigLLVMGetNativeTarget(ZigLLVM_ArchType *arch_type, ZigLLVM_SubArchType *su
free(native_triple); free(native_triple);
} }
const char *ZigLLVMGetSubArchTypeName(ZigLLVM_SubArchType sub_arch) {
switch (sub_arch) {
case ZigLLVM_NoSubArch:
return "(none)";
case ZigLLVM_ARMSubArch_v8_1a:
return "v8_1a";
case ZigLLVM_ARMSubArch_v8:
return "v8";
case ZigLLVM_ARMSubArch_v7:
return "v7";
case ZigLLVM_ARMSubArch_v7em:
return "v7em";
case ZigLLVM_ARMSubArch_v7m:
return "v7m";
case ZigLLVM_ARMSubArch_v7s:
return "v7s";
case ZigLLVM_ARMSubArch_v6:
return "v6";
case ZigLLVM_ARMSubArch_v6m:
return "v6m";
case ZigLLVM_ARMSubArch_v6k:
return "v6k";
case ZigLLVM_ARMSubArch_v6t2:
return "v6t2";
case ZigLLVM_ARMSubArch_v5:
return "v5";
case ZigLLVM_ARMSubArch_v5te:
return "v5te";
case ZigLLVM_ARMSubArch_v4t:
return "v4t";
case ZigLLVM_KalimbaSubArch_v3:
return "v3";
case ZigLLVM_KalimbaSubArch_v4:
return "v4";
case ZigLLVM_KalimbaSubArch_v5:
return "v5";
}
}
//------------------------------------ //------------------------------------
#include "buffer.hpp" #include "buffer.hpp"

1
src/zig_llvm.hpp
View File

@ -284,6 +284,7 @@ enum ZigLLVM_ObjectFormatType {
}; };
const char *ZigLLVMGetArchTypeName(ZigLLVM_ArchType arch); const char *ZigLLVMGetArchTypeName(ZigLLVM_ArchType arch);
const char *ZigLLVMGetSubArchTypeName(ZigLLVM_SubArchType sub_arch);
const char *ZigLLVMGetVendorTypeName(ZigLLVM_VendorType vendor); const char *ZigLLVMGetVendorTypeName(ZigLLVM_VendorType vendor);
const char *ZigLLVMGetOSTypeName(ZigLLVM_OSType os); const char *ZigLLVMGetOSTypeName(ZigLLVM_OSType os);
const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType environ); const char *ZigLLVMGetEnvironmentTypeName(ZigLLVM_EnvironmentType environ);