1 //===- llvm/BinaryFormat/Magic.cpp - File magic identification --*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/BinaryFormat/Magic.h" 11 12 #include "llvm/BinaryFormat/COFF.h" 13 #include "llvm/BinaryFormat/ELF.h" 14 #include "llvm/BinaryFormat/MachO.h" 15 #include "llvm/Support/Endian.h" 16 #include "llvm/Support/FileSystem.h" 17 18 #if !defined(_MSC_VER) && !defined(__MINGW32__) 19 #include <unistd.h> 20 #else 21 #include <io.h> 22 #endif 23 24 using namespace llvm; 25 using namespace llvm::support::endian; 26 using namespace llvm::sys::fs; 27 28 template <size_t N> 29 static bool startswith(StringRef Magic, const char (&S)[N]) { 30 return Magic.startswith(StringRef(S, N - 1)); 31 } 32 33 /// @brief Identify the magic in magic. 34 file_magic llvm::identify_magic(StringRef Magic) { 35 if (Magic.size() < 4) 36 return file_magic::unknown; 37 switch ((unsigned char)Magic[0]) { 38 case 0x00: { 39 // COFF bigobj, CL.exe's LTO object file, or short import library file 40 if (startswith(Magic, "\0\0\xFF\xFF")) { 41 size_t MinSize = 42 offsetof(COFF::BigObjHeader, UUID) + sizeof(COFF::BigObjMagic); 43 if (Magic.size() < MinSize) 44 return file_magic::coff_import_library; 45 46 const char *Start = Magic.data() + offsetof(COFF::BigObjHeader, UUID); 47 if (memcmp(Start, COFF::BigObjMagic, sizeof(COFF::BigObjMagic)) == 0) 48 return file_magic::coff_object; 49 if (memcmp(Start, COFF::ClGlObjMagic, sizeof(COFF::BigObjMagic)) == 0) 50 return file_magic::coff_cl_gl_object; 51 return file_magic::coff_import_library; 52 } 53 // Windows resource file 54 if (startswith(Magic, "\0\0\0\0\x20\0\0\0\xFF")) 55 return file_magic::windows_resource; 56 // 0x0000 = COFF unknown machine type 57 if (Magic[1] == 0) 58 return file_magic::coff_object; 59 if (startswith(Magic, "\0asm")) 60 return file_magic::wasm_object; 61 break; 62 } 63 case 0xDE: // 0x0B17C0DE = BC wraper 64 if (startswith(Magic, "\xDE\xC0\x17\x0B")) 65 return file_magic::bitcode; 66 break; 67 case 'B': 68 if (startswith(Magic, "BC\xC0\xDE")) 69 return file_magic::bitcode; 70 break; 71 case '!': 72 if (startswith(Magic, "!<arch>\n") || startswith(Magic, "!<thin>\n")) 73 return file_magic::archive; 74 break; 75 76 case '\177': 77 if (startswith(Magic, "\177ELF") && Magic.size() >= 18) { 78 bool Data2MSB = Magic[5] == 2; 79 unsigned high = Data2MSB ? 16 : 17; 80 unsigned low = Data2MSB ? 17 : 16; 81 if (Magic[high] == 0) { 82 switch (Magic[low]) { 83 default: 84 return file_magic::elf; 85 case 1: 86 return file_magic::elf_relocatable; 87 case 2: 88 return file_magic::elf_executable; 89 case 3: 90 return file_magic::elf_shared_object; 91 case 4: 92 return file_magic::elf_core; 93 } 94 } 95 // It's still some type of ELF file. 96 return file_magic::elf; 97 } 98 break; 99 100 case 0xCA: 101 if (startswith(Magic, "\xCA\xFE\xBA\xBE") || 102 startswith(Magic, "\xCA\xFE\xBA\xBF")) { 103 // This is complicated by an overlap with Java class files. 104 // See the Mach-O section in /usr/share/file/magic for details. 105 if (Magic.size() >= 8 && Magic[7] < 43) 106 return file_magic::macho_universal_binary; 107 } 108 break; 109 110 // The two magic numbers for mach-o are: 111 // 0xfeedface - 32-bit mach-o 112 // 0xfeedfacf - 64-bit mach-o 113 case 0xFE: 114 case 0xCE: 115 case 0xCF: { 116 uint16_t type = 0; 117 if (startswith(Magic, "\xFE\xED\xFA\xCE") || 118 startswith(Magic, "\xFE\xED\xFA\xCF")) { 119 /* Native endian */ 120 size_t MinSize; 121 if (Magic[3] == char(0xCE)) 122 MinSize = sizeof(MachO::mach_header); 123 else 124 MinSize = sizeof(MachO::mach_header_64); 125 if (Magic.size() >= MinSize) 126 type = Magic[12] << 24 | Magic[13] << 12 | Magic[14] << 8 | Magic[15]; 127 } else if (startswith(Magic, "\xCE\xFA\xED\xFE") || 128 startswith(Magic, "\xCF\xFA\xED\xFE")) { 129 /* Reverse endian */ 130 size_t MinSize; 131 if (Magic[0] == char(0xCE)) 132 MinSize = sizeof(MachO::mach_header); 133 else 134 MinSize = sizeof(MachO::mach_header_64); 135 if (Magic.size() >= MinSize) 136 type = Magic[15] << 24 | Magic[14] << 12 | Magic[13] << 8 | Magic[12]; 137 } 138 switch (type) { 139 default: 140 break; 141 case 1: 142 return file_magic::macho_object; 143 case 2: 144 return file_magic::macho_executable; 145 case 3: 146 return file_magic::macho_fixed_virtual_memory_shared_lib; 147 case 4: 148 return file_magic::macho_core; 149 case 5: 150 return file_magic::macho_preload_executable; 151 case 6: 152 return file_magic::macho_dynamically_linked_shared_lib; 153 case 7: 154 return file_magic::macho_dynamic_linker; 155 case 8: 156 return file_magic::macho_bundle; 157 case 9: 158 return file_magic::macho_dynamically_linked_shared_lib_stub; 159 case 10: 160 return file_magic::macho_dsym_companion; 161 case 11: 162 return file_magic::macho_kext_bundle; 163 } 164 break; 165 } 166 case 0xF0: // PowerPC Windows 167 case 0x83: // Alpha 32-bit 168 case 0x84: // Alpha 64-bit 169 case 0x66: // MPS R4000 Windows 170 case 0x50: // mc68K 171 case 0x4c: // 80386 Windows 172 case 0xc4: // ARMNT Windows 173 if (Magic[1] == 0x01) 174 return file_magic::coff_object; 175 LLVM_FALLTHROUGH; 176 177 case 0x90: // PA-RISC Windows 178 case 0x68: // mc68K Windows 179 if (Magic[1] == 0x02) 180 return file_magic::coff_object; 181 break; 182 183 case 'M': // Possible MS-DOS stub on Windows PE file 184 if (startswith(Magic, "MZ")) { 185 uint32_t off = read32le(Magic.data() + 0x3c); 186 // PE/COFF file, either EXE or DLL. 187 if (off < Magic.size() && 188 memcmp(Magic.data() + off, COFF::PEMagic, sizeof(COFF::PEMagic)) == 0) 189 return file_magic::pecoff_executable; 190 } 191 break; 192 193 case 0x64: // x86-64 or ARM64 Windows. 194 if (Magic[1] == char(0x86) || Magic[1] == char(0xaa)) 195 return file_magic::coff_object; 196 break; 197 198 default: 199 break; 200 } 201 return file_magic::unknown; 202 } 203 204 std::error_code llvm::identify_magic(const Twine &Path, file_magic &Result) { 205 int FD; 206 if (std::error_code EC = openFileForRead(Path, FD)) 207 return EC; 208 209 char Buffer[32]; 210 int Length = read(FD, Buffer, sizeof(Buffer)); 211 if (close(FD) != 0 || Length < 0) 212 return std::error_code(errno, std::generic_category()); 213 214 Result = identify_magic(StringRef(Buffer, Length)); 215 return std::error_code(); 216 } 217