1 //===-- Path.cpp - Implement OS Path Concept --------------------*- 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 //  This header file implements the operating system Path concept.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Support/Path.h"
15 #include "llvm/Support/FileSystem.h"
16 #include "llvm/Config/config.h"
17 #include "llvm/Support/FileSystem.h"
18 #include "llvm/Support/Endian.h"
19 #include <cassert>
20 #include <cstring>
21 #include <ostream>
22 using namespace llvm;
23 using namespace sys;
24 namespace {
25 using support::ulittle32_t;
26 }
27 
28 //===----------------------------------------------------------------------===//
29 //=== WARNING: Implementation here must contain only TRULY operating system
30 //===          independent code.
31 //===----------------------------------------------------------------------===//
32 
33 bool Path::operator==(const Path &that) const {
34   return path == that.path;
35 }
36 
37 bool Path::operator<(const Path& that) const {
38   return path < that.path;
39 }
40 
41 Path
42 Path::GetLLVMConfigDir() {
43   Path result;
44 #ifdef LLVM_ETCDIR
45   if (result.set(LLVM_ETCDIR))
46     return result;
47 #endif
48   return GetLLVMDefaultConfigDir();
49 }
50 
51 LLVMFileType
52 sys::IdentifyFileType(const char *magic, unsigned length) {
53   assert(magic && "Invalid magic number string");
54   assert(length >=4 && "Invalid magic number length");
55   switch ((unsigned char)magic[0]) {
56     case 0xDE:  // 0x0B17C0DE = BC wraper
57       if (magic[1] == (char)0xC0 && magic[2] == (char)0x17 &&
58           magic[3] == (char)0x0B)
59         return Bitcode_FileType;
60       break;
61     case 'B':
62       if (magic[1] == 'C' && magic[2] == (char)0xC0 && magic[3] == (char)0xDE)
63         return Bitcode_FileType;
64       break;
65     case '!':
66       if (length >= 8)
67         if (memcmp(magic,"!<arch>\n",8) == 0)
68           return Archive_FileType;
69       break;
70 
71     case '\177':
72       if (magic[1] == 'E' && magic[2] == 'L' && magic[3] == 'F') {
73         if (length >= 18 && magic[17] == 0)
74           switch (magic[16]) {
75             default: break;
76             case 1: return ELF_Relocatable_FileType;
77             case 2: return ELF_Executable_FileType;
78             case 3: return ELF_SharedObject_FileType;
79             case 4: return ELF_Core_FileType;
80           }
81       }
82       break;
83 
84     case 0xCA:
85       if (magic[1] == char(0xFE) && magic[2] == char(0xBA) &&
86           magic[3] == char(0xBE)) {
87         // This is complicated by an overlap with Java class files.
88         // See the Mach-O section in /usr/share/file/magic for details.
89         if (length >= 8 && magic[7] < 43)
90           // FIXME: Universal Binary of any type.
91           return Mach_O_DynamicallyLinkedSharedLib_FileType;
92       }
93       break;
94 
95     case 0xFE:
96     case 0xCE: {
97       uint16_t type = 0;
98       if (magic[0] == char(0xFE) && magic[1] == char(0xED) &&
99           magic[2] == char(0xFA) && magic[3] == char(0xCE)) {
100         /* Native endian */
101         if (length >= 16) type = magic[14] << 8 | magic[15];
102       } else if (magic[0] == char(0xCE) && magic[1] == char(0xFA) &&
103                  magic[2] == char(0xED) && magic[3] == char(0xFE)) {
104         /* Reverse endian */
105         if (length >= 14) type = magic[13] << 8 | magic[12];
106       }
107       switch (type) {
108         default: break;
109         case 1: return Mach_O_Object_FileType;
110         case 2: return Mach_O_Executable_FileType;
111         case 3: return Mach_O_FixedVirtualMemorySharedLib_FileType;
112         case 4: return Mach_O_Core_FileType;
113         case 5: return Mach_O_PreloadExecutable_FileType;
114         case 6: return Mach_O_DynamicallyLinkedSharedLib_FileType;
115         case 7: return Mach_O_DynamicLinker_FileType;
116         case 8: return Mach_O_Bundle_FileType;
117         case 9: return Mach_O_DynamicallyLinkedSharedLibStub_FileType;
118         case 10: break; // FIXME: MH_DSYM companion file with only debug.
119       }
120       break;
121     }
122     case 0xF0: // PowerPC Windows
123     case 0x83: // Alpha 32-bit
124     case 0x84: // Alpha 64-bit
125     case 0x66: // MPS R4000 Windows
126     case 0x50: // mc68K
127     case 0x4c: // 80386 Windows
128       if (magic[1] == 0x01)
129         return COFF_FileType;
130 
131     case 0x90: // PA-RISC Windows
132     case 0x68: // mc68K Windows
133       if (magic[1] == 0x02)
134         return COFF_FileType;
135       break;
136 
137     case 0x4d: // Possible MS-DOS stub on Windows PE file
138       if (magic[1] == 0x5a) {
139         uint32_t off = *reinterpret_cast<const ulittle32_t *>(magic + 0x3c);
140         // PE/COFF file, either EXE or DLL.
141         if (off < length && memcmp(magic + off, "PE\0\0",4) == 0)
142           return COFF_FileType;
143       }
144       break;
145 
146     case 0x64: // x86-64 Windows.
147       if (magic[1] == char(0x86))
148         return COFF_FileType;
149       break;
150 
151     default:
152       break;
153   }
154   return Unknown_FileType;
155 }
156 
157 bool
158 Path::isArchive() const {
159   LLVMFileType type;
160   if (fs::identify_magic(str(), type))
161     return false;
162   return type == Archive_FileType;
163 }
164 
165 bool
166 Path::isDynamicLibrary() const {
167   LLVMFileType type;
168   if (fs::identify_magic(str(), type))
169     return false;
170   switch (type) {
171     default: return false;
172     case Mach_O_FixedVirtualMemorySharedLib_FileType:
173     case Mach_O_DynamicallyLinkedSharedLib_FileType:
174     case Mach_O_DynamicallyLinkedSharedLibStub_FileType:
175     case ELF_SharedObject_FileType:
176     case COFF_FileType:  return true;
177   }
178 }
179 
180 bool
181 Path::isObjectFile() const {
182   LLVMFileType type;
183   if (fs::identify_magic(str(), type) || type == Unknown_FileType)
184     return false;
185   return true;
186 }
187 
188 Path
189 Path::FindLibrary(std::string& name) {
190   std::vector<sys::Path> LibPaths;
191   GetSystemLibraryPaths(LibPaths);
192   for (unsigned i = 0; i < LibPaths.size(); ++i) {
193     sys::Path FullPath(LibPaths[i]);
194     FullPath.appendComponent("lib" + name + LTDL_SHLIB_EXT);
195     if (FullPath.isDynamicLibrary())
196       return FullPath;
197     FullPath.eraseSuffix();
198     FullPath.appendSuffix("a");
199     if (FullPath.isArchive())
200       return FullPath;
201   }
202   return sys::Path();
203 }
204 
205 StringRef Path::GetDLLSuffix() {
206   return &(LTDL_SHLIB_EXT[1]);
207 }
208 
209 void
210 Path::appendSuffix(StringRef suffix) {
211   if (!suffix.empty()) {
212     path.append(".");
213     path.append(suffix);
214   }
215 }
216 
217 bool
218 Path::isBitcodeFile() const {
219   LLVMFileType type;
220   if (fs::identify_magic(str(), type))
221     return false;
222   return type == Bitcode_FileType;
223 }
224 
225 bool Path::hasMagicNumber(StringRef Magic) const {
226   std::string actualMagic;
227   if (getMagicNumber(actualMagic, static_cast<unsigned>(Magic.size())))
228     return Magic == actualMagic;
229   return false;
230 }
231 
232 static void getPathList(const char*path, std::vector<Path>& Paths) {
233   const char* at = path;
234   const char* delim = strchr(at, PathSeparator);
235   Path tmpPath;
236   while (delim != 0) {
237     std::string tmp(at, size_t(delim-at));
238     if (tmpPath.set(tmp))
239       if (tmpPath.canRead())
240         Paths.push_back(tmpPath);
241     at = delim + 1;
242     delim = strchr(at, PathSeparator);
243   }
244 
245   if (*at != 0)
246     if (tmpPath.set(std::string(at)))
247       if (tmpPath.canRead())
248         Paths.push_back(tmpPath);
249 }
250 
251 static StringRef getDirnameCharSep(StringRef path, const char *Sep) {
252   assert(Sep[0] != '\0' && Sep[1] == '\0' &&
253          "Sep must be a 1-character string literal.");
254   if (path.empty())
255     return ".";
256 
257   // If the path is all slashes, return a single slash.
258   // Otherwise, remove all trailing slashes.
259 
260   signed pos = static_cast<signed>(path.size()) - 1;
261 
262   while (pos >= 0 && path[pos] == Sep[0])
263     --pos;
264 
265   if (pos < 0)
266     return path[0] == Sep[0] ? Sep : ".";
267 
268   // Any slashes left?
269   signed i = 0;
270 
271   while (i < pos && path[i] != Sep[0])
272     ++i;
273 
274   if (i == pos) // No slashes?  Return "."
275     return ".";
276 
277   // There is at least one slash left.  Remove all trailing non-slashes.
278   while (pos >= 0 && path[pos] != Sep[0])
279     --pos;
280 
281   // Remove any trailing slashes.
282   while (pos >= 0 && path[pos] == Sep[0])
283     --pos;
284 
285   if (pos < 0)
286     return path[0] == Sep[0] ? Sep : ".";
287 
288   return path.substr(0, pos+1);
289 }
290 
291 // Include the truly platform-specific parts of this class.
292 #if defined(LLVM_ON_UNIX)
293 #include "Unix/Path.inc"
294 #endif
295 #if defined(LLVM_ON_WIN32)
296 #include "Windows/Path.inc"
297 #endif
298