1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
//===-- HostInfoAndroid.cpp -------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/Host/android/HostInfoAndroid.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/linux/HostInfoLinux.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
using namespace lldb_private;
using namespace llvm;
void HostInfoAndroid::ComputeHostArchitectureSupport(ArchSpec &arch_32,
ArchSpec &arch_64) {
HostInfoLinux::ComputeHostArchitectureSupport(arch_32, arch_64);
if (arch_32.IsValid()) {
arch_32.GetTriple().setEnvironment(llvm::Triple::Android);
}
if (arch_64.IsValid()) {
arch_64.GetTriple().setEnvironment(llvm::Triple::Android);
}
}
FileSpec HostInfoAndroid::GetDefaultShell() {
return FileSpec("/system/bin/sh");
}
FileSpec HostInfoAndroid::ResolveLibraryPath(const std::string &module_path,
const ArchSpec &arch) {
static const char *const ld_library_path_separator = ":";
static const char *const default_lib32_path[] = {"/vendor/lib", "/system/lib",
nullptr};
static const char *const default_lib64_path[] = {"/vendor/lib64",
"/system/lib64", nullptr};
if (module_path.empty() || module_path[0] == '/') {
FileSpec file_spec(module_path.c_str());
FileSystem::Instance().Resolve(file_spec);
return file_spec;
}
SmallVector<StringRef, 4> ld_paths;
if (const char *ld_library_path = ::getenv("LD_LIBRARY_PATH"))
StringRef(ld_library_path)
.split(ld_paths, StringRef(ld_library_path_separator), -1, false);
const char *const *default_lib_path = nullptr;
switch (arch.GetAddressByteSize()) {
case 4:
default_lib_path = default_lib32_path;
break;
case 8:
default_lib_path = default_lib64_path;
break;
default:
assert(false && "Unknown address byte size");
return FileSpec();
}
for (const char *const *it = default_lib_path; *it; ++it)
ld_paths.push_back(StringRef(*it));
for (const StringRef &path : ld_paths) {
FileSpec file_candidate(path.str().c_str());
FileSystem::Instance().Resolve(file_candidate);
file_candidate.AppendPathComponent(module_path.c_str());
if (FileSystem::Instance().Exists(file_candidate))
return file_candidate;
}
return FileSpec();
}
bool HostInfoAndroid::ComputeTempFileBaseDirectory(FileSpec &file_spec) {
bool success = HostInfoLinux::ComputeTempFileBaseDirectory(file_spec);
// On Android, there is no path which is guaranteed to be writable. If the
// user has not provided a path via an environment variable, the generic
// algorithm will deduce /tmp, which is plain wrong. In that case we have an
// invalid directory, we substitute the path with /data/local/tmp, which is
// correct at least in some cases (i.e., when running as shell user).
if (!success || !FileSystem::Instance().Exists(file_spec))
file_spec = FileSpec("/data/local/tmp");
return FileSystem::Instance().Exists(file_spec);
}
|
