this repo has no description
Fixes that got wget working
+574
-93
+53
-73
src/dyld/MachOLoader.cpp
+53
-73
src/dyld/MachOLoader.cpp
···
29
29
extern char** g_argv;
30
30
extern bool g_trampoline;
31
31
32
-
static void doNothing()
33
-
{
34
-
}
35
-
36
-
static bool lookupDyldFunction(const char* name, uint64_t* addr)
32
+
static bool lookupDyldFunction(const char* name, void** addr)
37
33
{
38
34
LOG << "lookupDyldFunction: " << name <<std::endl;
39
-
*addr = (int64_t)&doNothing;
40
-
return true;
35
+
*addr = dlsym(dlopen(0, 0), name);
36
+
return (*addr) != 0;
41
37
}
42
38
43
39
static uint64_t alignMem(uint64_t p, uint64_t a)
···
74
70
m_pUndefMgr = new UndefMgr;
75
71
76
72
if (g_trampoline)
73
+
{
77
74
m_pTrampolineMgr = new TrampolineMgr;
75
+
76
+
const char* info = getenv("TRAMPOLINE_INFO");
77
+
if (info)
78
+
TrampolineMgr::loadFunctionInfo(info);
79
+
}
78
80
}
79
81
80
82
void MachOLoader::loadDylibs(const MachO& mach)
81
83
{
82
-
for (size_t i = 0; i < mach.dylibs().size(); i++)
84
+
for (std::string dylib : mach.dylibs())
83
85
{
84
-
std::string dylib = mach.dylibs()[i];
85
-
86
86
// __darwin_dlopen checks if already loaded
87
87
// automatically adds a reference if so
88
88
···
106
106
m_pTrampolineMgr->invalidateMemoryMap();
107
107
108
108
const std::vector<Segment*>& segments = getSegments(mach);
109
-
for (size_t i = 0; i < segments.size(); i++)
109
+
for (Segment* seg : segments)
110
110
{
111
-
Segment* seg = segments[i];
112
111
const char* name = seg->segname;
113
112
if (!strcmp(name, SEG_PAGEZERO))
114
113
continue;
···
136
135
LOG << "will rebase: filename=" << mach.filename()
137
136
<< ", vmaddr=" << (void*)vmaddr
138
137
<< ", last_addr=" << (void*)m_last_addr <<std::endl;
139
-
assert(i == 0);
138
+
assert(seg == segments[0]);
140
139
vmaddr = m_last_addr;
141
140
*slide = vmaddr - seg->vmaddr;
142
141
}
···
185
184
186
185
void MachOLoader::doRebase(const MachO& mach, intptr slide)
187
186
{
188
-
for (size_t i = 0; i < mach.rebases().size(); i++)
187
+
for (const MachO::Rebase* rebase : mach.rebases())
189
188
{
190
-
const MachO::Rebase& rebase = *mach.rebases()[i];
191
-
switch (rebase.type)
189
+
switch (rebase->type)
192
190
{
193
191
case REBASE_TYPE_POINTER:
194
192
{
195
-
char** ptr = (char**)(rebase.vmaddr + slide);
193
+
char** ptr = (char**)(rebase->vmaddr + slide);
196
194
/*LOG << "rebase: " << i << ": " << (void*)rebase.vmaddr << ' '
197
195
<< (void*)*ptr << " => "
198
196
<< (void*)(*ptr + slide) << " @" << ptr <<std::endl;*/
···
203
201
default:
204
202
{
205
203
std::stringstream ss;
206
-
ss << "Unknown rebase type: " << rebase.type;
204
+
ss << "Unknown rebase type: " << rebase->type;
207
205
208
206
throw std::runtime_error(ss.str());
209
207
}
···
213
211
214
212
void MachOLoader::loadInitFuncs(const MachO& mach, intptr slide)
215
213
{
216
-
for (size_t i = 0; i < mach.init_funcs().size(); i++)
214
+
for (intptr addr : mach.init_funcs())
217
215
{
218
-
intptr addr = mach.init_funcs()[i] + slide;
219
-
LOG << "Registering init func " << (void*)addr
220
-
<< " from " << mach.filename() << std::endl;
216
+
addr += slide;
217
+
LOG << "Registering init func " << (void*)addr << " from " << mach.filename() << std::endl;
221
218
m_init_funcs.push_back(addr);
222
219
}
223
220
}
···
231
228
232
229
g_bound_names.resize(mach.binds().size());
233
230
234
-
for (size_t i = 0; i < mach.binds().size(); i++)
231
+
for (MachO::Bind* bind : mach.binds())
235
232
{
236
-
MachO::Bind* bind = mach.binds()[i];
237
-
238
233
if (bind->type == BIND_TYPE_POINTER)
239
234
{
240
235
std::string name = bind->name.substr(1);
···
356
351
{
357
352
exports->rehash(exports->size() + mach.exports().size());
358
353
359
-
for (size_t i = 0; i < mach.exports().size(); i++)
354
+
for (MachO::Export* exp : mach.exports())
360
355
{
361
-
MachO::Export exp = *mach.exports()[i];
362
-
exp.addr += base;
356
+
exp->addr += base;
363
357
// TODO(hamaji): Not 100% sure, but we may need to consider weak symbols.
364
-
if (!exports->insert(make_pair(exp.name, exp)).second)
365
-
fprintf(stderr, "duplicated exported symbol: %s\n", exp.name.c_str());
358
+
if (!exports->insert(make_pair(exp->name, *exp)).second)
359
+
fprintf(stderr, "duplicated exported symbol: %s\n", exp->name.c_str());
366
360
}
367
361
}
368
362
···
455
449
{
456
450
LOG << "booting from " << (void*)mach.entry() << "..." << std::endl;
457
451
LOG << "==========\n";
458
-
boot(mach.entry(), argc, argv, envp);
452
+
boot(mach.entry(), argc, argv, envp, apple);
459
453
}
460
454
else if (mach.main())
461
455
{
···
471
465
throw std::runtime_error("No entry point found");
472
466
}
473
467
474
-
void MachOLoader::boot( uint64_t entry, int argc, char** argv, char** envp)
468
+
static inline int findLast(char** array)
469
+
{
470
+
for (int i = 0; ; i++)
471
+
{
472
+
if (!array[i])
473
+
return i;
474
+
}
475
+
}
476
+
477
+
void MachOLoader::boot( uint64_t entry, int argc, char** argv, char** envp, char** apple)
475
478
{
476
479
#ifdef __x86_64__
477
-
// 0x08: argc
478
-
// 0x10: argv[0]
479
-
// 0x18: argv[1]
480
-
// ...: argv[n]
481
-
// 0
482
-
// envp[0]
483
-
// envp[1]
484
-
// envp[n]
485
-
486
-
// TODO: add 'apple'!
487
-
488
-
__asm__ volatile(" movl %1, %%eax;\n"
489
-
" mov %2, %%rdx;\n"
490
-
" pushq $0;\n"
491
-
// TODO(hamaji): envp
492
-
" pushq $0;\n"
493
-
".loop64:\n"
494
-
" subq $8, %%rdx;\n"
495
-
" pushq (%%rdx);\n"
496
-
" dec %%eax;\n"
497
-
" jnz .loop64;\n"
498
-
" movl %1, %%eax;\n"
499
-
" pushq %%rax;\n"
500
-
" jmp *%0;\n"
501
-
::"r"(entry), "r"(argc), "r"(argv + argc), "r"(envp)
502
-
:"%rax", "%rdx");
503
-
//fprintf(stderr, "done!\n");
480
+
# define PUSH(val) __asm__ volatile("pushq %0" :: "r"(uint64_t(val)) :)
481
+
# define JUMP(addr) __asm__ volatile("jmpq *%0" :: "m"(addr) :)
504
482
#else
505
-
__asm__ volatile(" mov %1, %%eax;\n"
506
-
" mov %2, %%edx;\n"
507
-
" push $0;\n"
508
-
".loop32:\n"
509
-
" sub $4, %%edx;\n"
510
-
" push (%%edx);\n"
511
-
" dec %%eax;\n"
512
-
" jnz .loop32;\n"
513
-
" mov %1, %%eax;\n"
514
-
" push %%eax;\n"
515
-
" jmp *%0;\n"
516
-
// TODO(hamaji): Fix parameters
517
-
::"r"(entry), "r"(argc), "r"(argv + argc), "g"(envp)
518
-
:"%eax", "%edx");
483
+
# define PUSH(val) __asm__ volatile("pushl %0" :: "r"(uint32_t(val)) :)
484
+
# define JUMP(addr) __asm__ volatile("jmp *%0" :: "r"(addr) :)
519
485
#endif
486
+
487
+
for (int i = findLast(apple); i >= 0; i--)
488
+
PUSH(apple[i]);
489
+
490
+
for (int i = findLast(envp); i >= 0; i--)
491
+
PUSH(envp[i]);
492
+
493
+
assert(!argv[argc]);
494
+
495
+
for (int i = argc; i >= 0; i--)
496
+
PUSH(argv[i]);
497
+
498
+
PUSH(argc);
499
+
JUMP(entry);
520
500
}
521
501
522
502
#ifdef DEBUG
+1
-1
src/dyld/MachOLoader.h
+1
-1
src/dyld/MachOLoader.h
···
64
64
const Exports& getExports() const { return m_exports; }
65
65
private:
66
66
// Jumps to the application entry
67
-
void boot(uint64_t entry, int argc, char** argv, char** envp);
67
+
void boot(uint64_t entry, int argc, char** argv, char** envp, char** apple);
68
68
private:
69
69
intptr m_last_addr;
70
70
std::vector<uint64_t> m_init_funcs;
+64
-9
src/dyld/Trampoline.cpp
+64
-9
src/dyld/Trampoline.cpp
···
62
62
{
63
63
if (m_memoryMap.empty())
64
64
loadMemoryMap();
65
+
66
+
// std::cout << "isExecutable(): " << addr << std::endl;
65
67
66
68
for (auto it = m_memoryMap.begin(); it != m_memoryMap.end(); it++)
67
69
{
···
91
93
pages.start = (void*) strtol(s, (char**) &s, 16);
92
94
s++;
93
95
pages.end = (void*) strtol(s, (char**) &s, 16);
94
-
pages.executable = *(s+3) == 'x';
96
+
pages.executable = (*(s+3) == 'x') && (*(s+2) == '-'); // not writable
95
97
96
-
// std::cout << line << " -> " << pages.start << " - " << pages.end << " " << pages.executable << std::endl;
98
+
//std::cout << line << " -> " << pages.start << " - " << pages.end << " " << pages.executable << std::endl;
97
99
m_memoryMap.push_back(pages);
98
100
}
99
101
}
···
204
206
{
205
207
}
206
208
209
+
TrampolineMgr::ArgumentWalker::ArgumentWalker(CallStack* stack, OutputArguments args)
210
+
: m_stack(stack), m_indexInt(0), m_indexXmm(0), m_pointers(args)
211
+
{
212
+
}
213
+
214
+
207
215
uint64_t TrampolineMgr::ArgumentWalker::next64bit()
208
216
{
209
217
uint64_t rv;
···
241
249
std::string TrampolineMgr::ArgumentWalker::next(char type)
242
250
{
243
251
std::stringstream ss;
252
+
void* ptr;
244
253
245
254
if (type == 'u')
246
255
ss << next64bit();
···
259
268
long double d = nextDouble();
260
269
ss << *((double*)&d);
261
270
}
262
-
else if (type == 'p')
263
-
ss << "0x" << std::hex << (void*)next64bit() << std::dec;
271
+
else if (type == 'p' || isupper(type))
272
+
{
273
+
ptr = (void*) next64bit();
274
+
ss << ptr;
275
+
}
276
+
else if (type == 'c')
277
+
ss << char(next64bit());
264
278
else if (type == 's')
265
-
ss << (const char*)next64bit();
279
+
{
280
+
const char* s = (const char*) next64bit();
281
+
ss << (void*)s;
282
+
if (s)
283
+
ss << " \"" << safeString(s) << '"';
284
+
}
266
285
else if (type == 'v')
267
286
ss << "(void)";
268
287
else
269
288
ss << '?';
289
+
290
+
if (isupper(type))
291
+
m_pointers.push_back(std::make_pair(tolower(type), ptr));
270
292
271
293
return ss.str();
272
294
}
···
277
299
278
300
if (type == 'u')
279
301
ss << m_stack->rax;
302
+
else if (type == 'c')
303
+
ss << char(m_stack->rax);
280
304
else if (type == 'i')
281
305
{
282
306
uint64_t u = m_stack->rax;
···
292
316
long double d = m_stack->xmm[0];
293
317
ss << *((double*)&d);
294
318
}
295
-
else if (type == 'p')
296
-
ss << "0x" << std::hex << (void*)m_stack->rax << std::dec;
319
+
else if (type == 'p' || isupper(type))
320
+
ss << (void*)m_stack->rax << std::dec;
297
321
else if (type == 's')
298
-
ss << (const char*)m_stack->rax;
322
+
{
323
+
const char* s = (const char*) m_stack->rax;
324
+
ss << (void*)s << " \"" << safeString(s) << '"';
325
+
}
299
326
else
300
327
ss << '?';
301
328
302
329
return ss.str();
303
330
}
304
331
332
+
std::string TrampolineMgr::ArgumentWalker::safeString(const char* in)
333
+
{
334
+
if (!in)
335
+
return std::string();
336
+
337
+
std::stringstream rv;
338
+
while (*in)
339
+
{
340
+
if (*in >= 32)
341
+
rv << *in;
342
+
else
343
+
{
344
+
if (*in == '\n')
345
+
rv << "\\n";
346
+
else if (*in == '\r')
347
+
rv << "\\r";
348
+
else if (*in == '\t')
349
+
rv << "\\t";
350
+
else
351
+
rv << "\\x" << std::hex << int(*in);
352
+
}
353
+
in++;
354
+
}
355
+
return rv.str();
356
+
}
357
+
305
358
#ifdef TEST
306
359
307
360
double mytestfunc(int a, int b, double c)
···
315
368
TrampolineMgr::loadFunctionInfo("/tmp/fi");
316
369
317
370
double (*pFunc)(int,int,double) = (double (*)(int,int,double)) mgr->generate((void*) &mytestfunc, "mytestfunc");
318
-
std::cout << pFunc(2,3,0.5) << std::endl;
371
+
int (*pPrintf)(FILE* f, const char*,...) = (int (*)(FILE* f, const char*,...)) mgr->generate((void*) &fprintf, "printf");
372
+
//std::cout << pFunc(2,3,0.5) << std::endl;
373
+
pPrintf(stdout, "Hello world: %s\n", "Test");
319
374
320
375
delete mgr;
321
376
return 0;
+7
src/dyld/Trampoline.h
+7
src/dyld/Trampoline.h
···
34
34
static void* printInfo(uint32_t index, CallStack* stack);
35
35
static void* printInfoR(uint32_t index, CallStack* stack);
36
36
private:
37
+
typedef std::vector<std::pair<char,void*> > OutputArguments;
37
38
struct AddrEntry
38
39
{
39
40
std::string name;
40
41
void* addr;
41
42
void* retAddr; // not reentrant
43
+
OutputArguments pointers; // not reentrant
42
44
};
43
45
struct MemoryPages
44
46
{
···
58
60
{
59
61
public:
60
62
ArgumentWalker(CallStack* stack);
63
+
ArgumentWalker(CallStack* stack, OutputArguments args /* for printInfoR only */);
61
64
uint64_t next64bit();
62
65
long double nextDouble();
63
66
std::string next(char type);
64
67
std::string ret(char type);
68
+
OutputArguments getOutputArguments() { return m_pointers; }
69
+
private:
70
+
static std::string safeString(const char* in);
65
71
private:
66
72
CallStack* m_stack;
67
73
int m_indexInt, m_indexXmm;
74
+
OutputArguments m_pointers;
68
75
};
69
76
70
77
static TrampolineMgr* m_pInstance;
+2
src/libSystem/CMakeLists.txt
+2
src/libSystem/CMakeLists.txt
+24
src/libSystem/common/auto.cpp
+24
src/libSystem/common/auto.cpp
···
1
+
#include "auto.h"
2
+
3
+
int Darling::flagsDarwinToNative(MappedFlag* flags, size_t count, int darwin)
4
+
{
5
+
int out = 0;
6
+
for (size_t i = 0; i < count; i++)
7
+
{
8
+
if (darwin & flags[i].darwin)
9
+
out |= flags[i].native;
10
+
}
11
+
return out;
12
+
}
13
+
14
+
int Darling::flagsNativeToDarwin(MappedFlag* flags, size_t count, int native)
15
+
{
16
+
int out = 0;
17
+
for (size_t i = 0; i < count; i++)
18
+
{
19
+
if (native & flags[i].native)
20
+
out |= flags[i].darwin;
21
+
}
22
+
return out;
23
+
}
24
+
+13
src/libSystem/common/auto.h
+13
src/libSystem/common/auto.h
···
1
1
#ifndef COMMON_AUTO_H
2
2
#define COMMON_AUTO_H
3
+
#include "path.h"
4
+
#include "../libc/errno.h"
3
5
4
6
inline bool retvalOK(void* p) { return p != 0; }
5
7
inline bool retvalOK(int p) { return p != -1; }
···
32
34
if (!retvalOK(rv))
33
35
errnoOut();
34
36
return rv;
37
+
}
38
+
39
+
namespace Darling
40
+
{
41
+
struct MappedFlag
42
+
{
43
+
int darwin;
44
+
int native;
45
+
};
46
+
int flagsDarwinToNative(MappedFlag* flags, size_t count, int darwin);
47
+
int flagsNativeToDarwin(MappedFlag* flags, size_t count, int native);
35
48
}
36
49
37
50
#endif
+16
-9
src/libSystem/kernel-bsd/sockets.cpp
+16
-9
src/libSystem/kernel-bsd/sockets.cpp
···
11
11
#include <cstring>
12
12
#include <poll.h>
13
13
14
-
static short familyDarwinToLinux(short f)
14
+
using namespace Darling;
15
+
16
+
short Darling::familyDarwinToLinux(short f)
15
17
{
16
18
switch (f)
17
19
{
···
32
34
}
33
35
}
34
36
35
-
static short familyLinuxToDarwin(short f)
37
+
short Darling::familyLinuxToDarwin(short f)
36
38
{
37
39
switch (f)
38
40
{
···
53
55
}
54
56
}
55
57
56
-
static bool sockaddrFixupIn(struct sockaddr* addr, socklen_t len)
58
+
bool Darling::sockaddrFixupIn(struct sockaddr* addr, socklen_t len)
57
59
{
58
60
if (offsetof(struct sockaddr,sa_family) == 0)
59
61
{
60
62
// BSD/Darwin has offset of 1
61
-
memmove(addr, reinterpret_cast<char*>(addr)+1, len-1);
63
+
//memmove(addr, reinterpret_cast<char*>(addr)+1, len-1);
64
+
short f = *reinterpret_cast<short*>(reinterpret_cast<char*>(addr)+1);
65
+
addr->sa_family = f;
62
66
}
63
67
addr->sa_family = familyDarwinToLinux(addr->sa_family);
64
68
return addr->sa_family != -1;
65
69
}
66
70
67
-
static bool sockaddrFixupOut(struct sockaddr* addr, socklen_t len)
71
+
bool Darling::sockaddrFixupOut(struct sockaddr* addr, socklen_t len)
68
72
{
69
73
bool ok;
70
74
addr->sa_family = familyLinuxToDarwin(addr->sa_family);
···
73
77
if (offsetof(struct sockaddr,sa_family) == 0)
74
78
{
75
79
// BSD/Darwin has offset of 1
76
-
memmove(reinterpret_cast<char*>(addr)+1, addr, len-1);
80
+
// memmove(reinterpret_cast<char*>(addr)+1, addr, len-1);
81
+
short f = addr->sa_family;
82
+
*reinterpret_cast<short*>(reinterpret_cast<char*>(addr)+1) = f;
77
83
}
78
84
return ok;
79
85
}
···
220
226
221
227
int __darwin_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
222
228
{
223
-
struct sockaddr* ma = reinterpret_cast<struct sockaddr*>(alloca(sizeof(addrlen)));
229
+
struct sockaddr* ma = reinterpret_cast<struct sockaddr*>(malloc(addrlen));
224
230
225
231
memcpy(ma, addr, addrlen);
226
-
ma->sa_family = familyDarwinToLinux(addr->sa_family);
227
232
228
-
if (ma->sa_family == -1)
233
+
if (!sockaddrFixupIn(ma, addrlen))
229
234
{
235
+
free(ma);
230
236
errno = DARWIN_EAFNOSUPPORT;
231
237
return -1;
232
238
}
···
235
241
int rv = ::connect(sockfd, ma, addrlen);
236
242
if (rv == -1)
237
243
errnoOut();
244
+
free(ma);
238
245
return rv;
239
246
}
240
247
}
+8
src/libSystem/kernel-bsd/sockets.h
+8
src/libSystem/kernel-bsd/sockets.h
+1
-1
src/libSystem/kernel-bsd/wait.cpp
+1
-1
src/libSystem/kernel-bsd/wait.cpp
+81
src/libSystem/libc/arch.cpp
+81
src/libSystem/libc/arch.cpp
···
1
+
#include "arch.h"
2
+
#include <cstring>
3
+
4
+
// This was dumped on snow leopard.
5
+
static NXArchInfo __darwin_all_arch_infos[] = {
6
+
// The first entry indicates the local arch.
7
+
{ "hppa", 11, 0, 2, "HP-PA" },
8
+
{ "i386", 7, 3, 1, "Intel 80x86" },
9
+
{ "x86_64", 16777223, 3, 1, "Intel x86-64" },
10
+
{ "i860", 15, 0, 2, "Intel 860" },
11
+
{ "m68k", 6, 1, 2, "Motorola 68K" },
12
+
{ "m88k", 13, 0, 2, "Motorola 88K" },
13
+
{ "ppc", 18, 0, 2, "PowerPC" },
14
+
{ "ppc64", 16777234, 0, 2, "PowerPC 64-bit" },
15
+
{ "sparc", 14, 0, 2, "SPARC" },
16
+
{ "arm", 12, 0, 1, "ARM" },
17
+
{ "any", -1, -1, 0, "Architecture Independent" },
18
+
{ "veo", 255, 2, 2, "veo" },
19
+
{ "hppa7100LC", 11, 1, 2, "HP-PA 7100LC" },
20
+
{ "m68030", 6, 3, 2, "Motorola 68030" },
21
+
{ "m68040", 6, 2, 2, "Motorola 68040" },
22
+
{ "i486", 7, 4, 1, "Intel 80486" },
23
+
{ "i486SX", 7, 132, 1, "Intel 80486SX" },
24
+
{ "pentium", 7, 5, 1, "Intel Pentium" },
25
+
{ "i586", 7, 5, 1, "Intel 80586" },
26
+
{ "pentpro", 7, 22, 1, "Intel Pentium Pro" },
27
+
{ "i686", 7, 22, 1, "Intel Pentium Pro" },
28
+
{ "pentIIm3", 7, 54, 1, "Intel Pentium II Model 3" },
29
+
{ "pentIIm5", 7, 86, 1, "Intel Pentium II Model 5" },
30
+
{ "pentium4", 7, 10, 1, "Intel Pentium 4" },
31
+
{ "ppc601", 18, 1, 2, "PowerPC 601" },
32
+
{ "ppc603", 18, 3, 2, "PowerPC 603" },
33
+
{ "ppc603e", 18, 4, 2, "PowerPC 603e" },
34
+
{ "ppc603ev", 18, 5, 2, "PowerPC 603ev" },
35
+
{ "ppc604", 18, 6, 2, "PowerPC 604" },
36
+
{ "ppc604e", 18, 7, 2, "PowerPC 604e" },
37
+
{ "ppc750", 18, 9, 2, "PowerPC 750" },
38
+
{ "ppc7400", 18, 10, 2, "PowerPC 7400" },
39
+
{ "ppc7450", 18, 11, 2, "PowerPC 7450" },
40
+
{ "ppc970", 18, 100, 2, "PowerPC 970" },
41
+
{ "ppc970-64", 16777234, 100, 2, "PowerPC 970 64-bit" },
42
+
{ "armv4t", 12, 5, 1, "arm v4t" },
43
+
{ "armv5", 12, 7, 1, "arm v5" },
44
+
{ "xscale", 12, 8, 1, "arm xscale" },
45
+
{ "armv6", 12, 6, 1, "arm v6" },
46
+
{ "armv7", 12, 9, 1, "arm v7" },
47
+
{ "little", -1, 0, 1, "Little Endian" },
48
+
{ "big", -1, 1, 2, "Big Endian" },
49
+
{ "veo1", 255, 1, 2, "veo 1" },
50
+
{ "veo2", 255, 2, 2, "veo 2" },
51
+
{ NULL, 0, 0, 0, NULL },
52
+
};
53
+
54
+
const NXArchInfo* NXGetAllArchInfos()
55
+
{
56
+
return __darwin_all_arch_infos;
57
+
}
58
+
59
+
const NXArchInfo* NXGetLocalArchInfo()
60
+
{
61
+
#if defined(__i386__)
62
+
return &__darwin_all_arch_infos[1];
63
+
#elif defined(__x86_64__)
64
+
return &__darwin_all_arch_infos[2];
65
+
#else
66
+
# error Unsupported architecture!
67
+
#endif
68
+
}
69
+
70
+
const NXArchInfo* NXGetArchInfoFromName(const char *name)
71
+
{
72
+
NXArchInfo* info = __darwin_all_arch_infos;
73
+
for (; info->name; info++)
74
+
{
75
+
if (!strcmp(info->name, name))
76
+
return info;
77
+
}
78
+
return 0;
79
+
}
80
+
81
+
+24
src/libSystem/libc/arch.h
+24
src/libSystem/libc/arch.h
···
1
+
#ifndef LIBC_ARCH_H
2
+
#define LIBC_ARCH_H
3
+
#include <stdint.h>
4
+
5
+
struct NXArchInfo
6
+
{
7
+
const char* name;
8
+
int32_t cputype;
9
+
int32_t cpusubtype;
10
+
int byteorder;
11
+
const char* description;
12
+
};
13
+
14
+
extern "C"
15
+
{
16
+
17
+
const NXArchInfo* NXGetAllArchInfos();
18
+
const NXArchInfo* NXGetLocalArchInfo();
19
+
const NXArchInfo* NXGetArchInfoFromName(const char *name);
20
+
21
+
}
22
+
23
+
#endif
24
+
+1
src/libSystem/libc/errno.h
+1
src/libSystem/libc/errno.h
+130
src/libSystem/libc/net.cpp
+130
src/libSystem/libc/net.cpp
···
1
+
#include "config.h"
2
+
#include "net.h"
3
+
#include "common/auto.h"
4
+
#include "kernel-bsd/sockets.h"
5
+
#include <cstring>
6
+
#include <string>
7
+
#include <iostream>
8
+
#include <arpa/inet.h>
9
+
10
+
static Darling::MappedFlag g_flags[] = {
11
+
{ DARWIN_AI_ADDRCONFIG, AI_ADDRCONFIG },
12
+
{ DARWIN_AI_ALL, AI_ALL },
13
+
{ DARWIN_AI_CANONNAME, AI_CANONNAME },
14
+
{ DARWIN_AI_NUMERICHOST, AI_NUMERICHOST },
15
+
{ DARWIN_AI_NUMERICSERV, AI_NUMERICSERV },
16
+
{ DARWIN_AI_PASSIVE, AI_PASSIVE },
17
+
{ DARWIN_AI_V4MAPPED, AI_V4MAPPED }
18
+
};
19
+
20
+
int __darwin_getaddrinfo(const char *hostname, const char *servname, const struct __darwin_addrinfo *hints, struct __darwin_addrinfo **res)
21
+
{
22
+
struct addrinfo* chints;
23
+
24
+
if (hints)
25
+
{
26
+
chints = new struct addrinfo;
27
+
28
+
const struct __darwin_addrinfo* next = hints;
29
+
struct addrinfo* cnext = chints;
30
+
31
+
while (next)
32
+
{
33
+
memset(cnext, 0, sizeof(*cnext));
34
+
cnext->ai_family = Darling::familyDarwinToLinux(next->ai_family);
35
+
cnext->ai_flags = Darling::flagsDarwinToNative(g_flags, sizeof(g_flags)/sizeof(g_flags[0]), next->ai_flags);
36
+
cnext->ai_socktype = next->ai_socktype;
37
+
38
+
next = next->ai_next;
39
+
40
+
if (next)
41
+
{
42
+
cnext->ai_next = new struct addrinfo;
43
+
cnext = cnext->ai_next;
44
+
}
45
+
else
46
+
cnext->ai_next = 0;
47
+
}
48
+
}
49
+
else
50
+
chints = 0;
51
+
52
+
struct addrinfo* nres;
53
+
int rv = getaddrinfo(hostname, servname, chints, &nres);
54
+
55
+
// delete native hints
56
+
while (chints)
57
+
{
58
+
struct addrinfo* i = chints->ai_next;
59
+
delete chints;
60
+
chints = i;
61
+
}
62
+
63
+
*res = 0;
64
+
if (!rv)
65
+
{
66
+
// convert the native addrinfo
67
+
struct addrinfo* next = nres;
68
+
struct __darwin_addrinfo* cnext = *res = new __darwin_addrinfo;
69
+
while (next)
70
+
{
71
+
cnext->ai_family = Darling::familyLinuxToDarwin(next->ai_family);
72
+
cnext->ai_flags = Darling::flagsNativeToDarwin(g_flags, sizeof(g_flags)/sizeof(g_flags[0]), next->ai_flags);
73
+
74
+
if (next->ai_canonname)
75
+
cnext->ai_canonname = strdup(next->ai_canonname);
76
+
else
77
+
cnext->ai_canonname = 0;
78
+
79
+
cnext->ai_socktype = next->ai_socktype;
80
+
cnext->ai_protocol = next->ai_protocol;
81
+
cnext->ai_addrlen = next->ai_addrlen;
82
+
83
+
cnext->ai_addr = static_cast<struct sockaddr*>(malloc(cnext->ai_addrlen));
84
+
memcpy(cnext->ai_addr, next->ai_addr, cnext->ai_addrlen);
85
+
86
+
Darling::sockaddrFixupOut(cnext->ai_addr, cnext->ai_addrlen);
87
+
next = next->ai_next;
88
+
89
+
if (next)
90
+
{
91
+
cnext->ai_next = new __darwin_addrinfo;
92
+
cnext = cnext->ai_next;
93
+
}
94
+
else
95
+
cnext->ai_next = 0;
96
+
}
97
+
freeaddrinfo(nres);
98
+
}
99
+
else
100
+
{
101
+
errnoOut();
102
+
}
103
+
104
+
return rv;
105
+
}
106
+
107
+
108
+
void __darwin_freeaddrinfo(struct __darwin_addrinfo* res)
109
+
{
110
+
while (res)
111
+
{
112
+
struct __darwin_addrinfo* n = res->ai_next;
113
+
free(res->ai_canonname);
114
+
free(res->ai_addr);
115
+
delete res;
116
+
res = n;
117
+
}
118
+
}
119
+
120
+
const char* __darwin_inet_ntop(int af, const void* src, char* dst, socklen_t size)
121
+
{
122
+
af = Darling::familyDarwinToLinux(af);
123
+
const char* rv = inet_ntop(af, src, dst, size);
124
+
125
+
if (!rv)
126
+
errnoOut();
127
+
128
+
return rv;
129
+
}
130
+
+38
src/libSystem/libc/net.h
+38
src/libSystem/libc/net.h
···
1
+
#ifndef LIBC_NET_H
2
+
#define LIBC_NET_H
3
+
#include <sys/types.h>
4
+
#include <sys/socket.h>
5
+
#include <netdb.h>
6
+
7
+
#define DARWIN_AI_ADDRCONFIG 1024
8
+
#define DARWIN_AI_ALL 256
9
+
#define DARWIN_AI_CANONNAME 2
10
+
#define DARWIN_AI_NUMERICHOST 4
11
+
#define DARWIN_AI_NUMERICSERV 4096
12
+
#define DARWIN_AI_PASSIVE 1
13
+
#define DARWIN_AI_V4MAPPED 2048
14
+
15
+
struct __darwin_addrinfo
16
+
{
17
+
int ai_flags;
18
+
int ai_family;
19
+
int ai_socktype;
20
+
int ai_protocol;
21
+
socklen_t ai_addrlen;
22
+
char *ai_canonname;
23
+
struct sockaddr *ai_addr;
24
+
struct __darwin_addrinfo *ai_next;
25
+
};
26
+
27
+
28
+
extern "C"
29
+
{
30
+
31
+
int __darwin_getaddrinfo(const char *hostname, const char *servname, const struct __darwin_addrinfo *hints, struct __darwin_addrinfo **res);
32
+
void __darwin_freeaddrinfo(struct __darwin_addrinfo* res);
33
+
const char* __darwin_inet_ntop(int af, const void* src, char* dst, socklen_t size);
34
+
35
+
}
36
+
37
+
#endif
38
+
+71
src/libSystem/libc/pthread.cpp
+71
src/libSystem/libc/pthread.cpp
···
64
64
return rv;
65
65
}
66
66
67
+
template<typename Func, typename... Args> int AutoAllocMutexGeneric(Func f, __darwin_pthread_mutex_t* mutex, Args... args)
68
+
{
69
+
int rv;
70
+
if (mutex->signature != __darwin_pthread_mutex_t::SIGNATURE_NATIVE_INITIALIZED)
71
+
{
72
+
pthread_mutexattr_t mta;
73
+
pthread_mutexattr_init(&mta);
74
+
int type;
75
+
76
+
switch (mutex->signature)
77
+
{
78
+
case __darwin_pthread_mutex_t::SIGNATURE_MACRO_INITIALIZED_R:
79
+
type = PTHREAD_MUTEX_RECURSIVE;
80
+
break;
81
+
case __darwin_pthread_mutex_t::SIGNATURE_MACRO_INITIALIZED_E:
82
+
type = PTHREAD_MUTEX_ERRORCHECK;
83
+
break;
84
+
case __darwin_pthread_mutex_t::SIGNATURE_MACRO_INITIALIZED:
85
+
default:
86
+
type = PTHREAD_MUTEX_NORMAL;
87
+
}
88
+
89
+
pthread_mutexattr_settype(&mta, type);
90
+
91
+
rv = __darwin_pthread_mutex_init(mutex, &mta);
92
+
if (rv)
93
+
return rv;
94
+
}
95
+
96
+
rv = f(&mutex->native, args...);
97
+
if (rv)
98
+
rv = errnoLinuxToDarwin(rv);
99
+
return rv;
100
+
}
101
+
67
102
int __darwin_pthread_rwlockattr_setpshared(pthread_rwlockattr_t* attr, int pshared)
68
103
{
69
104
pshared = TranslatePshared(pshared);
···
123
158
int __darwin_pthread_rwlock_unlock(__darwin_pthread_rwlock_t *rwlock)
124
159
{
125
160
return AutoAllocLockGeneric(pthread_rwlock_unlock, rwlock);
161
+
}
162
+
163
+
int __darwin_pthread_mutex_init(__darwin_pthread_mutex_t* mutex, const pthread_mutexattr_t* attr)
164
+
{
165
+
int rv = pthread_mutex_init(&mutex->native, attr);
166
+
mutex->signature = __darwin_pthread_mutex_t::SIGNATURE_NATIVE_INITIALIZED;
167
+
if (rv)
168
+
rv = errnoLinuxToDarwin(rv);
169
+
return rv;
170
+
}
171
+
172
+
int __darwin_pthread_mutex_destroy(__darwin_pthread_mutex_t* mutex)
173
+
{
174
+
if (mutex->signature == __darwin_pthread_mutex_t::SIGNATURE_NATIVE_INITIALIZED)
175
+
{
176
+
int rv = pthread_mutex_destroy(&mutex->native);
177
+
if (rv)
178
+
rv = errnoLinuxToDarwin(rv);
179
+
return rv;
180
+
}
181
+
return 0;
182
+
}
183
+
184
+
int __darwin_pthread_mutex_lock(__darwin_pthread_mutex_t* mutex)
185
+
{
186
+
return AutoAllocMutexGeneric(pthread_mutex_lock, mutex);
187
+
}
188
+
189
+
int __darwin_pthread_mutex_trylock(__darwin_pthread_mutex_t* mutex)
190
+
{
191
+
return AutoAllocMutexGeneric(pthread_mutex_trylock, mutex);
192
+
}
193
+
194
+
int __darwin_pthread_mutex_unlock(__darwin_pthread_mutex_t* mutex)
195
+
{
196
+
return AutoAllocMutexGeneric(pthread_mutex_unlock, mutex);
126
197
}
127
198
128
199
+13
src/libSystem/libc/pthread.h
+13
src/libSystem/libc/pthread.h
···
15
15
uint32_t signature;
16
16
pthread_rwlock_t native; // this will fit on Linux
17
17
};
18
+
struct __darwin_pthread_mutex_t
19
+
{
20
+
enum { SIGNATURE_MACRO_INITIALIZED = 0x32aaaba7, SIGNATURE_MACRO_INITIALIZED_R = 0x32AAABA2, SIGNATURE_MACRO_INITIALIZED_E = 0x32AAABA1, SIGNATURE_NATIVE_INITIALIZED = 0x12345678 };
21
+
uint32_t signature;
22
+
pthread_mutex_t native; // this will fit on Linux (40 vs 64)
23
+
};
18
24
19
25
extern "C"
20
26
{
···
32
38
int __darwin_pthread_rwlock_wrlock(__darwin_pthread_rwlock_t *rwlock);
33
39
int __darwin_pthread_rwlock_timedrdlock(__darwin_pthread_rwlock_t* rwlock, const struct timespec* abs_timeout);
34
40
int __darwin_pthread_rwlock_unlock(__darwin_pthread_rwlock_t *rwlock);
41
+
42
+
// pthread_mutex
43
+
int __darwin_pthread_mutex_init(__darwin_pthread_mutex_t*, const pthread_mutexattr_t* attr);
44
+
int __darwin_pthread_mutex_destroy(__darwin_pthread_mutex_t* mutex);
45
+
int __darwin_pthread_mutex_lock(__darwin_pthread_mutex_t* mutex);
46
+
int __darwin_pthread_mutex_trylock(__darwin_pthread_mutex_t* mutex);
47
+
int __darwin_pthread_mutex_unlock(__darwin_pthread_mutex_t* mutex);
35
48
36
49
// TODO: add other pthread functions for errno translation
37
50
+27
tools/offsetof.sh
+27
tools/offsetof.sh
···
1
+
#!/bin/sh
2
+
3
+
set -e
4
+
5
+
cfile=/tmp/offsetof.$$.c
6
+
include="$1"
7
+
struct="$2"
8
+
member="$3"
9
+
10
+
cat > $cfile <<END
11
+
#include <stdio.h>
12
+
#include <stddef.h>
13
+
#include <$include>
14
+
15
+
int main()
16
+
{
17
+
printf("offsetof($struct, $member)=%d\n", offsetof($struct, $member));
18
+
return 0;
19
+
}
20
+
21
+
END
22
+
23
+
gcc -w $cfile -o $cfile.bin
24
+
$cfile.bin
25
+
26
+
rm $cfile*
27
+