1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "metadata/metadata_builder.h"
17 #include <cstring>
18 #include "securec.h"
19 #include "ast/ast_array_type.h"
20 #include "ast/ast_list_type.h"
21 #include "ast/ast_map_type.h"
22 #include "util/logger.h"
23
24 #define ALIGN8(v) (((v) + 7) & ~7)
25
26 namespace OHOS {
27 namespace Idl {
28 const char* MetadataBuilder::TAG = "MetadataBuilder";
Build()29 std::shared_ptr<MetaComponent> MetadataBuilder::Build()
30 {
31 if (!module_->IsValid()) {
32 Logger::E(TAG, "The module is not validate.");
33 return nullptr;
34 }
35
36 size_ = CalculateMetadataSize();
37 if (size_ > 0) {
38 void* metadata = calloc(size_, 1);
39 if (metadata == nullptr) {
40 Logger::E(TAG, "Out of memory.");
41 return nullptr;
42 }
43 metaComponent_.reset(
44 new(metadata) MetaComponent, [](MetaComponent* p) { free(p); });
45
46 WriteMetadata(reinterpret_cast<uintptr_t>(metadata));
47 } else {
48 return nullptr;
49 }
50
51 return metaComponent_;
52 }
53
CalculateMetadataSize()54 size_t MetadataBuilder::CalculateMetadataSize()
55 {
56 baseAddr_ = 0;
57 CalculateMetaComponent(module_);
58 return baseAddr_;
59 }
60
CalculateMetaComponent(ASTModule * module)61 void MetadataBuilder::CalculateMetaComponent(ASTModule* module)
62 {
63 int namespaceNumber = module->GetNamespaceNumber();
64 int sequenceableNumber = module->GetSequenceableNumber();
65 int interfaceNumber = module->GetInterfaceNumber();
66 int typeNumber = module->GetTypeNumber();
67
68 // begin address
69 baseAddr_ = ALIGN8(baseAddr_);
70 stringPool_.Add(module_->GetName());
71 // namespaces_'s address
72 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaComponent));
73 // sequenceables_'s address
74 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber);
75 // interfaces_'s address
76 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaSequenceable*) * sequenceableNumber);
77 // types_'s address
78 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface*) * interfaceNumber);
79 // stringPool_'s address
80 baseAddr_ = baseAddr_ + sizeof(MetaType*) * typeNumber;
81
82 for (int i = 0; i < namespaceNumber; i++) {
83 CalculateMetaNamespace(module->GetNamespace(i));
84 }
85
86 for (int i = 0; i < sequenceableNumber; i++) {
87 CalculateMetaSequenceable(module->GetSequenceable(i));
88 }
89
90 for (int i = 0; i < interfaceNumber; i++) {
91 CalculateMetaInterface(module->GetInterface(i));
92 }
93
94 const ASTModule::TypeStringMap& types = module_->GetTypes();
95 for (const auto& pair : types) {
96 CalculateMetaType(pair.second);
97 }
98
99 // end address
100 CalculateStringPool();
101 }
102
CalculateMetaNamespace(ASTNamespace * nspace)103 void MetadataBuilder::CalculateMetaNamespace(ASTNamespace* nspace)
104 {
105 int sequenceableNumber = nspace->GetSequenceableNumber();
106 int interfaceNumber = nspace->GetInterfaceNumber();
107 int namespaceNumber = nspace->GetNamespaceNumber();
108
109 // begin address
110 baseAddr_ = ALIGN8(baseAddr_);
111 stringPool_.Add(nspace->GetName());
112 // sequenceables_'s address
113 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace));
114 // interfaces_'s address
115 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * sequenceableNumber);
116 // namespaces_'s address
117 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * interfaceNumber);
118 // end address
119 baseAddr_ = baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber;
120
121 for (int i = 0; i < namespaceNumber; i++) {
122 CalculateMetaNamespace(nspace->GetNamespace(i));
123 }
124 }
125
CalculateMetaSequenceable(ASTSequenceableType * sequenceable)126 void MetadataBuilder::CalculateMetaSequenceable(ASTSequenceableType* sequenceable)
127 {
128 // begin address
129 baseAddr_ = ALIGN8(baseAddr_);
130 stringPool_.Add(sequenceable->GetName());
131 stringPool_.Add(sequenceable->GetNamespace()->ToString());
132 // end address
133 baseAddr_ = baseAddr_ + sizeof(MetaSequenceable);
134 }
135
CalculateMetaInterface(ASTInterfaceType * interface)136 void MetadataBuilder::CalculateMetaInterface(ASTInterfaceType* interface)
137 {
138 int methodNumber = interface->GetMethodNumber();
139
140 // begin address
141 baseAddr_ = ALIGN8(baseAddr_);
142 stringPool_.Add(interface->GetLicense());
143 stringPool_.Add(interface->GetName());
144 stringPool_.Add(interface->GetNamespace()->ToString());
145 // methods_'s address
146 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface));
147 // end address
148 baseAddr_ = baseAddr_ + sizeof(MetaMethod*) * methodNumber;
149
150 for (int i = 0; i < methodNumber; i++) {
151 CalculateMetaMethod(interface->GetMethod(i));
152 }
153 }
154
CalculateMetaMethod(ASTMethod * method)155 void MetadataBuilder::CalculateMetaMethod(ASTMethod* method)
156 {
157 int parameterNumber = method->GetParameterNumber();
158
159 // begin address
160 baseAddr_ = ALIGN8(baseAddr_);
161 stringPool_.Add(method->GetName());
162 stringPool_.Add(method->GetSignature());
163 // parameters_'s address
164 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaMethod));
165 // end address
166 baseAddr_ = baseAddr_ + sizeof(MetaParameter*) * parameterNumber;
167
168 for (int i = 0; i < parameterNumber; i++) {
169 CalculateMetaParameter(method->GetParameter(i));
170 }
171 }
172
CalculateMetaParameter(ASTParameter * parameter)173 void MetadataBuilder::CalculateMetaParameter(ASTParameter* parameter)
174 {
175 // begin address
176 baseAddr_ = ALIGN8(baseAddr_);
177 stringPool_.Add(parameter->GetName());
178 // end address
179 baseAddr_ = baseAddr_ + sizeof(MetaParameter);
180 }
181
CalculateMetaType(ASTType * type)182 void MetadataBuilder::CalculateMetaType(ASTType* type)
183 {
184 // begin address
185 baseAddr_ = ALIGN8(baseAddr_);
186 // nestedTypeIndexes_'s address
187 baseAddr_ = baseAddr_ + sizeof(MetaType);
188 if (type->IsListType()) {
189 baseAddr_ = ALIGN8(baseAddr_);
190 // end address
191 baseAddr_ = baseAddr_ + sizeof(int*);
192 } else if (type->IsMapType()) {
193 // end address
194 int typeNumber = 2;
195 baseAddr_ = baseAddr_ + sizeof(int*) * typeNumber;
196 } else if (type->IsArrayType()) {
197 baseAddr_ = baseAddr_ + sizeof(int*);
198 }
199 }
200
CalculateStringPool()201 void MetadataBuilder::CalculateStringPool()
202 {
203 // begin address
204 baseAddr_ = ALIGN8(baseAddr_);
205 // end address
206 baseAddr_ = baseAddr_ + stringPool_.GetSize();
207 }
208
WriteMetadata(uintptr_t base)209 void MetadataBuilder::WriteMetadata(uintptr_t base)
210 {
211 baseAddr_ = base;
212 WriteMetaComponent(module_);
213 }
214
WriteMetaComponent(ASTModule * module)215 void MetadataBuilder::WriteMetaComponent(ASTModule* module)
216 {
217 int namespaceNumber = module->GetNamespaceNumber();
218 int sequenceableNumber = module->GetSequenceableNumber();
219 int interfaceNumber = module->GetInterfaceNumber();
220 int typeNumber = module->GetTypeNumber();
221
222 // begin address
223 baseAddr_ = ALIGN8(baseAddr_);
224 MetaComponent* mc = reinterpret_cast<MetaComponent*>(baseAddr_);
225 mc->magic_ = METADATA_MAGIC_NUMBER;
226 mc->size_ = size_;
227 mc->namespaceNumber_ = namespaceNumber;
228 mc->sequenceableNumber_ = sequenceableNumber;
229 mc->interfaceNumber_ = interfaceNumber;
230 mc->typeNumber_ = typeNumber;
231 mc->stringPoolSize_ = stringPool_.GetSize();
232 // namespaces_'s address
233 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaComponent));
234 mc->namespaces_ = reinterpret_cast<MetaNamespace**>(baseAddr_);
235 // sequenceables_'s address
236 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber);
237 mc->sequenceables_ = reinterpret_cast<MetaSequenceable**>(baseAddr_);
238 // interfaces_'s address
239 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaSequenceable*) * sequenceableNumber);
240 mc->interfaces_ = reinterpret_cast<MetaInterface**>(baseAddr_);
241 // types_'s address
242 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface*) * interfaceNumber);
243 mc->types_ = reinterpret_cast<MetaType**>(baseAddr_);
244 // stringPool_'s address
245 baseAddr_ = baseAddr_ + sizeof(MetaType*) * typeNumber;
246 mc->stringPool_ = reinterpret_cast<char*>(baseAddr_);
247 // end address
248 baseAddr_ = baseAddr_ + stringPool_.GetSize();
249 (void)memcpy_s(mc->stringPool_, stringPool_.GetSize(), stringPool_.GetData(), stringPool_.GetSize());
250
251 mc->name_ = WriteString(module->GetName());
252
253 for (int i = 0; i < namespaceNumber; i++) {
254 mc->namespaces_[i] = WriteMetaNamespace(module->GetNamespace(i));
255 }
256
257 for (int i = 0; i < sequenceableNumber; i++) {
258 mc->sequenceables_[i] = WriteMetaSequenceable(module->GetSequenceable(i));
259 }
260
261 for (int i = 0; i < interfaceNumber; i++) {
262 mc->interfaces_[i] = WriteMetaInterface(module->GetInterface(i));
263 }
264
265 const ASTModule::TypeStringMap& types = module->GetTypes();
266 int i = 0;
267 for (const auto& pair : types) {
268 mc->types_[i++] = WriteMetaType(pair.second);
269 }
270 }
271
WriteMetaNamespace(ASTNamespace * nspace)272 MetaNamespace* MetadataBuilder::WriteMetaNamespace(ASTNamespace* nspace)
273 {
274 int sequenceableNumber = nspace->GetSequenceableNumber();
275 int interfaceNumber = nspace->GetInterfaceNumber();
276 int namespaceNumber = nspace->GetNamespaceNumber();
277
278 // begin address
279 baseAddr_ = ALIGN8(baseAddr_);
280 MetaNamespace* mn = reinterpret_cast<MetaNamespace*>(baseAddr_);
281 mn->name_ = WriteString(nspace->GetName());
282 mn->sequenceableNumber_ = sequenceableNumber;
283 mn->interfaceNumber_ = interfaceNumber;
284 mn->namespaceNumber_ = namespaceNumber;
285 // sequenceables_'s address
286 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace));
287 mn->sequenceableIndexes_ = reinterpret_cast<int*>(baseAddr_);
288 // interfaces_'s address
289 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * sequenceableNumber);
290 mn->interfaceIndexes_ = reinterpret_cast<int*>(baseAddr_);
291 // namespaces_'s address
292 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * interfaceNumber);
293 mn->namespaces_ = reinterpret_cast<MetaNamespace**>(baseAddr_);
294 // end address
295 baseAddr_ = baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber;
296
297 for (int i = 0; i < sequenceableNumber; i++) {
298 AutoPtr<ASTSequenceableType> sequenceable = nspace->GetSequenceable(i);
299 mn->sequenceableIndexes_[i] = module_->IndexOf(sequenceable);
300 }
301
302 for (int i = 0; i < interfaceNumber; i++) {
303 AutoPtr<ASTInterfaceType> interface = nspace->GetInterface(i);
304 mn->interfaceIndexes_[i] = module_->IndexOf(interface);
305 }
306
307 for (int i = 0; i < namespaceNumber; i++) {
308 AutoPtr<ASTNamespace> inner = nspace->GetNamespace(i);
309 mn->namespaces_[i] = WriteMetaNamespace(inner);
310 }
311
312 return mn;
313 }
314
WriteMetaSequenceable(ASTSequenceableType * parcelabe)315 MetaSequenceable* MetadataBuilder::WriteMetaSequenceable(ASTSequenceableType* parcelabe)
316 {
317 // begin address
318 baseAddr_ = ALIGN8(baseAddr_);
319 MetaSequenceable* mp = reinterpret_cast<MetaSequenceable*>(baseAddr_);
320 mp->name_ = WriteString(parcelabe->GetName());
321 mp->namespace_ = WriteString(parcelabe->GetNamespace()->ToString());
322 // end address
323 baseAddr_ = baseAddr_ + sizeof(MetaSequenceable);
324
325 return mp;
326 }
327
WriteMetaInterface(ASTInterfaceType * interface)328 MetaInterface* MetadataBuilder::WriteMetaInterface(ASTInterfaceType* interface)
329 {
330 int methodNumber = interface->GetMethodNumber();
331
332 // begin address
333 baseAddr_ = ALIGN8(baseAddr_);
334 MetaInterface* mi = reinterpret_cast<MetaInterface*>(baseAddr_);
335 mi->license_ = WriteString(interface->GetLicense());
336 mi->name_ = WriteString(interface->GetName());
337 mi->namespace_ = WriteString(interface->GetNamespace()->ToString());
338 mi->properties_ = interface->IsOneway() ? INTERFACE_PROPERTY_ONEWAY : 0;
339 mi->methodNumber_ = methodNumber;
340 mi->external_ = interface->IsExternal();
341 // methods_'s address
342 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface));
343 mi->methods_ = reinterpret_cast<MetaMethod**>(baseAddr_);
344 // end address
345 baseAddr_ = baseAddr_ + sizeof(MetaMethod*) * methodNumber;
346
347 for (int i = 0; i < methodNumber; i++) {
348 mi->methods_[i] = WriteMetaMethod(interface->GetMethod(i));
349 }
350
351 return mi;
352 }
353
WriteMetaMethod(ASTMethod * method)354 MetaMethod* MetadataBuilder::WriteMetaMethod(ASTMethod* method)
355 {
356 int parameterNumber = method->GetParameterNumber();
357
358 // begin address
359 baseAddr_ = ALIGN8(baseAddr_);
360 MetaMethod* mm = reinterpret_cast<MetaMethod*>(baseAddr_);
361 mm->name_ = WriteString(method->GetName());
362 mm->signature_ = WriteString(method->GetSignature());
363 mm->properties_ = method->IsOneway() ? METHOD_PROPERTY_ONEWAY : 0;
364 mm->returnTypeIndex_ = module_->IndexOf(method->GetReturnType());
365 mm->parameterNumber_ = parameterNumber;
366 // parameters_'s address
367 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaMethod));
368 mm->parameters_ = reinterpret_cast<MetaParameter**>(baseAddr_);
369 // end address
370 baseAddr_ = baseAddr_ + sizeof(MetaParameter*) * parameterNumber;
371
372 for (int i = 0; i < parameterNumber; i++) {
373 mm->parameters_[i] = WriteMetaParameter(method->GetParameter(i));
374 }
375
376 return mm;
377 }
378
WriteMetaParameter(ASTParameter * parameter)379 MetaParameter* MetadataBuilder::WriteMetaParameter(ASTParameter* parameter)
380 {
381 // begin address
382 baseAddr_ = ALIGN8(baseAddr_);
383 MetaParameter* mp = reinterpret_cast<MetaParameter*>(baseAddr_);
384 mp->name_ = WriteString(parameter->GetName());
385 if (parameter->IsInParameter()) {
386 mp->attributes_ |= ATTR_IN;
387 }
388 if (parameter->IsOutParameter()) {
389 mp->attributes_ |= ATTR_OUT;
390 }
391 mp->typeIndex_ = module_->IndexOf(parameter->GetType());
392 // end address
393 baseAddr_ = baseAddr_ + sizeof(MetaParameter);
394
395 return mp;
396 }
397
WriteMetaType(ASTType * type)398 MetaType* MetadataBuilder::WriteMetaType(ASTType* type)
399 {
400 // begin address
401 baseAddr_ = ALIGN8(baseAddr_);
402 MetaType* mt = reinterpret_cast<MetaType*>(baseAddr_);
403 mt->kind_ = Type2Kind(type);
404 if (type->IsSequenceableType()) {
405 mt->index_ = module_->IndexOf(static_cast<ASTSequenceableType*>(type));
406 } else if (type->IsInterfaceType()) {
407 mt->index_ = module_->IndexOf(static_cast<ASTInterfaceType*>(type));
408 } else {
409 mt->index_ = module_->IndexOf(type);
410 }
411 baseAddr_ = baseAddr_ + sizeof(MetaType);
412 if (type->IsListType()) {
413 mt->nestedTypeNumber_ = 1;
414 // nestedTypeIndexes_'s address
415 baseAddr_ = ALIGN8(baseAddr_);
416 mt->nestedTypeIndexes_ = reinterpret_cast<int*>(baseAddr_);
417 AutoPtr<ASTType> elementType = (static_cast<ASTListType*>(type))->GetElementType();
418 mt->nestedTypeIndexes_[0] = module_->IndexOf(elementType);
419 // end address
420 baseAddr_ = baseAddr_ + sizeof(int*);
421 } else if (type->IsMapType()) {
422 int typeNumber = 2;
423 mt->nestedTypeNumber_ = typeNumber;
424 // nestedTypeIndexes_'s address
425 baseAddr_ = ALIGN8(baseAddr_);
426 mt->nestedTypeIndexes_ = reinterpret_cast<int*>(baseAddr_);
427 AutoPtr<ASTType> keyType = (static_cast<ASTMapType*>(type))->GetKeyType();
428 AutoPtr<ASTType> valueType = (static_cast<ASTMapType*>(type))->GetValueType();
429 mt->nestedTypeIndexes_[0] = module_->IndexOf(keyType);
430 mt->nestedTypeIndexes_[1] = module_->IndexOf(valueType);
431 // end address
432 baseAddr_ = baseAddr_ + sizeof(int*) * typeNumber;
433 } else if (type->IsArrayType()) {
434 mt->nestedTypeNumber_ = 1;
435 // nestedTypeIndexes_'s address
436 baseAddr_ = ALIGN8(baseAddr_);
437 mt->nestedTypeIndexes_ = reinterpret_cast<int*>(baseAddr_);
438 AutoPtr<ASTType> elementType = (static_cast<ASTArrayType*>(type))->GetElementType();
439 mt->nestedTypeIndexes_[0] = module_->IndexOf(elementType);
440 // end address
441 baseAddr_ = baseAddr_ + sizeof(int*);
442 }
443
444 return mt;
445 }
446
WriteString(const String & string)447 char* MetadataBuilder::WriteString(const String& string)
448 {
449 return string.IsNull() ? nullptr : metaComponent_->stringPool_ + stringPool_.GetOffset(string);
450 }
451
Type2Kind(ASTType * type)452 TypeKind MetadataBuilder::Type2Kind(ASTType* type)
453 {
454 if (type->IsCharType()) {
455 return TypeKind::Char;
456 } else if (type->IsBooleanType()) {
457 return TypeKind::Boolean;
458 } else if (type->IsByteType()) {
459 return TypeKind::Byte;
460 } else if (type->IsShortType()) {
461 return TypeKind::Short;
462 } else if (type->IsIntegerType()) {
463 return TypeKind::Integer;
464 } else if (type->IsLongType()) {
465 return TypeKind::Long;
466 } else if (type->IsFloatType()) {
467 return TypeKind::Float;
468 } else if (type->IsDoubleType()) {
469 return TypeKind::Double;
470 } else if (type->IsStringType()) {
471 return TypeKind::String;
472 } else if (type->IsVoidType()) {
473 return TypeKind::Void;
474 } else if (type->IsSequenceableType()) {
475 return TypeKind::Sequenceable;
476 } else if (type->IsInterfaceType()) {
477 return TypeKind::Interface;
478 } else if (type->IsListType()) {
479 return TypeKind::List;
480 } else if (type->IsMapType()) {
481 return TypeKind::Map;
482 } else if (type->IsArrayType()) {
483 return TypeKind::Array;
484 }
485 return TypeKind::Unknown;
486 }
487 } // namespace Idl
488 } // namespace OHOS
489