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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
from dataclasses import dataclass, field
from ..builder import AsyncBuilder
from .. import util
from .symbol import *
@dataclass(eq=False)
class ArbitraryData(Symbol):
data: bytes = field(default=None, repr=False)
padding_data: bytes = field(default=None, repr=False)
zero_length: bool = False
always_extern: bool = False
@property
def has_body(self):
return not self.zero_length
@property
def is_static(self):
if self.always_extern:
return False
s = self.reference_count.static
e = self.reference_count.extern
r = self.reference_count.rel
static_by_references = (s >= 0 and e == 0 and r == 0)
static_by_literal = self.identifier.label.startswith("lit_")
return static_by_references or static_by_literal
@property
def requires_force_active(self):
return self.is_static and self.reference_count.total == 0
@property
def export_as_static(self):
if self.always_extern:
return False
return True
@property
def is_class_symbol(self):
# @!game
# don't generate static class variables for 'cNullVec__6Z2Calc', because it will not compile.
# Z2Calc::cNullVec seems to be static data that is initialized in the class definition, thus,
# every translation unit which uses Z2Calc will have a copy of the Z2Calc::cNullVec in the data
# section. Could not find a way to make this compile without easily.
if self.identifier.name == "cNullVec__6Z2Calc":
return False
return self.demangled_name and self.has_class and not self.has_template
@property
def element_size(self):
return 1
@property
def total_element_count(self):
total = (self.size // self.element_size) + \
(self.padding // self.element_size)
return total
def element_type(self):
type = self.data_type
if self._section == ".rodata":
type = ConstType(type)
if self._section == ".extabindex":
type = ConstType(type)
if self._section == ".extab":
type = ConstType(type)
if self._section.startswith(".ctors"):
type = ConstType(type)
if self._section.startswith(".dtors"):
type = ConstType(type)
if self._section.startswith(".init"):
type = ConstType(type)
return type
def array_type(self):
if self.zero_length:
return ZeroArrayType.create(self.element_type())
return PaddingArrayType.create(
self.element_type(),
self.size // self.element_size,
self.padding // self.element_size)
def return_type(self):
array_type = self.array_type()
if isinstance(array_type, ArrayType) or isinstance(array_type, PaddingArrayType) or isinstance(array_type, ZeroArrayType):
return PointerType(array_type.base)
return array_type
def cpp_reference(self, accessor, addr):
name = self.declaration_name(forward=False, c_export=False,full_qualified_name=True)
if addr == self.addr:
return f"&{name}"
else:
offset = addr - self.addr
return f"(((char*)&{name})+0x{offset:X})"
def cpp_load(self, accessor, addr):
name = self.declaration_name(forward=False, c_export=False,full_qualified_name=True)
if addr == self.addr:
return f"{name}"
else:
offset = addr - self.addr
return f"*(((char*)&{name})+0x{offset:X})"
def declaration_name(self, forward: bool,
c_export: bool,
full_qualified_name: bool):
if not self.is_class_symbol or c_export:
return self.identifier.label
if full_qualified_name:
return self.demangled_name.to_str()
else:
return self.demangled_name.last.to_str()
async def export_declaration_header(self, exporter,
builder: AsyncBuilder,
forward: bool,
c_export: bool,
full_qualified_name: bool):
name = self.declaration_name(c_export=c_export,
forward=forward,
full_qualified_name=full_qualified_name)
decl_type = self.array_type()
await builder.write_nonewline(decl_type.decl(name))
async def export_forward_references(self,
exporter,
builder: AsyncBuilder,
c_export: bool = False):
if not c_export:
return
if not self.is_class_symbol:
if self.is_static and self.export_static:
if not self.require_forward_reference:
return
await self.export_section_header(builder)
if not self.is_class_symbol:
if not (self.is_static and self.export_static):
await self.export_extern(builder)
await self.export_declaration_header(exporter, builder,
forward=True,
c_export=c_export,
full_qualified_name=False)
await builder.write(";")
async def export_declaration_head(self, exporter, builder: AsyncBuilder):
name = self.declaration_name(c_export=False,
forward=False,
full_qualified_name=True)
decl_type = self.array_type()
if not self.is_class_symbol:
# for empty symbols that should be exported, we need to double declare it.
# otherwise, the compiler thinks that we're not actual declaring it.
is_extern = not (self.is_static and self.export_as_static)
if not self.data and is_extern:
await self.export_section(builder)
if self.force_section:
await self.export_section_header(builder)
await self.export_extern(builder)
await builder.write_nonewline(decl_type.decl(name))
await builder.write(";")
await self.export_section(builder)
if self.force_section:
await self.export_section_header(builder)
if not self.is_class_symbol:
if not is_extern:
await self.export_static(builder)
elif self.data and is_extern:
await self.export_extern(builder)
await builder.write_nonewline(decl_type.decl(name))
async def export_declaration_body(self, exporter, builder: AsyncBuilder):
if self.data:
assert self.size == len(self.data)
if self.alignment > 0:
await builder.write_nonewline(f" ALIGN_DECL({self.alignment})")
await builder.write(f" = {{")
await self.export_u8_data(builder, self.data)
if self.padding_data:
assert self.padding == len(self.padding_data)
await builder.write("\t/* padding */")
await self.export_u8_data(builder, self.padding_data)
await builder.write("};")
else:
if self.alignment > 0:
await builder.write_nonewline(f" ALIGN_DECL({self.alignment})")
await builder.write(";")
async def export_declaration(self, exporter, builder: AsyncBuilder):
if self.requires_force_active:
await builder.write(f"#pragma push")
await builder.write(f"#pragma force_active on")
await self.export_declaration_head(exporter, builder)
await self.export_declaration_body(exporter, builder)
if self._section == ".rodata":
await builder.write(f"COMPILER_STRIP_GATE(0x{self.addr:08X}, {self.cpp_reference(None, self.addr)});")
if self.requires_force_active:
await builder.write(f"#pragma pop")
@staticmethod
def create_with_data(identifier, addr, data, padding_data):
size = len(data)
padding_size = len(padding_data)
return ArbitraryData(identifier=identifier,
addr=addr,
size=size,
data=data,
data_type=U8,
padding=padding_size,
padding_data=padding_data)
@staticmethod
def create_without_data(identifier, addr, size, padding_size):
return ArbitraryData(identifier=identifier,
addr=addr,
size=size,
data=[],
data_type=U8,
padding=padding_size,
padding_data=[])
|
