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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "jit/mips-shared/Architecture-mips-shared.h"
#include <fcntl.h>
#include <unistd.h>
#include "jit/FlushICache.h" // js::jit::FlushICache
#include "jit/mips32/Simulator-mips32.h"
#include "jit/mips64/Simulator-mips64.h"
#include "jit/RegisterSets.h"
#if defined(__linux__) && !defined(JS_SIMULATOR)
# include <sys/cachectl.h>
#endif
#define HWCAP_MIPS (1 << 28)
#define HWCAP_LOONGSON (1 << 27)
#define HWCAP_R2 (1 << 26)
#define HWCAP_FPU (1 << 0)
namespace js {
namespace jit {
static uint32_t get_mips_flags() {
uint32_t flags = HWCAP_MIPS;
#if defined(JS_SIMULATOR_MIPS32) || defined(JS_SIMULATOR_MIPS64)
flags |= HWCAP_FPU;
flags |= HWCAP_R2;
#else
# ifdef __linux__
FILE* fp = fopen("/proc/cpuinfo", "r");
if (!fp) {
return flags;
}
char buf[1024] = {};
(void)fread(buf, sizeof(char), sizeof(buf) - 1, fp);
fclose(fp);
if (strstr(buf, "FPU")) {
flags |= HWCAP_FPU;
}
if (strstr(buf, "Loongson")) {
flags |= HWCAP_LOONGSON;
}
if (strstr(buf, "mips32r2") || strstr(buf, "mips64r2")) {
flags |= HWCAP_R2;
}
# endif
#endif // JS_SIMULATOR_MIPS32 || JS_SIMULATOR_MIPS64
return flags;
}
static bool check_fpu() { return mips_private::Flags & HWCAP_FPU; }
static bool check_loongson() { return mips_private::Flags & HWCAP_LOONGSON; }
static bool check_r2() { return mips_private::Flags & HWCAP_R2; }
namespace mips_private {
// Cache a local copy so we only have to read /proc/cpuinfo once.
uint32_t Flags = get_mips_flags();
bool hasFPU = check_fpu();
;
bool isLoongson = check_loongson();
bool hasR2 = check_r2();
} // namespace mips_private
bool CPUFlagsHaveBeenComputed() {
// Flags were computed above.
return true;
}
Registers::Code Registers::FromName(const char* name) {
for (size_t i = 0; i < Total; i++) {
if (strcmp(GetName(i), name) == 0) {
return Code(i);
}
}
return Invalid;
}
void FlushICache(void* code, size_t size) {
#if defined(JS_SIMULATOR)
js::jit::SimulatorProcess::FlushICache(code, size);
#elif defined(_MIPS_ARCH_LOONGSON3A)
// On Loongson3-CPUs, The cache flushed automatically
// by hardware. Just need to execute an instruction hazard.
uintptr_t tmp;
asm volatile(
".set push \n"
".set noreorder \n"
"move %[tmp], $ra \n"
"bal 1f \n"
"daddiu $ra, 8 \n"
"1: \n"
"jr.hb $ra \n"
"move $ra, %[tmp] \n"
".set pop\n"
: [tmp] "=&r"(tmp));
#elif defined(__GNUC__)
intptr_t end = reinterpret_cast<intptr_t>(code) + size;
__builtin___clear_cache(reinterpret_cast<char*>(code),
reinterpret_cast<char*>(end));
#else
_flush_cache(reinterpret_cast<char*>(code), size, BCACHE);
#endif
}
} // namespace jit
} // namespace js
|
