1716 ::close(file_descriptor);
1717 if (failed_to_read_elf_head) {
1718 // file i/o error - report dlerror() msg
1719 return NULL;
1720 }
1721
1722 typedef struct {
1723 Elf32_Half code; // Actual value as defined in elf.h
1724 Elf32_Half compat_class; // Compatibility of archs at VM's sense
1725 unsigned char elf_class; // 32 or 64 bit
1726 unsigned char endianess; // MSB or LSB
1727 char* name; // String representation
1728 } arch_t;
1729
1730 #ifndef EM_486
1731 #define EM_486 6 /* Intel 80486 */
1732 #endif
1733 #ifndef EM_AARCH64
1734 #define EM_AARCH64 183 /* ARM AARCH64 */
1735 #endif
1736
1737 static const arch_t arch_array[]={
1738 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
1739 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
1740 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
1741 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
1742 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
1743 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
1744 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
1745 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
1746 #if defined(VM_LITTLE_ENDIAN)
1747 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2LSB, (char*)"Power PC 64 LE"},
1748 {EM_SH, EM_SH, ELFCLASS32, ELFDATA2LSB, (char*)"SuperH"},
1749 #else
1750 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
1751 {EM_SH, EM_SH, ELFCLASS32, ELFDATA2MSB, (char*)"SuperH BE"},
1752 #endif
1753 {EM_ARM, EM_ARM, ELFCLASS32, ELFDATA2LSB, (char*)"ARM"},
1754 {EM_S390, EM_S390, ELFCLASSNONE, ELFDATA2MSB, (char*)"IBM System/390"},
1755 {EM_ALPHA, EM_ALPHA, ELFCLASS64, ELFDATA2LSB, (char*)"Alpha"},
1756 {EM_MIPS_RS3_LE, EM_MIPS_RS3_LE, ELFCLASS32, ELFDATA2LSB, (char*)"MIPSel"},
1757 {EM_MIPS, EM_MIPS, ELFCLASS32, ELFDATA2MSB, (char*)"MIPS"},
1758 {EM_PARISC, EM_PARISC, ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"},
1759 {EM_68K, EM_68K, ELFCLASS32, ELFDATA2MSB, (char*)"M68k"},
1760 {EM_AARCH64, EM_AARCH64, ELFCLASS64, ELFDATA2LSB, (char*)"AARCH64"},
1761 };
1762
1763 #if (defined IA32)
1764 static Elf32_Half running_arch_code=EM_386;
1765 #elif (defined AMD64)
1766 static Elf32_Half running_arch_code=EM_X86_64;
1767 #elif (defined IA64)
1768 static Elf32_Half running_arch_code=EM_IA_64;
1769 #elif (defined __sparc) && (defined _LP64)
1770 static Elf32_Half running_arch_code=EM_SPARCV9;
1771 #elif (defined __sparc) && (!defined _LP64)
1772 static Elf32_Half running_arch_code=EM_SPARC;
1773 #elif (defined __powerpc64__)
1774 static Elf32_Half running_arch_code=EM_PPC64;
1775 #elif (defined __powerpc__)
1776 static Elf32_Half running_arch_code=EM_PPC;
1777 #elif (defined AARCH64)
1778 static Elf32_Half running_arch_code=EM_AARCH64;
1779 #elif (defined ARM)
1780 static Elf32_Half running_arch_code=EM_ARM;
1781 #elif (defined S390)
1782 static Elf32_Half running_arch_code=EM_S390;
1783 #elif (defined ALPHA)
1784 static Elf32_Half running_arch_code=EM_ALPHA;
1785 #elif (defined MIPSEL)
1786 static Elf32_Half running_arch_code=EM_MIPS_RS3_LE;
1787 #elif (defined PARISC)
1788 static Elf32_Half running_arch_code=EM_PARISC;
1789 #elif (defined MIPS)
1790 static Elf32_Half running_arch_code=EM_MIPS;
1791 #elif (defined M68K)
1792 static Elf32_Half running_arch_code=EM_68K;
1793 #elif (defined SH)
1794 static Elf32_Half running_arch_code=EM_SH;
1795 #else
1796 #error Method os::dll_load requires that one of following is defined:\
1797 AARCH64, ALPHA, ARM, AMD64, IA32, IA64, M68K, MIPS, MIPSEL, PARISC, __powerpc__, __powerpc64__, S390, SH, __sparc
1798 #endif
1799
1800 // Identify compatability class for VM's architecture and library's architecture
1801 // Obtain string descriptions for architectures
1802
1803 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
1804 int running_arch_index=-1;
1805
1806 for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) {
1807 if (running_arch_code == arch_array[i].code) {
1808 running_arch_index = i;
1809 }
1810 if (lib_arch.code == arch_array[i].code) {
1811 lib_arch.compat_class = arch_array[i].compat_class;
1812 lib_arch.name = arch_array[i].name;
1813 }
1814 }
1815
1816 assert(running_arch_index != -1,
1817 "Didn't find running architecture code (running_arch_code) in arch_array");
2292 }
2293 }
2294 }
2295 }
2296 fclose(fp);
2297 }
2298 // cpuinfo not found or parsing failed, just print generic string. The entire
2299 // /proc/cpuinfo file will be printed later in the file (or enough of it for x86)
2300 #if defined(AARCH64)
2301 strncpy(cpuinfo, "AArch64", length);
2302 #elif defined(AMD64)
2303 strncpy(cpuinfo, "x86_64", length);
2304 #elif defined(ARM) // Order wrt. AARCH64 is relevant!
2305 strncpy(cpuinfo, "ARM", length);
2306 #elif defined(IA32)
2307 strncpy(cpuinfo, "x86_32", length);
2308 #elif defined(IA64)
2309 strncpy(cpuinfo, "IA64", length);
2310 #elif defined(PPC)
2311 strncpy(cpuinfo, "PPC64", length);
2312 #elif defined(S390)
2313 strncpy(cpuinfo, "S390", length);
2314 #elif defined(SPARC)
2315 strncpy(cpuinfo, "sparcv9", length);
2316 #elif defined(ZERO_LIBARCH)
2317 strncpy(cpuinfo, ZERO_LIBARCH, length);
2318 #else
2319 strncpy(cpuinfo, "unknown", length);
2320 #endif
2321 }
2322
2323 static void print_signal_handler(outputStream* st, int sig,
2324 char* buf, size_t buflen);
2325
2326 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
2327 st->print_cr("Signal Handlers:");
2328 print_signal_handler(st, SIGSEGV, buf, buflen);
2329 print_signal_handler(st, SIGBUS , buf, buflen);
2330 print_signal_handler(st, SIGFPE , buf, buflen);
2331 print_signal_handler(st, SIGPIPE, buf, buflen);
|
1716 ::close(file_descriptor);
1717 if (failed_to_read_elf_head) {
1718 // file i/o error - report dlerror() msg
1719 return NULL;
1720 }
1721
1722 typedef struct {
1723 Elf32_Half code; // Actual value as defined in elf.h
1724 Elf32_Half compat_class; // Compatibility of archs at VM's sense
1725 unsigned char elf_class; // 32 or 64 bit
1726 unsigned char endianess; // MSB or LSB
1727 char* name; // String representation
1728 } arch_t;
1729
1730 #ifndef EM_486
1731 #define EM_486 6 /* Intel 80486 */
1732 #endif
1733 #ifndef EM_AARCH64
1734 #define EM_AARCH64 183 /* ARM AARCH64 */
1735 #endif
1736 #ifndef EM_RISCV /* RISCV */
1737 #define EM_RISCV 243
1738 #endif
1739
1740 static const arch_t arch_array[]={
1741 {EM_386, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
1742 {EM_486, EM_386, ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
1743 {EM_IA_64, EM_IA_64, ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
1744 {EM_X86_64, EM_X86_64, ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
1745 {EM_SPARC, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
1746 {EM_SPARC32PLUS, EM_SPARC, ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
1747 {EM_SPARCV9, EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
1748 {EM_PPC, EM_PPC, ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
1749 #if defined(VM_LITTLE_ENDIAN)
1750 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2LSB, (char*)"Power PC 64 LE"},
1751 {EM_SH, EM_SH, ELFCLASS32, ELFDATA2LSB, (char*)"SuperH"},
1752 #else
1753 {EM_PPC64, EM_PPC64, ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
1754 {EM_SH, EM_SH, ELFCLASS32, ELFDATA2MSB, (char*)"SuperH BE"},
1755 #endif
1756 {EM_ARM, EM_ARM, ELFCLASS32, ELFDATA2LSB, (char*)"ARM"},
1757 {EM_S390, EM_S390, ELFCLASSNONE, ELFDATA2MSB, (char*)"IBM System/390"},
1758 {EM_ALPHA, EM_ALPHA, ELFCLASS64, ELFDATA2LSB, (char*)"Alpha"},
1759 {EM_MIPS_RS3_LE, EM_MIPS_RS3_LE, ELFCLASS32, ELFDATA2LSB, (char*)"MIPSel"},
1760 {EM_MIPS, EM_MIPS, ELFCLASS32, ELFDATA2MSB, (char*)"MIPS"},
1761 {EM_PARISC, EM_PARISC, ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"},
1762 {EM_68K, EM_68K, ELFCLASS32, ELFDATA2MSB, (char*)"M68k"},
1763 {EM_AARCH64, EM_AARCH64, ELFCLASS64, ELFDATA2LSB, (char*)"AARCH64"},
1764 {EM_RISCV, EM_RISCV, ELFCLASS64, ELFDATA2LSB, (char*)"RISCV"},
1765 };
1766
1767 #if (defined IA32)
1768 static Elf32_Half running_arch_code=EM_386;
1769 #elif (defined AMD64)
1770 static Elf32_Half running_arch_code=EM_X86_64;
1771 #elif (defined IA64)
1772 static Elf32_Half running_arch_code=EM_IA_64;
1773 #elif (defined __sparc) && (defined _LP64)
1774 static Elf32_Half running_arch_code=EM_SPARCV9;
1775 #elif (defined __sparc) && (!defined _LP64)
1776 static Elf32_Half running_arch_code=EM_SPARC;
1777 #elif (defined __powerpc64__)
1778 static Elf32_Half running_arch_code=EM_PPC64;
1779 #elif (defined __powerpc__)
1780 static Elf32_Half running_arch_code=EM_PPC;
1781 #elif (defined RISCV)
1782 static Elf32_Half running_arch_code=EM_RISCV;
1783 #elif (defined AARCH64)
1784 static Elf32_Half running_arch_code=EM_AARCH64;
1785 #elif (defined ARM)
1786 static Elf32_Half running_arch_code=EM_ARM;
1787 #elif (defined S390)
1788 static Elf32_Half running_arch_code=EM_S390;
1789 #elif (defined ALPHA)
1790 static Elf32_Half running_arch_code=EM_ALPHA;
1791 #elif (defined MIPSEL)
1792 static Elf32_Half running_arch_code=EM_MIPS_RS3_LE;
1793 #elif (defined PARISC)
1794 static Elf32_Half running_arch_code=EM_PARISC;
1795 #elif (defined MIPS)
1796 static Elf32_Half running_arch_code=EM_MIPS;
1797 #elif (defined M68K)
1798 static Elf32_Half running_arch_code=EM_68K;
1799 #elif (defined SH)
1800 static Elf32_Half running_arch_code=EM_SH;
1801 #else
1802 #error Method os::dll_load requires that one of following is defined:\
1803 AARCH64, ALPHA, ARM, AMD64, IA32, IA64, M68K, MIPS, MIPSEL, PARISC, __powerpc__, __powerpc64__, S390, SH, __sparc, RISCV
1804 #endif
1805
1806 // Identify compatability class for VM's architecture and library's architecture
1807 // Obtain string descriptions for architectures
1808
1809 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
1810 int running_arch_index=-1;
1811
1812 for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) {
1813 if (running_arch_code == arch_array[i].code) {
1814 running_arch_index = i;
1815 }
1816 if (lib_arch.code == arch_array[i].code) {
1817 lib_arch.compat_class = arch_array[i].compat_class;
1818 lib_arch.name = arch_array[i].name;
1819 }
1820 }
1821
1822 assert(running_arch_index != -1,
1823 "Didn't find running architecture code (running_arch_code) in arch_array");
2298 }
2299 }
2300 }
2301 }
2302 fclose(fp);
2303 }
2304 // cpuinfo not found or parsing failed, just print generic string. The entire
2305 // /proc/cpuinfo file will be printed later in the file (or enough of it for x86)
2306 #if defined(AARCH64)
2307 strncpy(cpuinfo, "AArch64", length);
2308 #elif defined(AMD64)
2309 strncpy(cpuinfo, "x86_64", length);
2310 #elif defined(ARM) // Order wrt. AARCH64 is relevant!
2311 strncpy(cpuinfo, "ARM", length);
2312 #elif defined(IA32)
2313 strncpy(cpuinfo, "x86_32", length);
2314 #elif defined(IA64)
2315 strncpy(cpuinfo, "IA64", length);
2316 #elif defined(PPC)
2317 strncpy(cpuinfo, "PPC64", length);
2318 #elif defined(RISCV)
2319 strncpy(cpuinfo, "RISCV", length);
2320 #elif defined(S390)
2321 strncpy(cpuinfo, "S390", length);
2322 #elif defined(SPARC)
2323 strncpy(cpuinfo, "sparcv9", length);
2324 #elif defined(ZERO_LIBARCH)
2325 strncpy(cpuinfo, ZERO_LIBARCH, length);
2326 #else
2327 strncpy(cpuinfo, "unknown", length);
2328 #endif
2329 }
2330
2331 static void print_signal_handler(outputStream* st, int sig,
2332 char* buf, size_t buflen);
2333
2334 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
2335 st->print_cr("Signal Handlers:");
2336 print_signal_handler(st, SIGSEGV, buf, buflen);
2337 print_signal_handler(st, SIGBUS , buf, buflen);
2338 print_signal_handler(st, SIGFPE , buf, buflen);
2339 print_signal_handler(st, SIGPIPE, buf, buflen);
|