1 /*
2 * Copyright 2010-2014, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "slang_rs_reflection.h"
18
19 #include <sys/stat.h>
20
21 #include <cstdarg>
22 #include <cctype>
23
24 #include <algorithm>
25 #include <sstream>
26 #include <string>
27 #include <utility>
28
29 #include "llvm/ADT/APFloat.h"
30 #include "llvm/ADT/StringExtras.h"
31
32 #include "os_sep.h"
33 #include "slang_rs_context.h"
34 #include "slang_rs_export_var.h"
35 #include "slang_rs_export_foreach.h"
36 #include "slang_rs_export_func.h"
37 #include "slang_rs_export_reduce.h"
38 #include "slang_rs_reflect_utils.h"
39 #include "slang_rs_reflection_state.h"
40 #include "slang_version.h"
41
42 #define RS_SCRIPT_CLASS_NAME_PREFIX "ScriptC_"
43 #define RS_SCRIPT_CLASS_SUPER_CLASS_NAME "ScriptC"
44
45 #define RS_TYPE_CLASS_SUPER_CLASS_NAME ".Script.FieldBase"
46
47 #define RS_TYPE_ITEM_CLASS_NAME "Item"
48
49 #define RS_TYPE_ITEM_SIZEOF_LEGACY "Item.sizeof"
50 #define RS_TYPE_ITEM_SIZEOF_CURRENT "mElement.getBytesSize()"
51
52 #define RS_TYPE_ITEM_BUFFER_NAME "mItemArray"
53 #define RS_TYPE_ITEM_BUFFER_PACKER_NAME "mIOBuffer"
54 #define RS_TYPE_ELEMENT_REF_NAME "mElementCache"
55
56 #define RS_EXPORT_VAR_INDEX_PREFIX "mExportVarIdx_"
57 #define RS_EXPORT_VAR_PREFIX "mExportVar_"
58 #define RS_EXPORT_VAR_ELEM_PREFIX "mExportVarElem_"
59 #define RS_EXPORT_VAR_DIM_PREFIX "mExportVarDim_"
60 #define RS_EXPORT_VAR_CONST_PREFIX "const_"
61
62 #define RS_ELEM_PREFIX "__"
63
64 #define RS_FP_PREFIX "__rs_fp_"
65
66 #define RS_RESOURCE_NAME "__rs_resource_name"
67
68 #define RS_EXPORT_FUNC_INDEX_PREFIX "mExportFuncIdx_"
69 #define RS_EXPORT_FOREACH_INDEX_PREFIX "mExportForEachIdx_"
70 #define RS_EXPORT_REDUCE_INDEX_PREFIX "mExportReduceIdx_"
71
72 #define RS_EXPORT_VAR_ALLOCATION_PREFIX "mAlloction_"
73 #define RS_EXPORT_VAR_DATA_STORAGE_PREFIX "mData_"
74
75 #define SAVED_RS_REFERENCE "mRSLocal"
76
77 namespace slang {
78
79 static void genCheck64BitInternal(const RSContext *Context, ReflectionState *State,
80 GeneratedFile &Out, bool Parens);
81
82 class RSReflectionJavaElementBuilder {
83 public:
84 RSReflectionJavaElementBuilder(const char *ElementBuilderName,
85 const RSExportRecordType *ERT,
86 const char *RenderScriptVar,
87 GeneratedFile *Out, const RSContext *RSContext,
88 RSReflectionJava *Reflection,
89 ReflectionState *RState);
90 void generate();
91
92 private:
93 void genAddElement(const RSExportType *ET, const std::string &VarName,
94 unsigned ArraySize);
95 void genAddStatementStart();
96 void genAddStatementEnd(const std::string &VarName, unsigned ArraySize,
97 unsigned Which = RSReflectionJava::FieldIndex | RSReflectionJava::Field32Index);
98 void genAddPadding(int PaddingSize, unsigned Which); // Which: See RSReflectionJava::incFieldIndex()
99 void genAddPadding(int PaddingSize, ReflectionState::Val32 Field32PaddingSize);
100 // TODO Will remove later due to field name information is not necessary for
101 // C-reflect-to-Java
createPaddingField()102 std::string createPaddingField() {
103 return mPaddingPrefix + llvm::itostr(mPaddingFieldIndex++);
104 }
105
genCheck64Bit(bool Parens)106 void genCheck64Bit(bool Parens) {
107 genCheck64BitInternal(mRSContext, mState, *mOut, Parens);
108 }
109
110 const char *mElementBuilderName;
111 const RSExportRecordType *mERT;
112 const char *mRenderScriptVar;
113 GeneratedFile *mOut;
114 std::string mPaddingPrefix;
115 int mPaddingFieldIndex;
116 const RSContext *mRSContext;
117 RSReflectionJava *mReflection;
118 ReflectionState *mState;
119 };
120
121 enum MatrixLanguage { ML_Java, ML_Script };
GetMatrixTypeName(const RSExportMatrixType * EMT,MatrixLanguage lang)122 static const char *GetMatrixTypeName(const RSExportMatrixType *EMT, MatrixLanguage lang) {
123 static const char *MatrixTypeJavaNameMap[3][2] = {/* 2x2 */ { "Matrix2f", "rs_matrix2x2" },
124 /* 3x3 */ { "Matrix3f", "rs_matrix3x3" },
125 /* 4x4 */ { "Matrix4f", "rs_matrix4x4" }
126 };
127 unsigned Dim = EMT->getDim();
128
129 if ((Dim - 2) < (sizeof(MatrixTypeJavaNameMap) / sizeof(const char *)))
130 return MatrixTypeJavaNameMap[EMT->getDim() - 2][lang];
131
132 slangAssert(false && "GetMatrixTypeName : Unsupported matrix dimension");
133 return nullptr;
134 }
135
GetVectorAccessor(unsigned Index)136 static const char *GetVectorAccessor(unsigned Index) {
137 static const char *VectorAccessorMap[] = {/* 0 */ "x",
138 /* 1 */ "y",
139 /* 2 */ "z",
140 /* 3 */ "w",
141 };
142
143 slangAssert((Index < (sizeof(VectorAccessorMap) / sizeof(const char *))) &&
144 "Out-of-bound index to access vector member");
145
146 return VectorAccessorMap[Index];
147 }
148
GetPackerAPIName(const RSExportPrimitiveType * EPT)149 static const char *GetPackerAPIName(const RSExportPrimitiveType *EPT) {
150 static const char *PrimitiveTypePackerAPINameMap[] = {
151 "addI16", // DataTypeFloat16
152 "addF32", // DataTypeFloat32
153 "addF64", // DataTypeFloat64
154 "addI8", // DataTypeSigned8
155 "addI16", // DataTypeSigned16
156 "addI32", // DataTypeSigned32
157 "addI64", // DataTypeSigned64
158 "addU8", // DataTypeUnsigned8
159 "addU16", // DataTypeUnsigned16
160 "addU32", // DataTypeUnsigned32
161 "addU64", // DataTypeUnsigned64
162 "addBoolean", // DataTypeBoolean
163 "addU16", // DataTypeUnsigned565
164 "addU16", // DataTypeUnsigned5551
165 "addU16", // DataTypeUnsigned4444
166 "addMatrix", // DataTypeRSMatrix2x2
167 "addMatrix", // DataTypeRSMatrix3x3
168 "addMatrix", // DataTypeRSMatrix4x4
169 "addObj", // DataTypeRSElement
170 "addObj", // DataTypeRSType
171 "addObj", // DataTypeRSAllocation
172 "addObj", // DataTypeRSSampler
173 "addObj", // DataTypeRSScript
174 "addObj", // DataTypeRSMesh
175 "addObj", // DataTypeRSPath
176 "addObj", // DataTypeRSProgramFragment
177 "addObj", // DataTypeRSProgramVertex
178 "addObj", // DataTypeRSProgramRaster
179 "addObj", // DataTypeRSProgramStore
180 "addObj", // DataTypeRSFont
181 };
182 unsigned TypeId = EPT->getType();
183
184 if (TypeId < (sizeof(PrimitiveTypePackerAPINameMap) / sizeof(const char *)))
185 return PrimitiveTypePackerAPINameMap[EPT->getType()];
186
187 slangAssert(false && "GetPackerAPIName : Unknown primitive data type");
188 return nullptr;
189 }
190
191 namespace {
192
GetReduceResultTypeName(const RSExportType * ET)193 std::string GetReduceResultTypeName(const RSExportType *ET) {
194 switch (ET->getClass()) {
195 case RSExportType::ExportClassConstantArray: {
196 const RSExportConstantArrayType *const CAT = static_cast<const RSExportConstantArrayType *>(ET);
197 return "resultArray" + std::to_string(CAT->getNumElement()) + "_" +
198 RSReflectionJava::GetTypeName(
199 CAT->getElementType(),
200 (RSReflectionJava::TypeNameDefault & ~RSReflectionJava::TypeNameWithRecordElementName) |
201 RSReflectionJava::TypeNameC);
202 }
203 case RSExportType::ExportClassRecord:
204 return "resultStruct_" +
205 RSReflectionJava::GetTypeName(
206 ET,
207 (RSReflectionJava::TypeNameDefault & ~RSReflectionJava::TypeNameWithRecordElementName) |
208 RSReflectionJava::TypeNameC);
209 default:
210 return "result_" +
211 RSReflectionJava::GetTypeName(ET, RSReflectionJava::TypeNameDefault | RSReflectionJava::TypeNameC);
212 }
213 }
214
GetReduceResultTypeName(const RSExportReduce * ER)215 std::string GetReduceResultTypeName(const RSExportReduce *ER) {
216 return GetReduceResultTypeName(ER->getResultType());
217 }
218
219 } // end anonymous namespace
220
GetTypeNullValue(const RSExportType * ET)221 static const char *GetTypeNullValue(const RSExportType *ET) {
222 switch (ET->getClass()) {
223 case RSExportType::ExportClassPrimitive: {
224 const RSExportPrimitiveType *EPT =
225 static_cast<const RSExportPrimitiveType *>(ET);
226 if (EPT->isRSObjectType())
227 return "null";
228 else if (EPT->getType() == DataTypeBoolean)
229 return "false";
230 else
231 return "0";
232 break;
233 }
234 case RSExportType::ExportClassPointer:
235 case RSExportType::ExportClassVector:
236 case RSExportType::ExportClassMatrix:
237 case RSExportType::ExportClassConstantArray:
238 case RSExportType::ExportClassRecord: {
239 return "null";
240 break;
241 }
242 default: { slangAssert(false && "Unknown class of type"); }
243 }
244 return "";
245 }
246
GetBuiltinElementConstruct(const RSExportType * ET)247 static std::string GetBuiltinElementConstruct(const RSExportType *ET) {
248 if (ET->getClass() == RSExportType::ExportClassPrimitive) {
249 return std::string("Element.") + ET->getElementName();
250 } else if (ET->getClass() == RSExportType::ExportClassVector) {
251 const RSExportVectorType *EVT = static_cast<const RSExportVectorType *>(ET);
252 if (EVT->getType() == DataTypeFloat32) {
253 if (EVT->getNumElement() == 2) {
254 return "Element.F32_2";
255 } else if (EVT->getNumElement() == 3) {
256 return "Element.F32_3";
257 } else if (EVT->getNumElement() == 4) {
258 return "Element.F32_4";
259 } else {
260 slangAssert(false && "Vectors should be size 2, 3, 4");
261 }
262 } else if (EVT->getType() == DataTypeUnsigned8) {
263 if (EVT->getNumElement() == 4)
264 return "Element.U8_4";
265 }
266 } else if (ET->getClass() == RSExportType::ExportClassMatrix) {
267 const RSExportMatrixType *EMT = static_cast<const RSExportMatrixType *>(ET);
268 switch (EMT->getDim()) {
269 case 2:
270 return "Element.MATRIX_2X2";
271 case 3:
272 return "Element.MATRIX_3X3";
273 case 4:
274 return "Element.MATRIX_4X4";
275 default:
276 slangAssert(false && "Unsupported dimension of matrix");
277 }
278 }
279 // RSExportType::ExportClassPointer can't be generated in a struct.
280
281 return "";
282 }
283
284 // If FromIntegerType == DestIntegerType, then Value is returned.
285 // Otherwise, return a Java expression that zero-extends the value
286 // Value, assumed to be of type FromIntegerType, to the integer type
287 // DestIntegerType.
288 //
289 // Intended operations:
290 // byte -> {byte,int,short,long}
291 // short -> {short,int,long}
292 // int -> {int,long}
293 // long -> long
ZeroExtendValue(const std::string & Value,const std::string & FromIntegerType,const std::string & DestIntegerType)294 static std::string ZeroExtendValue(const std::string &Value,
295 const std::string &FromIntegerType,
296 const std::string &DestIntegerType) {
297 #ifndef __DISABLE_ASSERTS
298 // Integer types arranged in increasing order by width
299 const std::vector<std::string> ValidTypes{"byte", "short", "int", "long"};
300 auto FromTypeLoc = std::find(ValidTypes.begin(), ValidTypes.end(), FromIntegerType);
301 auto DestTypeLoc = std::find(ValidTypes.begin(), ValidTypes.end(), DestIntegerType);
302 // Check that both types are valid.
303 slangAssert(FromTypeLoc != ValidTypes.end());
304 slangAssert(DestTypeLoc != ValidTypes.end());
305 // Check that DestIntegerType is at least as wide as FromIntegerType.
306 slangAssert(FromTypeLoc - ValidTypes.begin() <= DestTypeLoc - ValidTypes.begin());
307 #endif
308
309 if (FromIntegerType == DestIntegerType) {
310 return Value;
311 }
312
313 std::string Mask, MaskLiteralType;
314 if (FromIntegerType == "byte") {
315 Mask = "0xff";
316 MaskLiteralType = "int";
317 } else if (FromIntegerType == "short") {
318 Mask = "0xffff";
319 MaskLiteralType = "int";
320 } else if (FromIntegerType == "int") {
321 Mask = "0xffffffffL";
322 MaskLiteralType = "long";
323 } else {
324 // long -> long casts should have already been handled.
325 slangAssert(false && "Unknown integer type");
326 }
327
328 // Cast the mask to the appropriate type.
329 if (MaskLiteralType != DestIntegerType) {
330 Mask = "(" + DestIntegerType + ") " + Mask;
331 }
332 return "((" + DestIntegerType + ") ((" + Value + ") & " + Mask + "))";
333 }
334
GetTypeName(const RSExportType * ET,unsigned Style)335 std::string RSReflectionJava::GetTypeName(const RSExportType *ET, unsigned Style) {
336 slangAssert((Style & (TypeNameC|TypeNamePseudoC)) != (TypeNameC|TypeNamePseudoC));
337 slangAssert(!(Style & TypeNamePseudoC) || (Style == TypeNamePseudoC));
338
339 const bool CLike = Style & (TypeNameC|TypeNamePseudoC);
340
341 switch (ET->getClass()) {
342 case RSExportType::ExportClassPrimitive: {
343 const auto ReflectionType =
344 RSExportPrimitiveType::getRSReflectionType(static_cast<const RSExportPrimitiveType *>(ET));
345 return (CLike ? ReflectionType->s_name : ReflectionType->java_name);
346 }
347 case RSExportType::ExportClassPointer: {
348 slangAssert(!(Style & TypeNameC) &&
349 "No need to support C type names for pointer types yet");
350 const RSExportType *PointeeType =
351 static_cast<const RSExportPointerType *>(ET)->getPointeeType();
352
353 if (Style & TypeNamePseudoC)
354 return GetTypeName(PointeeType, Style) + "*";
355 else if (PointeeType->getClass() != RSExportType::ExportClassRecord)
356 return "Allocation";
357 else
358 return PointeeType->getElementName();
359 }
360 case RSExportType::ExportClassVector: {
361 const RSExportVectorType *EVT = static_cast<const RSExportVectorType *>(ET);
362 const auto ReflectionType = EVT->getRSReflectionType(EVT);
363 std::stringstream VecName;
364 VecName << (CLike ? ReflectionType->s_name : ReflectionType->rs_java_vector_prefix)
365 << EVT->getNumElement();
366 return VecName.str();
367 }
368 case RSExportType::ExportClassMatrix: {
369 return GetMatrixTypeName(static_cast<const RSExportMatrixType *>(ET), CLike ? ML_Script : ML_Java);
370 }
371 case RSExportType::ExportClassConstantArray: {
372 const RSExportConstantArrayType *CAT =
373 static_cast<const RSExportConstantArrayType *>(ET);
374 std::string ElementTypeName = GetTypeName(CAT->getElementType(), Style);
375 if (Style & TypeNamePseudoC) {
376 std::stringstream ArrayName;
377 ArrayName << ElementTypeName << '[' << CAT->getNumElement() << ']';
378 return ArrayName.str();
379 }
380 else if (Style & TypeNameWithConstantArrayBrackets) {
381 slangAssert(!(Style & TypeNameC) &&
382 "No need to support C type names for array types with brackets yet");
383 ElementTypeName.append("[]");
384 }
385 return ElementTypeName;
386 }
387 case RSExportType::ExportClassRecord: {
388 slangAssert(!(Style & TypeNameC) &&
389 "No need to support C type names for record types yet");
390 if (Style & TypeNamePseudoC)
391 return "struct " + ET->getName();
392 else if (Style & TypeNameWithRecordElementName)
393 return ET->getElementName() + "." RS_TYPE_ITEM_CLASS_NAME;
394 else
395 return ET->getName();
396 }
397 default: { slangAssert(false && "Unknown class of type"); }
398 }
399
400 return "";
401 }
402
genConditionalVal(const std::string & Prefix,bool Parens,size_t Val,ReflectionState::Val32 Val32)403 void RSReflectionJava::genConditionalVal(const std::string &Prefix, bool Parens,
404 size_t Val, ReflectionState::Val32 Val32) {
405 if (Prefix.empty() || (Val != 0) || (Val32.first && (Val32.second != 0 ))) {
406 mOut << Prefix;
407
408 if (!Val32.first || (Val == Val32.second)) {
409 // Either we're ignoring the 32-bit case, or 32-bit and 64-bit
410 // values are the same.
411 mOut << Val;
412 } else {
413 // We cannot ignore the 32-bit case, and 32-bit and 64-bit
414 // values differ.
415 if (Parens)
416 mOut << '(';
417 genCheck64Bit(true);
418 mOut << " ? " << Val << " : " << Val32.second;
419 if (Parens)
420 mOut << ')';
421 }
422 }
423 }
424
genCheck64BitInternal(const RSContext * Context,ReflectionState * State,GeneratedFile & Out,bool Parens)425 static void genCheck64BitInternal(const RSContext *Context, ReflectionState *State,
426 GeneratedFile &Out, bool Parens) {
427 State->setOutputClassDivergent();
428 if (Context->isCompatLib()) {
429 if (Parens)
430 Out << '(';
431 Out << "RenderScript.getPointerSize() == 8";
432 if (Parens)
433 Out << ')';
434 }
435 else
436 Out << "sIs64Bit";
437 }
438
genCheck64Bit(bool Parens)439 void RSReflectionJava::genCheck64Bit(bool Parens) {
440 genCheck64BitInternal(mRSContext, mState, mOut, Parens);
441 }
442
genCompute64Bit()443 void RSReflectionJava::genCompute64Bit() {
444 if (mRSContext->isCompatLib()) {
445 // We can rely on RenderScript class in lockstep with llvm-rs-cc
446 // and hence in lockstep with the generated code, so we don't need
447 // any complicated logic to determine pointer size.
448 return;
449 }
450
451 // Note that Android L is the first release to support 64-bit
452 // targets. When RenderScript is compiled with "-target-api $v"
453 // with "$v < 21" (L is API level 21), we only compile for 32-bit,
454 // and we reflect during that compile, so there are no divergent
455 // structs, and we will not get here.
456
457 slangAssert(mRSContext->getTargetAPI() >= SLANG_L_TARGET_API);
458
459 mOut.indent() << "private static boolean sIs64Bit;\n\n";
460 mOut.indent() << "static";
461 mOut.startBlock();
462 mOut.indent() << "if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)";
463 mOut.startBlock();
464 mOut.indent() << "sIs64Bit = Process.is64Bit();\n";
465 mOut.endBlock();
466 mOut.indent() << "else";
467 mOut.startBlock();
468 mOut.indent() << "try";
469 mOut.startBlock();
470 mOut.indent() << "Field f = RenderScript.class.getDeclaredField(\"sPointerSize\");\n";
471 mOut.indent() << "f.setAccessible(true);\n";
472 mOut.indent() << "sIs64Bit = (f.getInt(null) == 8);\n";
473 mOut.endBlock();
474
475 // If reflection fails, assume we're on a 32-bit-only device
476 // (64-bit-only is not allowed). This should only happen if the
477 // device is L-or-later but has been customized in some way so that
478 // the field "sPointerSize" -- introduced in L -- is not present.
479 //
480 // Alternatively, we could treat this as 64-bit (reverting to the
481 // behavior prior to the fix for http://b/32780232) or we could
482 // decide we have no idea what's going on and throw an exception.
483 mOut.indent() << "catch (Throwable e)";
484 mOut.startBlock();
485 mOut.indent() << "sIs64Bit = false;\n";
486 mOut.endBlock();
487
488 mOut.endBlock();
489 mOut.endBlock();
490 }
491
492 /********************** Methods to generate script class **********************/
RSReflectionJava(const RSContext * Context,std::vector<std::string> * GeneratedFileNames,const std::string & OutputBaseDirectory,const std::string & RSSourceFileName,const std::string & BitCodeFileName,bool EmbedBitcodeInJava,ReflectionState * RState)493 RSReflectionJava::RSReflectionJava(const RSContext *Context,
494 std::vector<std::string> *GeneratedFileNames,
495 const std::string &OutputBaseDirectory,
496 const std::string &RSSourceFileName,
497 const std::string &BitCodeFileName,
498 bool EmbedBitcodeInJava,
499 ReflectionState *RState)
500 : mRSContext(Context), mState(RState), mCollecting(RState->isCollecting()),
501 mPackageName(Context->getReflectJavaPackageName()),
502 mRSPackageName(Context->getRSPackageName()),
503 mOutputBaseDirectory(OutputBaseDirectory),
504 mRSSourceFileName(RSSourceFileName), mBitCodeFileName(BitCodeFileName),
505 mResourceId(RSSlangReflectUtils::JavaClassNameFromRSFileName(
506 mBitCodeFileName.c_str())),
507 mScriptClassName(RS_SCRIPT_CLASS_NAME_PREFIX +
508 RSSlangReflectUtils::JavaClassNameFromRSFileName(
509 mRSSourceFileName.c_str())),
510 mEmbedBitcodeInJava(EmbedBitcodeInJava), mNextExportVarSlot(0),
511 mNextExportFuncSlot(0), mNextExportForEachSlot(0),
512 mNextExportReduceSlot(0), mLastError(""),
513 mGeneratedFileNames(GeneratedFileNames), mFieldIndex(0), mField32Index(0) {
514 slangAssert(mGeneratedFileNames && "Must supply GeneratedFileNames");
515 slangAssert(!mPackageName.empty() && mPackageName != "-");
516
517 mOutputDirectory = RSSlangReflectUtils::ComputePackagedPath(
518 OutputBaseDirectory.c_str(), mPackageName.c_str()) +
519 OS_PATH_SEPARATOR_STR;
520
521 // mElement.getBytesSize only exists on JB+
522 if (mRSContext->getTargetAPI() >= SLANG_JB_TARGET_API) {
523 mItemSizeof = RS_TYPE_ITEM_SIZEOF_CURRENT;
524 } else {
525 mItemSizeof = RS_TYPE_ITEM_SIZEOF_LEGACY;
526 }
527
528 mState->nextFile(mRSContext, mPackageName, mRSSourceFileName);
529 }
530
genScriptClass(const std::string & ClassName,std::string & ErrorMsg)531 bool RSReflectionJava::genScriptClass(const std::string &ClassName,
532 std::string &ErrorMsg) {
533 if (!mCollecting) {
534 if (!startClass(AM_Public, false, ClassName, RS_SCRIPT_CLASS_SUPER_CLASS_NAME,
535 ErrorMsg))
536 return false;
537
538 mState->beginOutputClass();
539 genScriptClassConstructor();
540 }
541
542 // Reflect exported variables
543 mState->beginVariables(mRSContext->export_vars_size());
544 for (auto I = mRSContext->export_vars_begin(),
545 E = mRSContext->export_vars_end();
546 I != E; I++)
547 genExportVariable(*I);
548 mState->endVariables();
549
550 // Reflect exported forEach functions (only available on ICS+)
551 if (mRSContext->getTargetAPI() >= SLANG_ICS_TARGET_API) {
552 mState->beginForEaches(mRSContext->getNumAssignedForEachOrdinals());
553 for (auto I = mRSContext->export_foreach_begin(),
554 E = mRSContext->export_foreach_end();
555 I != E; I++) {
556 genExportForEach(*I);
557 }
558 mState->endForEaches();
559 }
560
561 // Reflect exported reduce functions
562 if (!mCollecting) {
563 for (const RSExportType *ResultType : mRSContext->getReduceResultTypes(
564 // FilterIn
565 exportableReduce,
566
567 // Compare
568 [](const RSExportType *A, const RSExportType *B)
569 { return GetReduceResultTypeName(A) < GetReduceResultTypeName(B); }))
570 genExportReduceResultType(ResultType);
571 }
572 mState->beginReduces(mRSContext->export_reduce_size());
573 for (auto I = mRSContext->export_reduce_begin(),
574 E = mRSContext->export_reduce_end();
575 I != E; ++I)
576 genExportReduce(*I);
577 mState->endReduces();
578
579 // Reflect exported functions (invokable)
580 mState->beginInvokables(mRSContext->export_funcs_size());
581 for (auto I = mRSContext->export_funcs_begin(),
582 E = mRSContext->export_funcs_end();
583 I != E; ++I)
584 genExportFunction(*I);
585 mState->endInvokables();
586
587 if (!mCollecting) {
588 if (mState->endOutputClass())
589 genCompute64Bit();
590
591 endClass();
592
593 mGeneratedFileNames->push_back(mScriptClassName);
594 }
595
596 return true;
597 }
598
genScriptClassConstructor()599 void RSReflectionJava::genScriptClassConstructor() {
600 std::string className(RSSlangReflectUtils::JavaBitcodeClassNameFromRSFileName(
601 mRSSourceFileName.c_str()));
602 // Provide a simple way to reference this object.
603 mOut.indent() << "private static final String " RS_RESOURCE_NAME " = \""
604 << getResourceId() << "\";\n";
605
606 // Generate a simple constructor with only a single parameter (the rest
607 // can be inferred from information we already have).
608 mOut.indent() << "// Constructor\n";
609 startFunction(AM_Public, false, nullptr, getClassName(), 1, "RenderScript",
610 "rs");
611
612 const bool haveReduceExportables =
613 mRSContext->export_reduce_begin() != mRSContext->export_reduce_end();
614
615 if (getEmbedBitcodeInJava()) {
616 // Call new single argument Java-only constructor
617 mOut.indent() << "super(rs,\n";
618 mOut.indent() << " " << RS_RESOURCE_NAME ",\n";
619 mOut.indent() << " " << className << ".getBitCode32(),\n";
620 mOut.indent() << " " << className << ".getBitCode64());\n";
621 } else {
622 // Call alternate constructor with required parameters.
623 // Look up the proper raw bitcode resource id via the context.
624 mOut.indent() << "this(rs,\n";
625 mOut.indent() << " rs.getApplicationContext().getResources(),\n";
626 mOut.indent() << " rs.getApplicationContext().getResources()."
627 "getIdentifier(\n";
628 mOut.indent() << " " RS_RESOURCE_NAME ", \"raw\",\n";
629 mOut.indent()
630 << " rs.getApplicationContext().getPackageName()));\n";
631 endFunction();
632
633 // Alternate constructor (legacy) with 3 original parameters.
634 startFunction(AM_Public, false, nullptr, getClassName(), 3, "RenderScript",
635 "rs", "Resources", "resources", "int", "id");
636 // Call constructor of super class
637 mOut.indent() << "super(rs, resources, id);\n";
638 }
639
640 // If an exported variable has initial value, reflect it.
641 // Keep this in sync with initialization handling in ReflectionState::declareVariable().
642
643 for (auto I = mRSContext->export_vars_begin(),
644 E = mRSContext->export_vars_end();
645 I != E; I++) {
646 const RSExportVar *EV = *I;
647 if (!EV->getInit().isUninit()) {
648 genInitExportVariable(EV->getType(), EV->getName(), EV->getInit());
649 } else if (EV->getArraySize()) {
650 // Always create an initial zero-init array object.
651 mOut.indent() << RS_EXPORT_VAR_PREFIX << EV->getName() << " = new "
652 << GetTypeName(EV->getType(), TypeNameDefault & ~TypeNameWithConstantArrayBrackets) << "["
653 << EV->getArraySize() << "];\n";
654 size_t NumInits = EV->getNumInits();
655 const RSExportConstantArrayType *ECAT =
656 static_cast<const RSExportConstantArrayType *>(EV->getType());
657 const RSExportType *ET = ECAT->getElementType();
658 for (size_t i = 0; i < NumInits; i++) {
659 std::stringstream Name;
660 Name << EV->getName() << "[" << i << "]";
661 genInitExportVariable(ET, Name.str(), EV->getInitArray(i));
662 }
663 }
664 if (mRSContext->getTargetAPI() >= SLANG_JB_TARGET_API) {
665 genTypeInstance(EV->getType());
666 }
667 genFieldPackerInstance(EV->getType());
668 }
669
670 if (haveReduceExportables) {
671 mOut.indent() << SAVED_RS_REFERENCE << " = rs;\n";
672 }
673
674 // Reflect argument / return types in kernels
675
676 for (auto I = mRSContext->export_foreach_begin(),
677 E = mRSContext->export_foreach_end();
678 I != E; I++) {
679 const RSExportForEach *EF = *I;
680
681 const RSExportForEach::InTypeVec &InTypes = EF->getInTypes();
682 for (RSExportForEach::InTypeIter BI = InTypes.begin(), EI = InTypes.end();
683 BI != EI; BI++) {
684 if (*BI != nullptr) {
685 genTypeInstanceFromPointer(*BI);
686 }
687 }
688
689 const RSExportType *OET = EF->getOutType();
690 if (OET) {
691 genTypeInstanceFromPointer(OET);
692 }
693 }
694
695 for (auto I = mRSContext->export_reduce_begin(),
696 E = mRSContext->export_reduce_end();
697 I != E; I++) {
698 const RSExportReduce *ER = *I;
699
700 const RSExportType *RT = ER->getResultType();
701 slangAssert(RT != nullptr);
702 if (!exportableReduce(RT))
703 continue;
704
705 genTypeInstance(RT);
706
707 const RSExportReduce::InTypeVec &InTypes = ER->getAccumulatorInTypes();
708 for (RSExportReduce::InTypeIter BI = InTypes.begin(), EI = InTypes.end();
709 BI != EI; BI++) {
710 slangAssert(*BI != nullptr);
711 genTypeInstance(*BI);
712 }
713 }
714
715 endFunction();
716
717 for (std::set<std::string>::iterator I = mTypesToCheck.begin(),
718 E = mTypesToCheck.end();
719 I != E; I++) {
720 mOut.indent() << "private Element " RS_ELEM_PREFIX << *I << ";\n";
721 }
722
723 for (std::set<std::string>::iterator I = mFieldPackerTypes.begin(),
724 E = mFieldPackerTypes.end();
725 I != E; I++) {
726 mOut.indent() << "private FieldPacker " RS_FP_PREFIX << *I << ";\n";
727 }
728
729 if (haveReduceExportables) {
730 // We save a private copy of rs in order to create temporary
731 // allocations in the reduce_* entry points.
732 mOut.indent() << "private RenderScript " << SAVED_RS_REFERENCE << ";\n";
733 }
734 }
735
genInitBoolExportVariable(const std::string & VarName,const clang::APValue & Val)736 void RSReflectionJava::genInitBoolExportVariable(const std::string &VarName,
737 const clang::APValue &Val) {
738 slangAssert(!Val.isUninit() && "Not a valid initializer");
739 slangAssert((Val.getKind() == clang::APValue::Int) &&
740 "Bool type has wrong initial APValue");
741
742 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = ";
743
744 mOut << ((Val.getInt().getSExtValue() == 0) ? "false" : "true") << ";\n";
745 }
746
747 void
genInitPrimitiveExportVariable(const std::string & VarName,const clang::APValue & Val)748 RSReflectionJava::genInitPrimitiveExportVariable(const std::string &VarName,
749 const clang::APValue &Val) {
750 slangAssert(!Val.isUninit() && "Not a valid initializer");
751
752 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = ";
753 genInitValue(Val, false);
754 mOut << ";\n";
755 }
756
genInitExportVariable(const RSExportType * ET,const std::string & VarName,const clang::APValue & Val)757 void RSReflectionJava::genInitExportVariable(const RSExportType *ET,
758 const std::string &VarName,
759 const clang::APValue &Val) {
760 slangAssert(!Val.isUninit() && "Not a valid initializer");
761
762 switch (ET->getClass()) {
763 case RSExportType::ExportClassPrimitive: {
764 const RSExportPrimitiveType *EPT =
765 static_cast<const RSExportPrimitiveType *>(ET);
766 if (EPT->getType() == DataTypeBoolean) {
767 genInitBoolExportVariable(VarName, Val);
768 } else {
769 genInitPrimitiveExportVariable(VarName, Val);
770 }
771 break;
772 }
773 case RSExportType::ExportClassPointer: {
774 if (!Val.isInt() || Val.getInt().getSExtValue() != 0)
775 std::cout << "Initializer which is non-NULL to pointer type variable "
776 "will be ignored\n";
777 break;
778 }
779 case RSExportType::ExportClassVector: {
780 const RSExportVectorType *EVT = static_cast<const RSExportVectorType *>(ET);
781 switch (Val.getKind()) {
782 case clang::APValue::Int:
783 case clang::APValue::Float: {
784 for (unsigned i = 0; i < EVT->getNumElement(); i++) {
785 std::string Name = VarName + "." + GetVectorAccessor(i);
786 genInitPrimitiveExportVariable(Name, Val);
787 }
788 break;
789 }
790 case clang::APValue::Vector: {
791 std::stringstream VecName;
792 VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix
793 << EVT->getNumElement();
794 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = new "
795 << VecName.str() << "();\n";
796
797 unsigned NumElements = std::min(
798 static_cast<unsigned>(EVT->getNumElement()), Val.getVectorLength());
799 for (unsigned i = 0; i < NumElements; i++) {
800 const clang::APValue &ElementVal = Val.getVectorElt(i);
801 std::string Name = VarName + "." + GetVectorAccessor(i);
802 genInitPrimitiveExportVariable(Name, ElementVal);
803 }
804 break;
805 }
806 case clang::APValue::MemberPointer:
807 case clang::APValue::Uninitialized:
808 case clang::APValue::ComplexInt:
809 case clang::APValue::ComplexFloat:
810 case clang::APValue::LValue:
811 case clang::APValue::Array:
812 case clang::APValue::Struct:
813 case clang::APValue::Union:
814 case clang::APValue::AddrLabelDiff: {
815 slangAssert(false && "Unexpected type of value of initializer.");
816 }
817 }
818 break;
819 }
820 // TODO(zonr): Resolving initializer of a record (and matrix) type variable
821 // is complex. It cannot obtain by just simply evaluating the initializer
822 // expression.
823 case RSExportType::ExportClassMatrix:
824 case RSExportType::ExportClassConstantArray:
825 case RSExportType::ExportClassRecord: {
826 #if 0
827 unsigned InitIndex = 0;
828 const RSExportRecordType *ERT =
829 static_cast<const RSExportRecordType*>(ET);
830
831 slangAssert((Val.getKind() == clang::APValue::Vector) &&
832 "Unexpected type of initializer for record type variable");
833
834 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName
835 << " = new " << ERT->getElementName()
836 << "." RS_TYPE_ITEM_CLASS_NAME"();\n";
837
838 for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(),
839 E = ERT->fields_end();
840 I != E;
841 I++) {
842 const RSExportRecordType::Field *F = *I;
843 std::string FieldName = VarName + "." + F->getName();
844
845 if (InitIndex > Val.getVectorLength())
846 break;
847
848 genInitPrimitiveExportVariable(FieldName,
849 Val.getVectorElt(InitIndex++));
850 }
851 #endif
852 slangAssert(false && "Unsupported initializer for record/matrix/constant "
853 "array type variable currently");
854 break;
855 }
856 default: { slangAssert(false && "Unknown class of type"); }
857 }
858 }
859
genExportVariable(const RSExportVar * EV)860 void RSReflectionJava::genExportVariable(const RSExportVar *EV) {
861 const RSExportType *ET = EV->getType();
862
863 const ReflectionState::Val32
864 AllocSize32 = mState->declareVariable(EV);
865
866 if (mCollecting)
867 return;
868
869 mOut.indent() << "private final static int " << RS_EXPORT_VAR_INDEX_PREFIX
870 << EV->getName() << " = " << getNextExportVarSlot() << ";\n";
871
872 switch (ET->getClass()) {
873 case RSExportType::ExportClassPrimitive: {
874 genPrimitiveTypeExportVariable(EV);
875 break;
876 }
877 case RSExportType::ExportClassPointer: {
878 genPointerTypeExportVariable(EV);
879 break;
880 }
881 case RSExportType::ExportClassVector: {
882 genVectorTypeExportVariable(EV);
883 break;
884 }
885 case RSExportType::ExportClassMatrix: {
886 genMatrixTypeExportVariable(EV);
887 break;
888 }
889 case RSExportType::ExportClassConstantArray: {
890 genConstantArrayTypeExportVariable(EV, AllocSize32);
891 break;
892 }
893 case RSExportType::ExportClassRecord: {
894 genRecordTypeExportVariable(EV, AllocSize32);
895 break;
896 }
897 default: { slangAssert(false && "Unknown class of type"); }
898 }
899 }
900
901 // Keep this in sync with Invokable analysis in ReflectionState::declareInvokable().
genExportFunction(const RSExportFunc * EF)902 void RSReflectionJava::genExportFunction(const RSExportFunc *EF) {
903 mState->declareInvokable(EF);
904
905 if (!mCollecting) {
906 mOut.indent() << "private final static int " << RS_EXPORT_FUNC_INDEX_PREFIX
907 << EF->getName() << " = " << getNextExportFuncSlot() << ";\n";
908 }
909
910 // invoke_*()
911 ArgTy Args;
912
913 if (!mCollecting) {
914 if (EF->hasParam()) {
915 for (RSExportFunc::const_param_iterator I = EF->params_begin(),
916 E = EF->params_end();
917 I != E; I++) {
918 Args.push_back(
919 std::make_pair(GetTypeName((*I)->getType()), (*I)->getName()));
920 }
921 }
922
923 if (mRSContext->getTargetAPI() >= SLANG_M_TARGET_API) {
924 startFunction(AM_Public, false, "Script.InvokeID",
925 "getInvokeID_" + EF->getName(), 0);
926
927 mOut.indent() << "return createInvokeID(" << RS_EXPORT_FUNC_INDEX_PREFIX
928 << EF->getName() << ");\n";
929
930 endFunction();
931 }
932
933 startFunction(AM_Public, false, "void",
934 "invoke_" + EF->getName(/*Mangle=*/false),
935 // We are using un-mangled name since Java
936 // supports method overloading.
937 Args);
938 }
939
940 if (!EF->hasParam()) {
941 if (!mCollecting)
942 mOut.indent() << "invoke(" << RS_EXPORT_FUNC_INDEX_PREFIX << EF->getName()
943 << ");\n";
944 } else {
945 const RSExportRecordType *ERT = EF->getParamPacketType();
946
947 // NOTE: This type isn't on the RSContext::export_types* list.
948 mState->declareRecord(ERT, false);
949
950 std::string FieldPackerName = EF->getName() + "_fp";
951
952 if (genCreateFieldPacker(ERT, FieldPackerName.c_str(),
953 mState->getRecord32(ERT).getRecordAllocSize()))
954 genPackVarOfType(ERT, nullptr, FieldPackerName.c_str());
955
956 if (!mCollecting)
957 mOut.indent() << "invoke(" << RS_EXPORT_FUNC_INDEX_PREFIX << EF->getName()
958 << ", " << FieldPackerName << ");\n";
959 }
960
961 if (!mCollecting)
962 endFunction();
963 }
964
genPairwiseDimCheck(const std::string & name0,const std::string & name1)965 void RSReflectionJava::genPairwiseDimCheck(const std::string &name0,
966 const std::string &name1) {
967 mOut.indent() << "// Verify dimensions\n";
968 mOut.indent() << "t0 = " << name0 << ".getType();\n";
969 mOut.indent() << "t1 = " << name1 << ".getType();\n";
970 mOut.indent() << "if ((t0.getCount() != t1.getCount()) ||\n";
971 mOut.indent() << " (t0.getX() != t1.getX()) ||\n";
972 mOut.indent() << " (t0.getY() != t1.getY()) ||\n";
973 mOut.indent() << " (t0.getZ() != t1.getZ()) ||\n";
974 mOut.indent() << " (t0.hasFaces() != t1.hasFaces()) ||\n";
975 mOut.indent() << " (t0.hasMipmaps() != t1.hasMipmaps())) {\n";
976 mOut.indent() << " throw new RSRuntimeException(\"Dimension mismatch "
977 << "between parameters " << name0 << " and " << name1
978 << "!\");\n";
979 mOut.indent() << "}\n\n";
980 }
981
genNullArrayCheck(const std::string & ArrayName)982 void RSReflectionJava::genNullArrayCheck(const std::string &ArrayName) {
983 mOut.indent() << "// Verify that \"" << ArrayName << "\" is non-null.\n";
984 mOut.indent() << "if (" << ArrayName << " == null) {\n";
985 mOut.indent() << " throw new RSIllegalArgumentException(\"Array \\\""
986 << ArrayName << "\\\" is null!\");\n";
987 mOut.indent() << "}\n";
988 }
989
genVectorLengthCompatibilityCheck(const std::string & ArrayName,unsigned VecSize)990 void RSReflectionJava::genVectorLengthCompatibilityCheck(const std::string &ArrayName,
991 unsigned VecSize) {
992 mOut.indent() << "// Verify that the array length is a multiple of the vector size.\n";
993 mOut.indent() << "if (" << ArrayName << ".length % " << std::to_string(VecSize)
994 << " != 0) {\n";
995 mOut.indent() << " throw new RSIllegalArgumentException(\"Array \\\"" << ArrayName
996 << "\\\" is not a multiple of " << std::to_string(VecSize)
997 << " in length!\");\n";
998 mOut.indent() << "}\n";
999 }
1000
1001 // Keep this in sync with ForEach analysis in ReflectionState::beginForEach()
1002 // and other ReflectionState::*ForEach*() methods.
genExportForEach(const RSExportForEach * EF)1003 void RSReflectionJava::genExportForEach(const RSExportForEach *EF) {
1004 if (EF->isDummyRoot()) {
1005 mState->declareForEachDummyRoot(EF);
1006
1007 if (!mCollecting) {
1008 // Skip reflection for dummy root() kernels. Note that we have to
1009 // advance the next slot number for ForEach, however.
1010 mOut.indent() << "//private final static int "
1011 << RS_EXPORT_FOREACH_INDEX_PREFIX << EF->getName() << " = "
1012 << getNextExportForEachSlot() << ";\n";
1013 }
1014
1015 return;
1016 }
1017
1018 if (!mCollecting) {
1019 mOut.indent() << "private final static int " << RS_EXPORT_FOREACH_INDEX_PREFIX
1020 << EF->getName() << " = " << getNextExportForEachSlot()
1021 << ";\n";
1022 }
1023
1024 // forEach_*()
1025 ArgTy Args;
1026 bool HasAllocation = false; // at least one in/out allocation?
1027
1028 const RSExportForEach::InVec &Ins = EF->getIns();
1029 const RSExportForEach::InTypeVec &InTypes = EF->getInTypes();
1030 const RSExportType *OET = EF->getOutType();
1031 const RSExportRecordType *ERT = EF->getParamPacketType();
1032
1033 mState->beginForEach(EF);
1034
1035 for (RSExportForEach::InTypeIter BI = InTypes.begin(), EI = InTypes.end();
1036 BI != EI; BI++) {
1037 mState->addForEachIn(EF, *BI);
1038 }
1039
1040 if (Ins.size() == 1) {
1041 HasAllocation = true;
1042 if (!mCollecting)
1043 Args.push_back(std::make_pair("Allocation", "ain"));
1044 } else if (Ins.size() > 1) {
1045 HasAllocation = true;
1046 if (!mCollecting) {
1047 for (RSExportForEach::InIter BI = Ins.begin(), EI = Ins.end(); BI != EI;
1048 BI++) {
1049 Args.push_back(std::make_pair("Allocation",
1050 "ain_" + (*BI)->getName().str()));
1051 }
1052 }
1053 }
1054
1055 if (EF->hasOut() || EF->hasReturn()) {
1056 HasAllocation = true;
1057 if (!mCollecting)
1058 Args.push_back(std::make_pair("Allocation", "aout"));
1059 }
1060
1061 if (ERT) {
1062 for (RSExportForEach::const_param_iterator I = EF->params_begin(),
1063 E = EF->params_end();
1064 I != E; I++) {
1065 mState->addForEachParam(EF, (*I)->getType());
1066 if (!mCollecting)
1067 Args.push_back(
1068 std::make_pair(GetTypeName((*I)->getType()), (*I)->getName()));
1069 }
1070 }
1071
1072 if (mRSContext->getTargetAPI() >= SLANG_JB_MR1_TARGET_API) {
1073 mState->addForEachSignatureMetadata(EF, EF->getSignatureMetadata());
1074
1075 if (!mCollecting) {
1076 startFunction(AM_Public, false, "Script.KernelID",
1077 "getKernelID_" + EF->getName(), 0);
1078
1079 // TODO: add element checking
1080 mOut.indent() << "return createKernelID(" << RS_EXPORT_FOREACH_INDEX_PREFIX
1081 << EF->getName() << ", " << EF->getSignatureMetadata()
1082 << ", null, null);\n";
1083
1084 endFunction();
1085 }
1086 }
1087
1088 if (!mCollecting) {
1089 if (mRSContext->getTargetAPI() >= SLANG_JB_MR2_TARGET_API) {
1090 if (HasAllocation) {
1091 startFunction(AM_Public, false, "void", "forEach_" + EF->getName(), Args);
1092
1093 mOut.indent() << "forEach_" << EF->getName();
1094 mOut << "(";
1095
1096 if (Ins.size() == 1) {
1097 mOut << "ain, ";
1098
1099 } else if (Ins.size() > 1) {
1100 for (RSExportForEach::InIter BI = Ins.begin(), EI = Ins.end(); BI != EI;
1101 BI++) {
1102
1103 mOut << "ain_" << (*BI)->getName().str() << ", ";
1104 }
1105 }
1106
1107 if (EF->hasOut() || EF->hasReturn()) {
1108 mOut << "aout, ";
1109 }
1110
1111 if (EF->hasUsrData()) {
1112 mOut << Args.back().second << ", ";
1113 }
1114
1115 // No clipped bounds to pass in.
1116 mOut << "null);\n";
1117
1118 endFunction();
1119 }
1120
1121 // Add the clipped kernel parameters to the Args list.
1122 Args.push_back(std::make_pair("Script.LaunchOptions", "sc"));
1123 }
1124 }
1125
1126 if (!mCollecting) {
1127 startFunction(AM_Public, false, "void", "forEach_" + EF->getName(), Args);
1128
1129 if (InTypes.size() == 1) {
1130 if (InTypes.front() != nullptr) {
1131 genTypeCheck(InTypes.front(), "ain");
1132 }
1133
1134 } else if (InTypes.size() > 1) {
1135 size_t Index = 0;
1136 for (RSExportForEach::InTypeIter BI = InTypes.begin(), EI = InTypes.end();
1137 BI != EI; BI++, ++Index) {
1138
1139 if (*BI != nullptr) {
1140 genTypeCheck(*BI, ("ain_" + Ins[Index]->getName()).str().c_str());
1141 }
1142 }
1143 }
1144
1145 if (OET) {
1146 genTypeCheck(OET, "aout");
1147 }
1148
1149 if (Ins.size() == 1 && (EF->hasOut() || EF->hasReturn())) {
1150 mOut.indent() << "Type t0, t1;";
1151 genPairwiseDimCheck("ain", "aout");
1152
1153 } else if (Ins.size() > 1) {
1154 mOut.indent() << "Type t0, t1;";
1155
1156 std::string In0Name = "ain_" + Ins[0]->getName().str();
1157
1158 for (size_t index = 1; index < Ins.size(); ++index) {
1159 genPairwiseDimCheck(In0Name, "ain_" + Ins[index]->getName().str());
1160 }
1161
1162 if (EF->hasOut() || EF->hasReturn()) {
1163 genPairwiseDimCheck(In0Name, "aout");
1164 }
1165 }
1166 }
1167
1168 std::string FieldPackerName = EF->getName() + "_fp";
1169 if (ERT) {
1170 // NOTE: This type isn't on the RSContext::export_types* list.
1171 mState->declareRecord(ERT, false);
1172
1173 if (genCreateFieldPacker(ERT, FieldPackerName.c_str(),
1174 mState->getRecord32(ERT).getRecordAllocSize())) {
1175 genPackVarOfType(ERT, nullptr, FieldPackerName.c_str());
1176 }
1177 }
1178
1179 mState->endForEach();
1180
1181 if (mCollecting)
1182 return;
1183
1184 mOut.indent() << "forEach(" << RS_EXPORT_FOREACH_INDEX_PREFIX
1185 << EF->getName();
1186
1187 if (Ins.size() == 1) {
1188 mOut << ", ain";
1189 } else if (Ins.size() > 1) {
1190 mOut << ", new Allocation[]{ain_" << Ins[0]->getName().str();
1191
1192 for (size_t index = 1; index < Ins.size(); ++index) {
1193 mOut << ", ain_" << Ins[index]->getName().str();
1194 }
1195
1196 mOut << "}";
1197
1198 } else {
1199 mOut << ", (Allocation) null";
1200 }
1201
1202 if (EF->hasOut() || EF->hasReturn())
1203 mOut << ", aout";
1204 else
1205 mOut << ", null";
1206
1207 if (EF->hasUsrData())
1208 mOut << ", " << FieldPackerName;
1209 else
1210 mOut << ", null";
1211
1212 if (mRSContext->getTargetAPI() >= SLANG_JB_MR2_TARGET_API) {
1213 mOut << ", sc);\n";
1214 } else {
1215 mOut << ");\n";
1216 }
1217
1218 endFunction();
1219 }
1220
1221 //////////////////////////////////////////////////////////////////////////////////////////////////////
1222
1223 // Reductions with certain legal result types can only be reflected for NDK, not for Java.
exportableReduce(const RSExportType * ResultType)1224 bool RSReflectionJava::exportableReduce(const RSExportType *ResultType) {
1225 const RSExportType *CheckType = ResultType;
1226 if (ResultType->getClass() == RSExportType::ExportClassConstantArray)
1227 CheckType = static_cast<const RSExportConstantArrayType *>(ResultType)->getElementType();
1228 if (CheckType->getClass() == RSExportType::ExportClassRecord) {
1229 // No Java reflection for struct until http://b/22236498 is resolved.
1230 return false;
1231 }
1232
1233 return true;
1234 }
1235
1236 namespace {
1237 enum MappingComment { MappingCommentWithoutType, MappingCommentWithCType };
1238
1239 // OUTPUTS
1240 // InputParamName = name to use for input parameter
1241 // InputMappingComment = text showing the mapping from InputParamName to the corresponding
1242 // accumulator function parameter name (and possibly type)
1243 // INPUTS
1244 // NamePrefix = beginning of parameter name (e.g., "in")
1245 // MappingComment = whether or not InputMappingComment should contain type
1246 // ER = description of the reduction
1247 // InIdx = which input (numbered from zero)
getReduceInputStrings(std::string & InputParamName,std::string & InputMappingComment,const std::string & NamePrefix,MappingComment Mapping,const RSExportReduce * ER,size_t InIdx)1248 void getReduceInputStrings(std::string &InputParamName, std::string &InputMappingComment,
1249 const std::string &NamePrefix, MappingComment Mapping,
1250 const RSExportReduce *ER, size_t InIdx) {
1251 InputParamName = NamePrefix + std::to_string(InIdx+1);
1252 std::string TypeString;
1253 if (Mapping == MappingCommentWithCType) {
1254 const RSExportType *InType = ER->getAccumulatorInTypes()[InIdx];
1255 if (InType->getClass() == RSExportType::ExportClassRecord) {
1256 // convertToRTD doesn't understand this type
1257 TypeString = "/* struct <> */ ";
1258 } else {
1259 RSReflectionTypeData InTypeData;
1260 ER->getAccumulatorInTypes()[InIdx]->convertToRTD(&InTypeData);
1261 slangAssert(InTypeData.type->s_name != nullptr);
1262 if (InTypeData.vecSize > 1) {
1263 TypeString = InTypeData.type->s_name + std::to_string(InTypeData.vecSize) + " ";
1264 } else {
1265 TypeString = InTypeData.type->s_name + std::string(" ");
1266 }
1267 }
1268 }
1269 InputMappingComment = InputParamName + " = \"" + TypeString + std::string(ER->getAccumulatorIns()[InIdx]->getName()) + "\"";
1270 }
1271
1272 } // end anonymous namespace
1273
1274 // Keep this in sync with Reduce analysis in ReflectionState::declareReduce().
genExportReduce(const RSExportReduce * ER)1275 void RSReflectionJava::genExportReduce(const RSExportReduce *ER) {
1276 const bool IsExportable = exportableReduce(ER->getResultType());
1277
1278 // Need to track even a non-exportable reduce, both so that we get
1279 // the count of reduction kernels correct, and so that we can
1280 // intelligently diagnose cases where 32-bit and 64-bit compiles
1281 // disagree as to whether a reduction kernel is exportable.
1282 mState->declareReduce(ER, IsExportable);
1283
1284 if (!IsExportable || mCollecting)
1285 return;
1286
1287 // Generate the reflected function index.
1288 mOut.indent() << "private final static int " << RS_EXPORT_REDUCE_INDEX_PREFIX
1289 << ER->getNameReduce() << " = " << getNextExportReduceSlot()
1290 << ";\n";
1291
1292 /****** remember resultSvType generation **********************************************************/
1293
1294 // Two variants of reduce_* entry points get generated.
1295 // Array variant:
1296 // result_<resultSvType> reduce_<name>(<devecSiIn1Type>[] in1, ..., <devecSiInNType>[] inN)
1297 // Allocation variant:
1298 // result_<resultSvType> reduce_<name>(Allocation in1, ..., Allocation inN)
1299 // result_<resultSvType> reduce_<name>(Allocation in1, ..., Allocation inN, Script.LaunchOptions sc)
1300
1301 genExportReduceArrayVariant(ER);
1302 genExportReduceAllocationVariant(ER);
1303 }
1304
genExportReduceArrayVariant(const RSExportReduce * ER)1305 void RSReflectionJava::genExportReduceArrayVariant(const RSExportReduce *ER) {
1306 // Analysis of result type. Returns early if result type is not
1307 // suitable for array method reflection.
1308 const RSExportType *const ResultType = ER->getResultType();
1309 auto ResultTypeClass = ResultType->getClass();
1310 switch (ResultTypeClass) {
1311 case RSExportType::ExportClassConstantArray:
1312 case RSExportType::ExportClassMatrix:
1313 case RSExportType::ExportClassPrimitive:
1314 case RSExportType::ExportClassVector:
1315 // Ok
1316 break;
1317
1318 case RSExportType::ExportClassPointer:
1319 slangAssert(!"Should not get here with pointer type");
1320 return;
1321
1322 case RSExportType::ExportClassRecord:
1323 // TODO: convertToRTD() cannot handle this. Why not?
1324 return;
1325
1326 default:
1327 slangAssert(!"Unknown export class");
1328 return;
1329 }
1330 RSReflectionTypeData ResultTypeData;
1331 ResultType->convertToRTD(&ResultTypeData);
1332 if (!ResultTypeData.type->java_name || !ResultTypeData.type->java_array_element_name ||
1333 (ResultTypeData.vecSize > 1 && !ResultTypeData.type->rs_java_vector_prefix)) {
1334 slangAssert(false);
1335 return;
1336 }
1337 const std::string ResultTypeName = GetReduceResultTypeName(ER);
1338
1339 // Analysis of inputs. Returns early if some input type is not
1340 // suitable for array method reflection.
1341 llvm::SmallVector<RSReflectionTypeData, 1> InsTypeData;
1342 ArgTy Args;
1343 const auto &Ins = ER->getAccumulatorIns();
1344 const auto &InTypes = ER->getAccumulatorInTypes();
1345 slangAssert(Ins.size() == InTypes.size());
1346 InsTypeData.resize(Ins.size());
1347 llvm::SmallVector<std::string, 1> InComments;
1348 for (size_t InIdx = 0, InEnd = Ins.size(); InIdx < InEnd; ++InIdx) {
1349 const RSExportType *const InType = InTypes[InIdx];
1350 switch (InType->getClass()) {
1351 case RSExportType::ExportClassMatrix:
1352 case RSExportType::ExportClassPrimitive:
1353 case RSExportType::ExportClassVector:
1354 // Ok
1355 break;
1356
1357 case RSExportType::ExportClassConstantArray:
1358 // No
1359 return;
1360
1361 case RSExportType::ExportClassPointer:
1362 slangAssert(!"Should not get here with pointer type");
1363 return;
1364
1365 case RSExportType::ExportClassRecord:
1366 // TODO: convertToRTD() cannot handle this. Why not?
1367 return;
1368
1369 default:
1370 slangAssert(!"Unknown export class");
1371 return;
1372 }
1373
1374 RSReflectionTypeData &InTypeData = InsTypeData[InIdx];
1375 InType->convertToRTD(&InTypeData);
1376 if (!InTypeData.type->java_name || !InTypeData.type->java_array_element_name ||
1377 (InTypeData.vecSize > 1 && !InTypeData.type->rs_java_vector_prefix)) {
1378 return;
1379 }
1380
1381 std::string InputParamName, InputComment;
1382 getReduceInputStrings(InputParamName, InputComment, "in", MappingCommentWithoutType, ER, InIdx);
1383 if (InTypeData.vecSize > 1)
1384 InputComment += (", flattened " + std::to_string(InTypeData.vecSize) + "-vectors");
1385 InComments.push_back(InputComment);
1386
1387 const std::string InputTypeName = std::string(InTypeData.type->java_array_element_name) + "[]";
1388 Args.push_back(std::make_pair(InputTypeName, InputParamName));
1389 }
1390
1391 const std::string MethodName = "reduce_" + ER->getNameReduce();
1392
1393 // result_<resultSvType> reduce_<name>(<devecSiIn1Type>[] in1, ..., <devecSiInNType>[] inN)
1394
1395 for (const std::string &InComment : InComments)
1396 mOut.indent() << "// " << InComment << "\n";
1397 startFunction(AM_Public, false, ResultTypeName.c_str(), MethodName, Args);
1398 slangAssert(Ins.size() == InTypes.size());
1399 slangAssert(Ins.size() == InsTypeData.size());
1400 slangAssert(Ins.size() == Args.size());
1401 std::string In1Length;
1402 std::string InputAllocationOutgoingArgumentList;
1403 std::vector<std::string> InputAllocationNames;
1404 for (size_t InIdx = 0, InEnd = Ins.size(); InIdx < InEnd; ++InIdx) {
1405 const std::string &ArgName = Args[InIdx].second;
1406 genNullArrayCheck(ArgName);
1407 std::string InLength = ArgName + ".length";
1408 const uint32_t VecSize = InsTypeData[InIdx].vecSize;
1409 if (VecSize > 1) {
1410 InLength += " / " + std::to_string(VecSize);
1411 genVectorLengthCompatibilityCheck(ArgName, VecSize);
1412 }
1413 if (InIdx == 0) {
1414 In1Length = InLength;
1415 } else {
1416 mOut.indent() << "// Verify that input array lengths are the same.\n";
1417 mOut.indent() << "if (" << In1Length << " != " << InLength << ") {\n";
1418 mOut.indent() << " throw new RSRuntimeException(\"Array length mismatch "
1419 << "between parameters \\\"" << Args[0].second << "\\\" and \\\"" << ArgName
1420 << "\\\"!\");\n";
1421 mOut.indent() << "}\n";
1422 }
1423 // Create a temporary input allocation
1424 const std::string TempName = "a" + ArgName;
1425 mOut.indent() << "Allocation " << TempName << " = Allocation.createSized("
1426 << SAVED_RS_REFERENCE << ", "
1427 << RS_ELEM_PREFIX << InTypes[InIdx]->getElementName() << ", "
1428 << InLength << ");\n";
1429 mOut.indent() << TempName << ".setAutoPadding(true);\n";
1430 mOut.indent() << TempName << ".copyFrom(" << ArgName << ");\n";
1431 // ... and put that input allocation on the outgoing argument list
1432 if (!InputAllocationOutgoingArgumentList.empty())
1433 InputAllocationOutgoingArgumentList += ", ";
1434 InputAllocationOutgoingArgumentList += TempName;
1435 // ... and keep track of it for setting result.mTempIns
1436 InputAllocationNames.push_back(TempName);
1437 }
1438
1439 mOut << "\n";
1440 mOut.indent() << ResultTypeName << " result = " << MethodName << "(" << InputAllocationOutgoingArgumentList << ", null);\n";
1441 if (!InputAllocationNames.empty()) {
1442 mOut.indent() << "result.mTempIns = new Allocation[]{";
1443 bool EmittedFirst = false;
1444 for (const std::string &InputAllocationName : InputAllocationNames) {
1445 if (!EmittedFirst) {
1446 EmittedFirst = true;
1447 } else {
1448 mOut << ", ";
1449 }
1450 mOut << InputAllocationName;
1451 }
1452 mOut << "};\n";
1453 }
1454 mOut.indent() << "return result;\n";
1455 endFunction();
1456 }
1457
genExportReduceAllocationVariant(const RSExportReduce * ER)1458 void RSReflectionJava::genExportReduceAllocationVariant(const RSExportReduce *ER) {
1459 const auto &Ins = ER->getAccumulatorIns();
1460 const auto &InTypes = ER->getAccumulatorInTypes();
1461 const RSExportType *ResultType = ER->getResultType();
1462
1463 llvm::SmallVector<std::string, 1> InComments;
1464 ArgTy Args;
1465 for (size_t InIdx = 0, InEnd = Ins.size(); InIdx < InEnd; ++InIdx) {
1466 std::string InputParamName, InputComment;
1467 getReduceInputStrings(InputParamName, InputComment, "ain", MappingCommentWithCType, ER, InIdx);
1468 InComments.push_back(InputComment);
1469 Args.push_back(std::make_pair("Allocation", InputParamName));
1470 }
1471
1472 const std::string MethodName = "reduce_" + ER->getNameReduce();
1473 const std::string ResultTypeName = GetReduceResultTypeName(ER);
1474
1475 // result_<resultSvType> reduce_<name>(Allocation in1, ..., Allocation inN)
1476
1477 for (const std::string &InComment : InComments)
1478 mOut.indent() << "// " << InComment << "\n";
1479 startFunction(AM_Public, false, ResultTypeName.c_str(), MethodName, Args);
1480 mOut.indent() << "return " << MethodName << "(";
1481 bool EmittedFirstArg = false;
1482 for (const auto &Arg : Args) {
1483 if (!EmittedFirstArg) {
1484 EmittedFirstArg = true;
1485 } else {
1486 mOut << ", ";
1487 }
1488 mOut << Arg.second;
1489 }
1490 mOut << ", null);\n";
1491 endFunction();
1492
1493 // result_<resultSvType> reduce_<name>(Allocation in1, ..., Allocation inN, Script.LaunchOptions sc)
1494
1495 static const char FormalOptionsName[] = "sc";
1496 Args.push_back(std::make_pair("Script.LaunchOptions", FormalOptionsName));
1497 for (const std::string &InComment : InComments)
1498 mOut.indent() << "// " << InComment << "\n";
1499 startFunction(AM_Public, false, ResultTypeName.c_str(), MethodName, Args);
1500 const std::string &In0Name = Args[0].second;
1501 // Sanity-check inputs
1502 if (Ins.size() > 1)
1503 mOut.indent() << "Type t0, t1;\n";
1504 for (size_t InIdx = 0, InEnd = Ins.size(); InIdx < InEnd; ++InIdx) {
1505 const std::string &InName = Args[InIdx].second;
1506 genTypeCheck(InTypes[InIdx], InName.c_str());
1507 if (InIdx > 0)
1508 genPairwiseDimCheck(In0Name.c_str(), InName.c_str());
1509 }
1510 // Create a temporary output allocation
1511 const char OutputAllocName[] = "aout";
1512 const size_t OutputAllocLength =
1513 ResultType->getClass() == RSExportType::ExportClassConstantArray
1514 ? static_cast<const RSExportConstantArrayType *>(ResultType)->getNumElement()
1515 : 1;
1516 mOut.indent() << "Allocation " << OutputAllocName << " = Allocation.createSized("
1517 << SAVED_RS_REFERENCE << ", "
1518 << RS_ELEM_PREFIX << ResultType->getElementName() << ", "
1519 << OutputAllocLength << ");\n";
1520 mOut.indent() << OutputAllocName << ".setAutoPadding(true);\n";
1521 // Call the underlying reduce entry point
1522 mOut.indent() << "reduce(" << RS_EXPORT_REDUCE_INDEX_PREFIX << ER->getNameReduce()
1523 << ", new Allocation[]{" << In0Name;
1524 for (size_t InIdx = 1, InEnd = Ins.size(); InIdx < InEnd; ++InIdx)
1525 mOut << ", " << Args[InIdx].second;
1526 mOut << "}, " << OutputAllocName << ", " << FormalOptionsName << ");\n";
1527 mOut.indent() << "return new " << ResultTypeName << "(" << OutputAllocName << ");\n";
1528 endFunction();
1529 }
1530
1531 namespace {
1532
1533 // When we've copied the Allocation to a Java array, how do we
1534 // further process the elements of that array?
1535 enum MapFromAllocation {
1536 MapFromAllocationTrivial, // no further processing
1537 MapFromAllocationPositive, // need to ensure elements are positive (range check)
1538 MapFromAllocationBoolean, // need to convert elements from byte to boolean
1539 MapFromAllocationPromote // need to zero extend elements
1540 };
1541
1542 // Return Java expression that maps from an Allocation element to a Java non-vector result.
1543 //
1544 // MFA = mapping kind
1545 // ArrayElementTypeName = type of InVal (having been copied out of Allocation to Java array)
1546 // ReflectedScalarTypeName = type of mapped value
1547 // InVal = input value that must be mapped
1548 //
genReduceResultMapping(MapFromAllocation MFA,const std::string & ArrayElementTypeName,const std::string & ReflectedScalarTypeName,const char * InVal)1549 std::string genReduceResultMapping(MapFromAllocation MFA,
1550 const std::string &ArrayElementTypeName,
1551 const std::string &ReflectedScalarTypeName,
1552 const char *InVal) {
1553 switch (MFA) {
1554 default:
1555 slangAssert(!"Unknown MapFromAllocation");
1556 // and fall through
1557 case MapFromAllocationPositive: // range checking must be done separately
1558 case MapFromAllocationTrivial:
1559 return InVal;
1560 case MapFromAllocationBoolean:
1561 return std::string(InVal) + std::string(" != 0");
1562 case MapFromAllocationPromote:
1563 return ZeroExtendValue(InVal,
1564 ArrayElementTypeName,
1565 ReflectedScalarTypeName);
1566 }
1567 }
1568
1569 // Return Java expression that maps from an Allocation element to a Java vector result.
1570 //
1571 // MFA = mapping kind
1572 // ArrayElementTypeName = type of InVal (having been copied out of Allocation to Java array)
1573 // ReflectedScalarTypeName = type of mapped value
1574 // VectorTypeName = type of vector
1575 // VectorElementCount = number of elements in the vector
1576 // InArray = input array containing vector elements
1577 // InIdx = index of first vector element within InArray (or nullptr, if 0)
1578 //
genReduceResultVectorMapping(MapFromAllocation MFA,const std::string & ArrayElementTypeName,const std::string & ReflectedScalarTypeName,const std::string & VectorTypeName,unsigned VectorElementCount,const char * InArray,const char * InIdx=nullptr)1579 std::string genReduceResultVectorMapping(MapFromAllocation MFA,
1580 const std::string &ArrayElementTypeName,
1581 const std::string &ReflectedScalarTypeName,
1582 const std::string &VectorTypeName,
1583 unsigned VectorElementCount,
1584 const char *InArray, const char *InIdx = nullptr) {
1585 std::string result = "new " + VectorTypeName + "(";
1586 for (unsigned VectorElementIdx = 0; VectorElementIdx < VectorElementCount; ++VectorElementIdx) {
1587 if (VectorElementIdx)
1588 result += ", ";
1589
1590 std::string ArrayElementName = std::string(InArray) + "[";
1591 if (InIdx)
1592 ArrayElementName += std::string(InIdx) + "+";
1593 ArrayElementName += std::to_string(VectorElementIdx) + "]";
1594
1595 result += genReduceResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
1596 ArrayElementName.c_str());
1597 }
1598 result += ")";
1599 return result;
1600 }
1601
genReduceResultRangeCheck(GeneratedFile & Out,const char * InVal)1602 void genReduceResultRangeCheck(GeneratedFile &Out, const char *InVal) {
1603 Out.indent() << "if (" << InVal << " < 0)\n";
1604 Out.indent() << " throw new RSRuntimeException(\"Result is not representible in Java\");\n";
1605 }
1606
1607 } // end anonymous namespace
1608
genExportReduceResultType(const RSExportType * ResultType)1609 void RSReflectionJava::genExportReduceResultType(const RSExportType *ResultType) {
1610 if (!exportableReduce(ResultType))
1611 return;
1612
1613 const std::string ClassName = GetReduceResultTypeName(ResultType);
1614 const std::string GetMethodReturnTypeName = GetTypeName(ResultType);
1615 mOut.indent() << "// To obtain the result, invoke get(), which blocks\n";
1616 mOut.indent() << "// until the asynchronously-launched operation has completed.\n";
1617 mOut.indent() << "public static class " << ClassName;
1618 mOut.startBlock();
1619 startFunction(AM_Public, false, GetMethodReturnTypeName.c_str(), "get", 0);
1620
1621 RSReflectionTypeData TypeData;
1622 ResultType->convertToRTD(&TypeData);
1623
1624 const std::string UnbracketedResultTypeName =
1625 GetTypeName(ResultType, TypeNameDefault & ~TypeNameWithConstantArrayBrackets);
1626 const std::string ReflectedScalarTypeName = TypeData.type->java_name;
1627 // Note: MATRIX* types do not have a java_array_element_name
1628 const std::string ArrayElementTypeName =
1629 TypeData.type->java_array_element_name
1630 ? std::string(TypeData.type->java_array_element_name)
1631 : ReflectedScalarTypeName;
1632
1633 MapFromAllocation MFA = MapFromAllocationTrivial;
1634 if (std::string(TypeData.type->rs_type) == "UNSIGNED_64")
1635 MFA = MapFromAllocationPositive;
1636 else if (ReflectedScalarTypeName == "boolean")
1637 MFA = MapFromAllocationBoolean;
1638 else if (ReflectedScalarTypeName != ArrayElementTypeName)
1639 MFA = MapFromAllocationPromote;
1640
1641 mOut.indent() << "if (!mGotResult)";
1642 mOut.startBlock();
1643
1644 if (TypeData.vecSize == 1) { // result type is non-vector
1645 // <ArrayElementType>[] outArray = new <ArrayElementType>[1];
1646 // mOut.copyTo(outArray);
1647 mOut.indent() << ArrayElementTypeName << "[] outArray = new " << ArrayElementTypeName
1648 << "[" << std::max(TypeData.arraySize, 1U) << "];\n";
1649 mOut.indent() << "mOut.copyTo(outArray);\n";
1650 if (TypeData.arraySize == 0) { // result type is non-array non-vector
1651 // mResult = outArray[0]; // but there are several special cases
1652 if (MFA == MapFromAllocationPositive)
1653 genReduceResultRangeCheck(mOut, "outArray[0]");
1654 mOut.indent() << "mResult = "
1655 << genReduceResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
1656 "outArray[0]")
1657 << ";\n";
1658 } else { // result type is array of non-vector
1659 if (MFA == MapFromAllocationTrivial) {
1660 // mResult = outArray;
1661 mOut.indent() << "mResult = outArray;\n";
1662 } else {
1663 // <ResultType> result = new <UnbracketedResultType>[<ArrayElementCount>];
1664 // for (unsigned Idx = 0; Idx < <ArrayElementCount>; ++Idx)
1665 // result[Idx] = <Transform>(outArray[Idx]);
1666 // mResult = result; // but there are several special cases
1667 if (MFA != MapFromAllocationPositive) {
1668 mOut.indent() << GetTypeName(ResultType) << " result = new "
1669 << UnbracketedResultTypeName
1670 << "[" << TypeData.arraySize << "];\n";
1671 }
1672 mOut.indent() << "for (int Idx = 0; Idx < " << TypeData.arraySize << "; ++Idx)";
1673 mOut.startBlock();
1674 if (MFA == MapFromAllocationPositive) {
1675 genReduceResultRangeCheck(mOut, "outArray[Idx]");
1676 } else {
1677 mOut.indent() << "result[Idx] = "
1678 << genReduceResultMapping(MFA, ArrayElementTypeName, ReflectedScalarTypeName,
1679 "outArray[Idx]")
1680 << ";\n";
1681 }
1682 mOut.endBlock();
1683 mOut.indent() << "mResult = " << (MFA == MapFromAllocationPositive ? "outArray" : "result") << ";\n";
1684 }
1685 }
1686 } else { // result type is vector or array of vector
1687 // <ArrayElementType>[] outArray = new <ArrayElementType>[<VectorElementCount> * <ArrayElementCount>];
1688 // mOut.copyTo(outArray);
1689 const unsigned VectorElementCount = TypeData.vecSize;
1690 const unsigned OutArrayElementCount = VectorElementCount * std::max(TypeData.arraySize, 1U);
1691 mOut.indent() << ArrayElementTypeName << "[] outArray = new " << ArrayElementTypeName
1692 << "[" << OutArrayElementCount << "];\n";
1693 mOut.indent() << "mOut.copyTo(outArray);\n";
1694 if (MFA == MapFromAllocationPositive) {
1695 mOut.indent() << "for (int Idx = 0; Idx < " << OutArrayElementCount << "; ++Idx)";
1696 mOut.startBlock();
1697 genReduceResultRangeCheck(mOut, "outArray[Idx]");
1698 mOut.endBlock();
1699 }
1700 if (TypeData.arraySize == 0) { // result type is vector
1701 // mResult = new <ResultType>(outArray[0], outArray[1] ...); // but there are several special cases
1702 mOut.indent() << "mResult = "
1703 << genReduceResultVectorMapping(MFA,
1704 ArrayElementTypeName, ReflectedScalarTypeName,
1705 GetTypeName(ResultType), VectorElementCount,
1706 "outArray")
1707 << ";\n";
1708 } else { // result type is array of vector
1709 // <ResultType> result = new <UnbracketedResultType>[<ArrayElementCount>];
1710 // for (unsigned Idx = 0; Idx < <ArrayElementCount>; ++Idx)
1711 // result[Idx] = new <UnbracketedResultType>(outArray[<ArrayElementCount>*Idx+0],
1712 // outArray[<ArrayElementCount>*Idx+1]...);
1713 // mResult = result; // but there are several special cases
1714 mOut.indent() << GetTypeName(ResultType) << " result = new "
1715 << UnbracketedResultTypeName
1716 << "[" << TypeData.arraySize << "];\n";
1717 mOut.indent() << "for (int Idx = 0; Idx < " << TypeData.arraySize << "; ++Idx)";
1718 mOut.startBlock();
1719 mOut.indent() << "result[Idx] = "
1720 << genReduceResultVectorMapping(MFA,
1721 ArrayElementTypeName, ReflectedScalarTypeName,
1722 UnbracketedResultTypeName, VectorElementCount,
1723 "outArray", (std::to_string(VectorElementCount) + "*Idx").c_str())
1724 << ";\n";
1725 mOut.endBlock();
1726 mOut.indent() << "mResult = result;\n";
1727 }
1728 }
1729
1730 mOut.indent() << "mOut.destroy();\n";
1731 mOut.indent() << "mOut = null; // make Java object eligible for garbage collection\n";
1732 mOut.indent() << "if (mTempIns != null)";
1733 mOut.startBlock();
1734 mOut.indent() << "for (Allocation tempIn : mTempIns)";
1735 mOut.startBlock();
1736 mOut.indent() << "tempIn.destroy();\n";
1737 mOut.endBlock();
1738 mOut.indent() << "mTempIns = null; // make Java objects eligible for garbage collection\n";
1739 mOut.endBlock();
1740 mOut.indent() << "mGotResult = true;\n";
1741 mOut.endBlock();
1742
1743 mOut.indent() << "return mResult;\n";
1744 endFunction();
1745
1746 startFunction(AM_Private, false, nullptr, ClassName, 1, "Allocation", "out");
1747 // TODO: Generate allocation type check and size check? Or move
1748 // responsibility for instantiating the Allocation here, instead of
1749 // the reduce_* method?
1750 mOut.indent() << "mTempIns = null;\n";
1751 mOut.indent() << "mOut = out;\n";
1752 mOut.indent() << "mGotResult = false;\n";
1753 endFunction();
1754 mOut.indent() << "private Allocation[] mTempIns;\n";
1755 mOut.indent() << "private Allocation mOut;\n";
1756 // TODO: If result is reference type rather than primitive type, we
1757 // could omit mGotResult and use mResult==null to indicate that we
1758 // haven't obtained the result yet.
1759 mOut.indent() << "private boolean mGotResult;\n";
1760 mOut.indent() << "private " << GetMethodReturnTypeName << " mResult;\n";
1761 mOut.endBlock();
1762 }
1763
1764 //////////////////////////////////////////////////////////////////////////////////////////////////////
1765
genTypeInstanceFromPointer(const RSExportType * ET)1766 void RSReflectionJava::genTypeInstanceFromPointer(const RSExportType *ET) {
1767 if (ET->getClass() == RSExportType::ExportClassPointer) {
1768 // For pointer parameters to original forEach kernels.
1769 const RSExportPointerType *EPT =
1770 static_cast<const RSExportPointerType *>(ET);
1771 genTypeInstance(EPT->getPointeeType());
1772 } else {
1773 // For handling pass-by-value kernel parameters.
1774 genTypeInstance(ET);
1775 }
1776 }
1777
genTypeInstance(const RSExportType * ET)1778 void RSReflectionJava::genTypeInstance(const RSExportType *ET) {
1779 switch (ET->getClass()) {
1780 case RSExportType::ExportClassPrimitive:
1781 case RSExportType::ExportClassVector:
1782 case RSExportType::ExportClassConstantArray: {
1783 std::string TypeName = ET->getElementName();
1784 if (addTypeNameForElement(TypeName)) {
1785 mOut.indent() << RS_ELEM_PREFIX << TypeName << " = Element." << TypeName
1786 << "(rs);\n";
1787 }
1788 break;
1789 }
1790
1791 case RSExportType::ExportClassRecord: {
1792 std::string ClassName = ET->getElementName();
1793 if (addTypeNameForElement(ClassName)) {
1794 mOut.indent() << RS_ELEM_PREFIX << ClassName << " = " << ClassName
1795 << ".createElement(rs);\n";
1796 }
1797 break;
1798 }
1799
1800 default:
1801 break;
1802 }
1803 }
1804
genFieldPackerInstance(const RSExportType * ET)1805 void RSReflectionJava::genFieldPackerInstance(const RSExportType *ET) {
1806 switch (ET->getClass()) {
1807 case RSExportType::ExportClassPrimitive:
1808 case RSExportType::ExportClassVector:
1809 case RSExportType::ExportClassConstantArray:
1810 case RSExportType::ExportClassRecord: {
1811 std::string TypeName = ET->getElementName();
1812 addTypeNameForFieldPacker(TypeName);
1813 break;
1814 }
1815
1816 default:
1817 break;
1818 }
1819 }
1820
genTypeCheck(const RSExportType * ET,const char * VarName)1821 void RSReflectionJava::genTypeCheck(const RSExportType *ET,
1822 const char *VarName) {
1823 mOut.indent() << "// check " << VarName << "\n";
1824
1825 if (ET->getClass() == RSExportType::ExportClassPointer) {
1826 const RSExportPointerType *EPT =
1827 static_cast<const RSExportPointerType *>(ET);
1828 ET = EPT->getPointeeType();
1829 }
1830
1831 std::string TypeName;
1832
1833 switch (ET->getClass()) {
1834 case RSExportType::ExportClassPrimitive:
1835 case RSExportType::ExportClassVector:
1836 case RSExportType::ExportClassRecord: {
1837 TypeName = ET->getElementName();
1838 break;
1839 }
1840
1841 default:
1842 break;
1843 }
1844
1845 if (!TypeName.empty()) {
1846 mOut.indent() << "if (!" << VarName
1847 << ".getType().getElement().isCompatible(" RS_ELEM_PREFIX
1848 << TypeName << ")) {\n";
1849 mOut.indent() << " throw new RSRuntimeException(\"Type mismatch with "
1850 << TypeName << "!\");\n";
1851 mOut.indent() << "}\n";
1852 }
1853 }
1854
genPrimitiveTypeExportVariable(const RSExportVar * EV)1855 void RSReflectionJava::genPrimitiveTypeExportVariable(const RSExportVar *EV) {
1856 slangAssert(
1857 (EV->getType()->getClass() == RSExportType::ExportClassPrimitive) &&
1858 "Variable should be type of primitive here");
1859
1860 const RSExportPrimitiveType *EPT =
1861 static_cast<const RSExportPrimitiveType *>(EV->getType());
1862 std::string TypeName = GetTypeName(EPT);
1863 const std::string &VarName = EV->getName();
1864
1865 genPrivateExportVariable(TypeName, EV->getName());
1866
1867 if (EV->isConst()) {
1868 mOut.indent() << "public final static " << TypeName
1869 << " " RS_EXPORT_VAR_CONST_PREFIX << VarName << " = ";
1870 const clang::APValue &Val = EV->getInit();
1871 genInitValue(Val, EPT->getType() == DataTypeBoolean);
1872 mOut << ";\n";
1873 } else {
1874 // set_*()
1875 // This must remain synchronized, since multiple Dalvik threads may
1876 // be calling setters.
1877 startFunction(AM_PublicSynchronized, false, "void", "set_" + VarName, 1,
1878 TypeName.c_str(), "v");
1879 if ((EPT->getElementSizeInBytes() < 4) || EV->isUnsigned()) {
1880 // We create/cache a per-type FieldPacker. This allows us to reuse the
1881 // validation logic (for catching negative inputs from Dalvik, as well
1882 // as inputs that are too large to be represented in the unsigned type).
1883 // Sub-integer types are also handled specially here, so that we don't
1884 // overwrite bytes accidentally.
1885 std::string ElemName = EPT->getElementName();
1886 std::string FPName;
1887 FPName = RS_FP_PREFIX + ElemName;
1888 mOut.indent() << "if (" << FPName << "!= null) {\n";
1889 mOut.increaseIndent();
1890 mOut.indent() << FPName << ".reset();\n";
1891 mOut.decreaseIndent();
1892 mOut.indent() << "} else {\n";
1893 mOut.increaseIndent();
1894 mOut.indent() << FPName << " = new FieldPacker(" << EPT->getElementSizeInBytes()
1895 << ");\n";
1896 mOut.decreaseIndent();
1897 mOut.indent() << "}\n";
1898
1899 genPackVarOfType(EPT, "v", FPName.c_str());
1900 mOut.indent() << "setVar(" << RS_EXPORT_VAR_INDEX_PREFIX << VarName
1901 << ", " << FPName << ");\n";
1902 } else {
1903 mOut.indent() << "setVar(" << RS_EXPORT_VAR_INDEX_PREFIX << VarName
1904 << ", v);\n";
1905 }
1906
1907 // Dalvik update comes last, since the input may be invalid (and hence
1908 // throw an exception).
1909 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;\n";
1910
1911 endFunction();
1912 }
1913
1914 genGetExportVariable(TypeName, VarName);
1915 genGetFieldID(VarName);
1916 }
1917
genInitValue(const clang::APValue & Val,bool asBool)1918 void RSReflectionJava::genInitValue(const clang::APValue &Val, bool asBool) {
1919 switch (Val.getKind()) {
1920 case clang::APValue::Int: {
1921 const llvm::APInt &api = Val.getInt();
1922 if (asBool) {
1923 mOut << ((api.getSExtValue() == 0) ? "false" : "true");
1924 } else {
1925 // TODO: Handle unsigned correctly
1926 mOut << api.getSExtValue();
1927 if (api.getBitWidth() > 32) {
1928 mOut << "L";
1929 }
1930 }
1931 break;
1932 }
1933
1934 case clang::APValue::Float: {
1935 const llvm::APFloat &apf = Val.getFloat();
1936 llvm::SmallString<30> s;
1937 apf.toString(s);
1938 mOut << s.c_str();
1939 if (&apf.getSemantics() == &llvm::APFloat::IEEEsingle) {
1940 if (s.count('.') == 0) {
1941 mOut << ".f";
1942 } else {
1943 mOut << "f";
1944 }
1945 }
1946 break;
1947 }
1948
1949 case clang::APValue::ComplexInt:
1950 case clang::APValue::ComplexFloat:
1951 case clang::APValue::LValue:
1952 case clang::APValue::Vector: {
1953 slangAssert(false && "Primitive type cannot have such kind of initializer");
1954 break;
1955 }
1956
1957 default: { slangAssert(false && "Unknown kind of initializer"); }
1958 }
1959 }
1960
genPointerTypeExportVariable(const RSExportVar * EV)1961 void RSReflectionJava::genPointerTypeExportVariable(const RSExportVar *EV) {
1962 const RSExportType *ET = EV->getType();
1963 const RSExportType *PointeeType;
1964
1965 slangAssert((ET->getClass() == RSExportType::ExportClassPointer) &&
1966 "Variable should be type of pointer here");
1967
1968 PointeeType = static_cast<const RSExportPointerType *>(ET)->getPointeeType();
1969 std::string TypeName = GetTypeName(ET);
1970 const std::string &VarName = EV->getName();
1971
1972 genPrivateExportVariable(TypeName, VarName);
1973
1974 // bind_*()
1975 startFunction(AM_Public, false, "void", "bind_" + VarName, 1,
1976 TypeName.c_str(), "v");
1977
1978 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;\n";
1979 mOut.indent() << "if (v == null) bindAllocation(null, "
1980 << RS_EXPORT_VAR_INDEX_PREFIX << VarName << ");\n";
1981
1982 if (PointeeType->getClass() == RSExportType::ExportClassRecord) {
1983 mOut.indent() << "else bindAllocation(v.getAllocation(), "
1984 << RS_EXPORT_VAR_INDEX_PREFIX << VarName << ");\n";
1985 } else {
1986 mOut.indent() << "else bindAllocation(v, " << RS_EXPORT_VAR_INDEX_PREFIX
1987 << VarName << ");\n";
1988 }
1989
1990 endFunction();
1991
1992 genGetExportVariable(TypeName, VarName);
1993 }
1994
genVectorTypeExportVariable(const RSExportVar * EV)1995 void RSReflectionJava::genVectorTypeExportVariable(const RSExportVar *EV) {
1996 slangAssert((EV->getType()->getClass() == RSExportType::ExportClassVector) &&
1997 "Variable should be type of vector here");
1998
1999 std::string TypeName = GetTypeName(EV->getType());
2000 std::string VarName = EV->getName();
2001
2002 genPrivateExportVariable(TypeName, VarName);
2003 genSetExportVariable(TypeName, EV, 1);
2004 genGetExportVariable(TypeName, VarName);
2005 genGetFieldID(VarName);
2006 }
2007
genMatrixTypeExportVariable(const RSExportVar * EV)2008 void RSReflectionJava::genMatrixTypeExportVariable(const RSExportVar *EV) {
2009 slangAssert((EV->getType()->getClass() == RSExportType::ExportClassMatrix) &&
2010 "Variable should be type of matrix here");
2011
2012 const RSExportType *ET = EV->getType();
2013 std::string TypeName = GetTypeName(ET);
2014 const std::string &VarName = EV->getName();
2015
2016 genPrivateExportVariable(TypeName, VarName);
2017
2018 // set_*()
2019 if (!EV->isConst()) {
2020 const char *FieldPackerName = "fp";
2021 startFunction(AM_PublicSynchronized, false, "void", "set_" + VarName, 1,
2022 TypeName.c_str(), "v");
2023 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;\n";
2024
2025 if (genCreateFieldPacker(ET, FieldPackerName, ReflectionState::NoVal32()))
2026 genPackVarOfType(ET, "v", FieldPackerName);
2027 mOut.indent() << "setVar(" RS_EXPORT_VAR_INDEX_PREFIX << VarName << ", "
2028 << FieldPackerName << ");\n";
2029
2030 endFunction();
2031 }
2032
2033 genGetExportVariable(TypeName, VarName);
2034 genGetFieldID(VarName);
2035 }
2036
2037 void
genConstantArrayTypeExportVariable(const RSExportVar * EV,ReflectionState::Val32 AllocSize32)2038 RSReflectionJava::genConstantArrayTypeExportVariable(const RSExportVar *EV,
2039 ReflectionState::Val32 AllocSize32) {
2040 const RSExportType *const ET = EV->getType();
2041 slangAssert(
2042 (ET->getClass() == RSExportType::ExportClassConstantArray) &&
2043 "Variable should be type of constant array here");
2044
2045 std::string TypeName = GetTypeName(EV->getType());
2046 std::string VarName = EV->getName();
2047
2048 genPrivateExportVariable(TypeName, VarName);
2049 genSetExportVariable(TypeName, EV,
2050 static_cast<const RSExportConstantArrayType *>(ET)->getNumElement(),
2051 AllocSize32);
2052 genGetExportVariable(TypeName, VarName);
2053 genGetFieldID(VarName);
2054 }
2055
genRecordTypeExportVariable(const RSExportVar * EV,ReflectionState::Val32 AllocSize32)2056 void RSReflectionJava::genRecordTypeExportVariable(const RSExportVar *EV,
2057 ReflectionState::Val32 AllocSize32) {
2058 slangAssert((EV->getType()->getClass() == RSExportType::ExportClassRecord) &&
2059 "Variable should be type of struct here");
2060
2061 std::string TypeName = GetTypeName(EV->getType());
2062 std::string VarName = EV->getName();
2063
2064 genPrivateExportVariable(TypeName, VarName);
2065 genSetExportVariable(TypeName, EV, 1, AllocSize32);
2066 genGetExportVariable(TypeName, VarName);
2067 genGetFieldID(VarName);
2068 }
2069
genPrivateExportVariable(const std::string & TypeName,const std::string & VarName)2070 void RSReflectionJava::genPrivateExportVariable(const std::string &TypeName,
2071 const std::string &VarName) {
2072 mOut.indent() << "private " << TypeName << " " << RS_EXPORT_VAR_PREFIX
2073 << VarName << ";\n";
2074 }
2075
2076 // Dimension = array element count; otherwise, 1.
genSetExportVariable(const std::string & TypeName,const RSExportVar * EV,unsigned Dimension,ReflectionState::Val32 AllocSize32)2077 void RSReflectionJava::genSetExportVariable(const std::string &TypeName,
2078 const RSExportVar *EV,
2079 unsigned Dimension,
2080 ReflectionState::Val32 AllocSize32) {
2081 if (!EV->isConst()) {
2082 const char *FieldPackerName = "fp";
2083 const std::string &VarName = EV->getName();
2084 const RSExportType *ET = EV->getType();
2085 startFunction(AM_PublicSynchronized, false, "void", "set_" + VarName, 1,
2086 TypeName.c_str(), "v");
2087 mOut.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = v;\n";
2088
2089 if (genCreateFieldPacker(ET, FieldPackerName, AllocSize32))
2090 genPackVarOfType(ET, "v", FieldPackerName);
2091
2092 if (mRSContext->getTargetAPI() < SLANG_JB_TARGET_API) {
2093 // Legacy apps must use the old setVar() without Element/dim components.
2094 mOut.indent() << "setVar(" << RS_EXPORT_VAR_INDEX_PREFIX << VarName
2095 << ", " << FieldPackerName << ");\n";
2096 } else {
2097 // We only have support for one-dimensional array reflection today,
2098 // but the entry point (i.e. setVar()) takes an array of dimensions.
2099 mOut.indent() << "int []__dimArr = new int[1];\n";
2100 mOut.indent() << "__dimArr[0] = " << Dimension << ";\n";
2101 mOut.indent() << "setVar(" << RS_EXPORT_VAR_INDEX_PREFIX << VarName
2102 << ", " << FieldPackerName << ", " << RS_ELEM_PREFIX
2103 << ET->getElementName() << ", __dimArr);\n";
2104 }
2105
2106 endFunction();
2107 }
2108 }
2109
genGetExportVariable(const std::string & TypeName,const std::string & VarName)2110 void RSReflectionJava::genGetExportVariable(const std::string &TypeName,
2111 const std::string &VarName) {
2112 startFunction(AM_Public, false, TypeName.c_str(), "get_" + VarName, 0);
2113
2114 mOut.indent() << "return " << RS_EXPORT_VAR_PREFIX << VarName << ";\n";
2115
2116 endFunction();
2117 }
2118
genGetFieldID(const std::string & VarName)2119 void RSReflectionJava::genGetFieldID(const std::string &VarName) {
2120 // We only generate getFieldID_*() for non-Pointer (bind) types.
2121 if (mRSContext->getTargetAPI() >= SLANG_JB_MR1_TARGET_API) {
2122 startFunction(AM_Public, false, "Script.FieldID", "getFieldID_" + VarName,
2123 0);
2124
2125 mOut.indent() << "return createFieldID(" << RS_EXPORT_VAR_INDEX_PREFIX
2126 << VarName << ", null);\n";
2127
2128 endFunction();
2129 }
2130 }
2131
2132 /******************* Methods to generate script class /end *******************/
2133
genCreateFieldPacker(const RSExportType * ET,const char * FieldPackerName,ReflectionState::Val32 AllocSize32)2134 bool RSReflectionJava::genCreateFieldPacker(const RSExportType *ET,
2135 const char *FieldPackerName,
2136 ReflectionState::Val32 AllocSize32) {
2137 size_t AllocSize = ET->getAllocSize();
2138 slangAssert(!AllocSize32.first || ((AllocSize == 0) == (AllocSize32.second == 0)));
2139 if (AllocSize > 0) {
2140 if (!mCollecting) {
2141 mOut.indent() << "FieldPacker " << FieldPackerName << " = new FieldPacker(";
2142 genConditionalVal("", false, AllocSize, AllocSize32);
2143 mOut << ");\n";
2144 }
2145 }
2146 else
2147 return false;
2148 return true;
2149 }
2150
genPackVarOfType(const RSExportType * ET,const char * VarName,const char * FieldPackerName)2151 void RSReflectionJava::genPackVarOfType(const RSExportType *ET,
2152 const char *VarName,
2153 const char *FieldPackerName) {
2154 if (mCollecting)
2155 return;
2156
2157 switch (ET->getClass()) {
2158 case RSExportType::ExportClassPrimitive:
2159 case RSExportType::ExportClassVector: {
2160 mOut.indent() << FieldPackerName << "."
2161 << GetPackerAPIName(
2162 static_cast<const RSExportPrimitiveType *>(ET)) << "("
2163 << VarName << ");\n";
2164 break;
2165 }
2166 case RSExportType::ExportClassPointer: {
2167 // Must reflect as type Allocation in Java
2168 const RSExportType *PointeeType =
2169 static_cast<const RSExportPointerType *>(ET)->getPointeeType();
2170
2171 if (PointeeType->getClass() != RSExportType::ExportClassRecord) {
2172 mOut.indent() << FieldPackerName << ".addI32(" << VarName
2173 << ".getPtr());\n";
2174 } else {
2175 mOut.indent() << FieldPackerName << ".addI32(" << VarName
2176 << ".getAllocation().getPtr());\n";
2177 }
2178 break;
2179 }
2180 case RSExportType::ExportClassMatrix: {
2181 mOut.indent() << FieldPackerName << ".addMatrix(" << VarName << ");\n";
2182 break;
2183 }
2184 case RSExportType::ExportClassConstantArray: {
2185 const RSExportConstantArrayType *ECAT =
2186 static_cast<const RSExportConstantArrayType *>(ET);
2187
2188 // TODO(zonr): more elegant way. Currently, we obtain the unique index
2189 // variable (this method involves recursive call which means
2190 // we may have more than one level loop, therefore we can't
2191 // always use the same index variable name here) name given
2192 // in the for-loop from counting the '.' in @VarName.
2193 unsigned Level = 0;
2194 size_t LastDotPos = 0;
2195 std::string ElementVarName(VarName);
2196
2197 while (LastDotPos != std::string::npos) {
2198 LastDotPos = ElementVarName.find_first_of('.', LastDotPos + 1);
2199 Level++;
2200 }
2201 std::string IndexVarName("ct");
2202 IndexVarName.append(llvm::utostr(Level));
2203
2204 mOut.indent() << "for (int " << IndexVarName << " = 0; " << IndexVarName
2205 << " < " << ECAT->getNumElement() << "; " << IndexVarName << "++)";
2206 mOut.startBlock();
2207
2208 ElementVarName.append("[" + IndexVarName + "]");
2209 genPackVarOfType(ECAT->getElementType(), ElementVarName.c_str(),
2210 FieldPackerName);
2211
2212 mOut.endBlock();
2213 break;
2214 }
2215 case RSExportType::ExportClassRecord: {
2216 // Keep struct/field layout in sync with ReflectionState::declareRecord()
2217
2218 const RSExportRecordType *ERT = static_cast<const RSExportRecordType *>(ET);
2219 const ReflectionState::Record32 Record32 = mState->getRecord32(ERT);
2220
2221 auto emitSkip = [this, &FieldPackerName](size_t At, size_t Need,
2222 ReflectionState::Val32 Padding32) {
2223 if ((Need > At) || (Padding32.first && (Padding32.second != 0))) {
2224 size_t Padding = Need - At;
2225 mOut.indent() << FieldPackerName << ".skip(";
2226 if (!Padding32.first || (Padding == Padding32.second))
2227 mOut << Padding;
2228 else {
2229 genCheck64Bit(true);
2230 mOut << " ? " << Padding << " : " << Padding32.second;
2231 }
2232 mOut << ");\n";
2233 }
2234 };
2235
2236 // Relative pos from now on in field packer
2237 unsigned Pos = 0;
2238
2239 unsigned FieldNum = 0;
2240 for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(),
2241 E = ERT->fields_end();
2242 I != E; I++, FieldNum++) {
2243 const RSExportRecordType::Field *F = *I;
2244 std::string FieldName;
2245 size_t FieldOffset = F->getOffsetInParent();
2246 const RSExportType *T = F->getType();
2247 size_t FieldStoreSize = T->getStoreSize();
2248 size_t FieldAllocSize = T->getAllocSize();
2249
2250 const auto Field32PreAndPostPadding = Record32.getFieldPreAndPostPadding(FieldNum);
2251
2252 if (VarName != nullptr)
2253 FieldName = VarName + ("." + F->getName());
2254 else
2255 FieldName = F->getName();
2256
2257 emitSkip(Pos, FieldOffset, Field32PreAndPostPadding.first /* pre */);
2258
2259 genPackVarOfType(F->getType(), FieldName.c_str(), FieldPackerName);
2260
2261 // There is padding in the field type?
2262 emitSkip(FieldStoreSize, FieldAllocSize, Field32PreAndPostPadding.second /* post */);
2263
2264 Pos = FieldOffset + FieldAllocSize;
2265 }
2266
2267 // There maybe some padding after the struct
2268 emitSkip(Pos, ERT->getAllocSize(), Record32.getRecordPostPadding());
2269 break;
2270 }
2271 default: { slangAssert(false && "Unknown class of type"); }
2272 }
2273 }
2274
genAllocateVarOfType(const RSExportType * T,const std::string & VarName)2275 void RSReflectionJava::genAllocateVarOfType(const RSExportType *T,
2276 const std::string &VarName) {
2277 switch (T->getClass()) {
2278 case RSExportType::ExportClassPrimitive: {
2279 // Primitive type like int in Java has its own storage once it's declared.
2280 //
2281 // FIXME: Should we allocate storage for RS object?
2282 // if (static_cast<const RSExportPrimitiveType *>(T)->isRSObjectType())
2283 // mOut.indent() << VarName << " = new " << GetTypeName(T) << "();\n";
2284 break;
2285 }
2286 case RSExportType::ExportClassPointer: {
2287 // Pointer type is an instance of Allocation or a TypeClass whose value is
2288 // expected to be assigned by programmer later in Java program. Therefore
2289 // we don't reflect things like [VarName] = new Allocation();
2290 mOut.indent() << VarName << " = null;\n";
2291 break;
2292 }
2293 case RSExportType::ExportClassConstantArray: {
2294 const RSExportConstantArrayType *ECAT =
2295 static_cast<const RSExportConstantArrayType *>(T);
2296 const RSExportType *ElementType = ECAT->getElementType();
2297
2298 mOut.indent() << VarName << " = new " << GetTypeName(ElementType) << "["
2299 << ECAT->getNumElement() << "];\n";
2300
2301 // Primitive type element doesn't need allocation code.
2302 if (ElementType->getClass() != RSExportType::ExportClassPrimitive) {
2303 mOut.indent() << "for (int $ct = 0; $ct < " << ECAT->getNumElement()
2304 << "; $ct++)";
2305 mOut.startBlock();
2306
2307 std::string ElementVarName(VarName);
2308 ElementVarName.append("[$ct]");
2309 genAllocateVarOfType(ElementType, ElementVarName);
2310
2311 mOut.endBlock();
2312 }
2313 break;
2314 }
2315 case RSExportType::ExportClassVector:
2316 case RSExportType::ExportClassMatrix:
2317 case RSExportType::ExportClassRecord: {
2318 mOut.indent() << VarName << " = new " << GetTypeName(T) << "();\n";
2319 break;
2320 }
2321 }
2322 }
2323
genNewItemBufferIfNull(const char * Index)2324 void RSReflectionJava::genNewItemBufferIfNull(const char *Index) {
2325 mOut.indent() << "if (" << RS_TYPE_ITEM_BUFFER_NAME " == null) ";
2326 mOut << RS_TYPE_ITEM_BUFFER_NAME << " = new " << RS_TYPE_ITEM_CLASS_NAME
2327 << "[getType().getX() /* count */];\n";
2328 if (Index != nullptr) {
2329 mOut.indent() << "if (" << RS_TYPE_ITEM_BUFFER_NAME << "[" << Index
2330 << "] == null) ";
2331 mOut << RS_TYPE_ITEM_BUFFER_NAME << "[" << Index << "] = new "
2332 << RS_TYPE_ITEM_CLASS_NAME << "();\n";
2333 }
2334 }
2335
genNewItemBufferPackerIfNull()2336 void RSReflectionJava::genNewItemBufferPackerIfNull() {
2337 mOut.indent() << "if (" << RS_TYPE_ITEM_BUFFER_PACKER_NAME << " == null) ";
2338 mOut << RS_TYPE_ITEM_BUFFER_PACKER_NAME " = new FieldPacker("
2339 << mItemSizeof << " * getType().getX()/* count */);\n";
2340 }
2341
2342 /********************** Methods to generate type class **********************/
genTypeClass(const RSExportRecordType * ERT,std::string & ErrorMsg)2343 bool RSReflectionJava::genTypeClass(const RSExportRecordType *ERT,
2344 std::string &ErrorMsg) {
2345 mState->declareRecord(ERT);
2346 if (mCollecting)
2347 return true;
2348
2349 std::string ClassName = ERT->getElementName();
2350 std::string superClassName = getRSPackageName();
2351 superClassName += RS_TYPE_CLASS_SUPER_CLASS_NAME;
2352
2353 if (!startClass(AM_Public, false, ClassName, superClassName.c_str(),
2354 ErrorMsg))
2355 return false;
2356
2357 mGeneratedFileNames->push_back(ClassName);
2358
2359 mState->beginOutputClass();
2360
2361 genTypeItemClass(ERT);
2362
2363 // Declare item buffer and item buffer packer
2364 mOut.indent() << "private " << RS_TYPE_ITEM_CLASS_NAME << " "
2365 << RS_TYPE_ITEM_BUFFER_NAME << "[];\n";
2366 mOut.indent() << "private FieldPacker " << RS_TYPE_ITEM_BUFFER_PACKER_NAME
2367 << ";\n";
2368 mOut.indent() << "private static java.lang.ref.WeakReference<Element> "
2369 << RS_TYPE_ELEMENT_REF_NAME
2370 << " = new java.lang.ref.WeakReference<Element>(null);\n";
2371
2372 genTypeClassConstructor(ERT);
2373 genTypeClassCopyToArrayLocal(ERT);
2374 genTypeClassCopyToArray(ERT);
2375 genTypeClassItemSetter(ERT);
2376 genTypeClassItemGetter(ERT);
2377 genTypeClassComponentSetter(ERT);
2378 genTypeClassComponentGetter(ERT);
2379 genTypeClassCopyAll(ERT);
2380 if (!mRSContext->isCompatLib()) {
2381 // Skip the resize method if we are targeting a compatibility library.
2382 genTypeClassResize();
2383 }
2384
2385 if (mState->endOutputClass())
2386 genCompute64Bit();
2387
2388 endClass();
2389
2390 resetFieldIndex();
2391 clearFieldIndexMap();
2392
2393 return true;
2394 }
2395
genTypeItemClass(const RSExportRecordType * ERT)2396 void RSReflectionJava::genTypeItemClass(const RSExportRecordType *ERT) {
2397 mOut.indent() << "static public class " RS_TYPE_ITEM_CLASS_NAME;
2398 mOut.startBlock();
2399
2400 // Sizeof should not be exposed for 64-bit; it is not accurate
2401 if (mRSContext->getTargetAPI() < 21) {
2402 mOut.indent() << "public static final int sizeof = " << ERT->getAllocSize()
2403 << ";\n";
2404 }
2405
2406 // Member elements
2407 mOut << "\n";
2408 for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
2409 FE = ERT->fields_end();
2410 FI != FE; FI++) {
2411 mOut.indent() << GetTypeName((*FI)->getType()) << " " << (*FI)->getName()
2412 << ";\n";
2413 }
2414
2415 // Constructor
2416 mOut << "\n";
2417 mOut.indent() << RS_TYPE_ITEM_CLASS_NAME << "()";
2418 mOut.startBlock();
2419
2420 for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
2421 FE = ERT->fields_end();
2422 FI != FE; FI++) {
2423 const RSExportRecordType::Field *F = *FI;
2424 genAllocateVarOfType(F->getType(), F->getName());
2425 }
2426
2427 // end Constructor
2428 mOut.endBlock();
2429
2430 // end Item class
2431 mOut.endBlock();
2432 }
2433
genTypeClassConstructor(const RSExportRecordType * ERT)2434 void RSReflectionJava::genTypeClassConstructor(const RSExportRecordType *ERT) {
2435 const char *RenderScriptVar = "rs";
2436
2437 startFunction(AM_Public, true, "Element", "createElement", 1, "RenderScript",
2438 RenderScriptVar);
2439
2440 // TODO(all): Fix weak-refs + multi-context issue.
2441 // mOut.indent() << "Element e = " << RS_TYPE_ELEMENT_REF_NAME
2442 // << ".get();\n";
2443 // mOut.indent() << "if (e != null) return e;\n";
2444 RSReflectionJavaElementBuilder builder("eb", ERT, RenderScriptVar, &mOut,
2445 mRSContext, this, mState);
2446 builder.generate();
2447
2448 mOut.indent() << "return eb.create();\n";
2449 // mOut.indent() << "e = eb.create();\n";
2450 // mOut.indent() << RS_TYPE_ELEMENT_REF_NAME
2451 // << " = new java.lang.ref.WeakReference<Element>(e);\n";
2452 // mOut.indent() << "return e;\n";
2453 endFunction();
2454
2455 // private with element
2456 startFunction(AM_Private, false, nullptr, getClassName(), 1, "RenderScript",
2457 RenderScriptVar);
2458 mOut.indent() << RS_TYPE_ITEM_BUFFER_NAME << " = null;\n";
2459 mOut.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME << " = null;\n";
2460 mOut.indent() << "mElement = createElement(" << RenderScriptVar << ");\n";
2461 endFunction();
2462
2463 // 1D without usage
2464 startFunction(AM_Public, false, nullptr, getClassName(), 2, "RenderScript",
2465 RenderScriptVar, "int", "count");
2466
2467 mOut.indent() << RS_TYPE_ITEM_BUFFER_NAME << " = null;\n";
2468 mOut.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME << " = null;\n";
2469 mOut.indent() << "mElement = createElement(" << RenderScriptVar << ");\n";
2470 // Call init() in super class
2471 mOut.indent() << "init(" << RenderScriptVar << ", count);\n";
2472 endFunction();
2473
2474 // 1D with usage
2475 startFunction(AM_Public, false, nullptr, getClassName(), 3, "RenderScript",
2476 RenderScriptVar, "int", "count", "int", "usages");
2477
2478 mOut.indent() << RS_TYPE_ITEM_BUFFER_NAME << " = null;\n";
2479 mOut.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME << " = null;\n";
2480 mOut.indent() << "mElement = createElement(" << RenderScriptVar << ");\n";
2481 // Call init() in super class
2482 mOut.indent() << "init(" << RenderScriptVar << ", count, usages);\n";
2483 endFunction();
2484
2485 // create1D with usage
2486 startFunction(AM_Public, true, getClassName().c_str(), "create1D", 3,
2487 "RenderScript", RenderScriptVar, "int", "dimX", "int",
2488 "usages");
2489 mOut.indent() << getClassName() << " obj = new " << getClassName() << "("
2490 << RenderScriptVar << ");\n";
2491 mOut.indent() << "obj.mAllocation = Allocation.createSized("
2492 "rs, obj.mElement, dimX, usages);\n";
2493 mOut.indent() << "return obj;\n";
2494 endFunction();
2495
2496 // create1D without usage
2497 startFunction(AM_Public, true, getClassName().c_str(), "create1D", 2,
2498 "RenderScript", RenderScriptVar, "int", "dimX");
2499 mOut.indent() << "return create1D(" << RenderScriptVar
2500 << ", dimX, Allocation.USAGE_SCRIPT);\n";
2501 endFunction();
2502
2503 // create2D without usage
2504 startFunction(AM_Public, true, getClassName().c_str(), "create2D", 3,
2505 "RenderScript", RenderScriptVar, "int", "dimX", "int", "dimY");
2506 mOut.indent() << "return create2D(" << RenderScriptVar
2507 << ", dimX, dimY, Allocation.USAGE_SCRIPT);\n";
2508 endFunction();
2509
2510 // create2D with usage
2511 startFunction(AM_Public, true, getClassName().c_str(), "create2D", 4,
2512 "RenderScript", RenderScriptVar, "int", "dimX", "int", "dimY",
2513 "int", "usages");
2514
2515 mOut.indent() << getClassName() << " obj = new " << getClassName() << "("
2516 << RenderScriptVar << ");\n";
2517 mOut.indent() << "Type.Builder b = new Type.Builder(rs, obj.mElement);\n";
2518 mOut.indent() << "b.setX(dimX);\n";
2519 mOut.indent() << "b.setY(dimY);\n";
2520 mOut.indent() << "Type t = b.create();\n";
2521 mOut.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);\n";
2522 mOut.indent() << "return obj;\n";
2523 endFunction();
2524
2525 // createTypeBuilder
2526 startFunction(AM_Public, true, "Type.Builder", "createTypeBuilder", 1,
2527 "RenderScript", RenderScriptVar);
2528 mOut.indent() << "Element e = createElement(" << RenderScriptVar << ");\n";
2529 mOut.indent() << "return new Type.Builder(rs, e);\n";
2530 endFunction();
2531
2532 // createCustom with usage
2533 startFunction(AM_Public, true, getClassName().c_str(), "createCustom", 3,
2534 "RenderScript", RenderScriptVar, "Type.Builder", "tb", "int",
2535 "usages");
2536 mOut.indent() << getClassName() << " obj = new " << getClassName() << "("
2537 << RenderScriptVar << ");\n";
2538 mOut.indent() << "Type t = tb.create();\n";
2539 mOut.indent() << "if (t.getElement() != obj.mElement) {\n";
2540 mOut.indent() << " throw new RSIllegalArgumentException("
2541 "\"Type.Builder did not match expected element type.\");\n";
2542 mOut.indent() << "}\n";
2543 mOut.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);\n";
2544 mOut.indent() << "return obj;\n";
2545 endFunction();
2546 }
2547
genTypeClassCopyToArray(const RSExportRecordType * ERT)2548 void RSReflectionJava::genTypeClassCopyToArray(const RSExportRecordType *ERT) {
2549 startFunction(AM_Private, false, "void", "copyToArray", 2,
2550 RS_TYPE_ITEM_CLASS_NAME, "i", "int", "index");
2551
2552 genNewItemBufferPackerIfNull();
2553 mOut.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME << ".reset(index * "
2554 << mItemSizeof << ");\n";
2555
2556 mOut.indent() << "copyToArrayLocal(i, " RS_TYPE_ITEM_BUFFER_PACKER_NAME
2557 ");\n";
2558
2559 endFunction();
2560 }
2561
2562 void
genTypeClassCopyToArrayLocal(const RSExportRecordType * ERT)2563 RSReflectionJava::genTypeClassCopyToArrayLocal(const RSExportRecordType *ERT) {
2564 startFunction(AM_Private, false, "void", "copyToArrayLocal", 2,
2565 RS_TYPE_ITEM_CLASS_NAME, "i", "FieldPacker", "fp");
2566
2567 genPackVarOfType(ERT, "i", "fp");
2568
2569 endFunction();
2570 }
2571
genTypeClassItemSetter(const RSExportRecordType * ERT)2572 void RSReflectionJava::genTypeClassItemSetter(const RSExportRecordType *ERT) {
2573 startFunction(AM_PublicSynchronized, false, "void", "set", 3,
2574 RS_TYPE_ITEM_CLASS_NAME, "i", "int", "index", "boolean",
2575 "copyNow");
2576 genNewItemBufferIfNull(nullptr);
2577 mOut.indent() << RS_TYPE_ITEM_BUFFER_NAME << "[index] = i;\n";
2578
2579 mOut.indent() << "if (copyNow) ";
2580 mOut.startBlock();
2581
2582 mOut.indent() << "copyToArray(i, index);\n";
2583 mOut.indent() << "FieldPacker fp = new FieldPacker(" << mItemSizeof << ");\n";
2584 mOut.indent() << "copyToArrayLocal(i, fp);\n";
2585 mOut.indent() << "mAllocation.setFromFieldPacker(index, fp);\n";
2586
2587 // End of if (copyNow)
2588 mOut.endBlock();
2589
2590 endFunction();
2591 }
2592
genTypeClassItemGetter(const RSExportRecordType * ERT)2593 void RSReflectionJava::genTypeClassItemGetter(const RSExportRecordType *ERT) {
2594 startFunction(AM_PublicSynchronized, false, RS_TYPE_ITEM_CLASS_NAME, "get", 1,
2595 "int", "index");
2596 mOut.indent() << "if (" << RS_TYPE_ITEM_BUFFER_NAME
2597 << " == null) return null;\n";
2598 mOut.indent() << "return " << RS_TYPE_ITEM_BUFFER_NAME << "[index];\n";
2599 endFunction();
2600 }
2601
2602 void
genTypeClassComponentSetter(const RSExportRecordType * ERT)2603 RSReflectionJava::genTypeClassComponentSetter(const RSExportRecordType *ERT) {
2604 const ReflectionState::Record32 Record32 = mState->getRecord32(ERT);
2605
2606 unsigned FieldNum = 0;
2607 for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
2608 FE = ERT->fields_end();
2609 FI != FE; FI++, FieldNum++) {
2610 const RSExportRecordType::Field *F = *FI;
2611 size_t FieldOffset = F->getOffsetInParent();
2612 size_t FieldStoreSize = F->getType()->getStoreSize();
2613 std::pair<unsigned, unsigned> FieldIndex = getFieldIndex(F);
2614
2615 const auto Field32OffsetAndStoreSize = Record32.getFieldOffsetAndStoreSize(FieldNum);
2616
2617 startFunction(AM_PublicSynchronized, false, "void", "set_" + F->getName(),
2618 3, "int", "index", GetTypeName(F->getType()).c_str(), "v",
2619 "boolean", "copyNow");
2620 genNewItemBufferPackerIfNull();
2621 genNewItemBufferIfNull("index");
2622 mOut.indent() << RS_TYPE_ITEM_BUFFER_NAME << "[index]." << F->getName()
2623 << " = v;\n";
2624
2625 mOut.indent() << "if (copyNow) ";
2626 mOut.startBlock();
2627
2628 mOut.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME << ".reset(index * "
2629 << mItemSizeof;
2630 genConditionalVal(" + ", true, FieldOffset, Field32OffsetAndStoreSize.first /* offset */);
2631 mOut << ");\n";
2632
2633 genPackVarOfType(F->getType(), "v", RS_TYPE_ITEM_BUFFER_PACKER_NAME);
2634
2635 mOut.indent() << "FieldPacker fp = new FieldPacker(";
2636 genConditionalVal("", false, FieldStoreSize, Field32OffsetAndStoreSize.second /* size */);
2637 mOut << ");\n";
2638
2639 genPackVarOfType(F->getType(), "v", "fp");
2640 mOut.indent() << "mAllocation.setFromFieldPacker(index, ";
2641 genConditionalVal("", false, FieldIndex.first,
2642 ReflectionState::Val32(Field32OffsetAndStoreSize.first.first, FieldIndex.second));
2643 mOut << ", fp);\n";
2644
2645 // End of if (copyNow)
2646 mOut.endBlock();
2647
2648 endFunction();
2649 }
2650 }
2651
2652 void
genTypeClassComponentGetter(const RSExportRecordType * ERT)2653 RSReflectionJava::genTypeClassComponentGetter(const RSExportRecordType *ERT) {
2654 for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
2655 FE = ERT->fields_end();
2656 FI != FE; FI++) {
2657 const RSExportRecordType::Field *F = *FI;
2658 startFunction(AM_PublicSynchronized, false,
2659 GetTypeName(F->getType()).c_str(), "get_" + F->getName(), 1,
2660 "int", "index");
2661 mOut.indent() << "if (" RS_TYPE_ITEM_BUFFER_NAME << " == null) return "
2662 << GetTypeNullValue(F->getType()) << ";\n";
2663 mOut.indent() << "return " RS_TYPE_ITEM_BUFFER_NAME << "[index]."
2664 << F->getName() << ";\n";
2665 endFunction();
2666 }
2667 }
2668
genTypeClassCopyAll(const RSExportRecordType * ERT)2669 void RSReflectionJava::genTypeClassCopyAll(const RSExportRecordType *ERT) {
2670 startFunction(AM_PublicSynchronized, false, "void", "copyAll", 0);
2671
2672 mOut.indent() << "for (int ct = 0; ct < " << RS_TYPE_ITEM_BUFFER_NAME
2673 << ".length; ct++)"
2674 << " copyToArray(" << RS_TYPE_ITEM_BUFFER_NAME
2675 << "[ct], ct);\n";
2676 mOut.indent() << "mAllocation.setFromFieldPacker(0, "
2677 << RS_TYPE_ITEM_BUFFER_PACKER_NAME ");\n";
2678
2679 endFunction();
2680 }
2681
genTypeClassResize()2682 void RSReflectionJava::genTypeClassResize() {
2683 startFunction(AM_PublicSynchronized, false, "void", "resize", 1, "int",
2684 "newSize");
2685
2686 mOut.indent() << "if (mItemArray != null) ";
2687 mOut.startBlock();
2688 mOut.indent() << "int oldSize = mItemArray.length;\n";
2689 mOut.indent() << "int copySize = Math.min(oldSize, newSize);\n";
2690 mOut.indent() << "if (newSize == oldSize) return;\n";
2691 mOut.indent() << "Item ni[] = new Item[newSize];\n";
2692 mOut.indent() << "System.arraycopy(mItemArray, 0, ni, 0, copySize);\n";
2693 mOut.indent() << "mItemArray = ni;\n";
2694 mOut.endBlock();
2695 mOut.indent() << "mAllocation.resize(newSize);\n";
2696
2697 mOut.indent() << "if (" RS_TYPE_ITEM_BUFFER_PACKER_NAME
2698 " != null) " RS_TYPE_ITEM_BUFFER_PACKER_NAME " = "
2699 "new FieldPacker(" << mItemSizeof << " * getType().getX()/* count */);\n";
2700
2701 endFunction();
2702 }
2703
2704 /******************** Methods to generate type class /end ********************/
2705
2706 /********** Methods to create Element in Java of given record type ***********/
2707
RSReflectionJavaElementBuilder(const char * ElementBuilderName,const RSExportRecordType * ERT,const char * RenderScriptVar,GeneratedFile * Out,const RSContext * RSContext,RSReflectionJava * Reflection,ReflectionState * RState)2708 RSReflectionJavaElementBuilder::RSReflectionJavaElementBuilder(
2709 const char *ElementBuilderName, const RSExportRecordType *ERT,
2710 const char *RenderScriptVar, GeneratedFile *Out, const RSContext *RSContext,
2711 RSReflectionJava *Reflection, ReflectionState *RState)
2712 : mElementBuilderName(ElementBuilderName), mERT(ERT),
2713 mRenderScriptVar(RenderScriptVar), mOut(Out), mPaddingFieldIndex(1),
2714 mRSContext(RSContext), mReflection(Reflection), mState(RState) {
2715 if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) {
2716 mPaddingPrefix = "#padding_";
2717 } else {
2718 mPaddingPrefix = "#rs_padding_";
2719 }
2720 }
2721
generate()2722 void RSReflectionJavaElementBuilder::generate() {
2723 mOut->indent() << "Element.Builder " << mElementBuilderName
2724 << " = new Element.Builder(" << mRenderScriptVar << ");\n";
2725 genAddElement(mERT, "", /* ArraySize = */ 0);
2726 }
2727
genAddElement(const RSExportType * ET,const std::string & VarName,unsigned ArraySize)2728 void RSReflectionJavaElementBuilder::genAddElement(const RSExportType *ET,
2729 const std::string &VarName,
2730 unsigned ArraySize) {
2731 std::string ElementConstruct = GetBuiltinElementConstruct(ET);
2732
2733 if (ElementConstruct != "") {
2734 genAddStatementStart();
2735 *mOut << ElementConstruct << "(" << mRenderScriptVar << ")";
2736 genAddStatementEnd(VarName, ArraySize);
2737 } else {
2738
2739 switch (ET->getClass()) {
2740 case RSExportType::ExportClassPrimitive: {
2741 const RSExportPrimitiveType *EPT =
2742 static_cast<const RSExportPrimitiveType *>(ET);
2743 const char *DataTypeName =
2744 RSExportPrimitiveType::getRSReflectionType(EPT)->rs_type;
2745 genAddStatementStart();
2746 *mOut << "Element.createUser(" << mRenderScriptVar
2747 << ", Element.DataType." << DataTypeName << ")";
2748 genAddStatementEnd(VarName, ArraySize);
2749 break;
2750 }
2751 case RSExportType::ExportClassVector: {
2752 const RSExportVectorType *EVT =
2753 static_cast<const RSExportVectorType *>(ET);
2754 const char *DataTypeName =
2755 RSExportPrimitiveType::getRSReflectionType(EVT)->rs_type;
2756 genAddStatementStart();
2757 *mOut << "Element.createVector(" << mRenderScriptVar
2758 << ", Element.DataType." << DataTypeName << ", "
2759 << EVT->getNumElement() << ")";
2760 genAddStatementEnd(VarName, ArraySize);
2761 break;
2762 }
2763 case RSExportType::ExportClassPointer:
2764 // Pointer type variable should be resolved in
2765 // GetBuiltinElementConstruct()
2766 slangAssert(false && "??");
2767 break;
2768 case RSExportType::ExportClassMatrix:
2769 // Matrix type variable should be resolved
2770 // in GetBuiltinElementConstruct()
2771 slangAssert(false && "??");
2772 break;
2773 case RSExportType::ExportClassConstantArray: {
2774 const RSExportConstantArrayType *ECAT =
2775 static_cast<const RSExportConstantArrayType *>(ET);
2776
2777 const RSExportType *ElementType = ECAT->getElementType();
2778 if (ElementType->getClass() != RSExportType::ExportClassRecord) {
2779 genAddElement(ECAT->getElementType(), VarName, ECAT->getNumElement());
2780 } else {
2781 slangAssert((ArraySize == 0) && "Cannot reflect multidimensional array types");
2782 ArraySize = ECAT->getNumElement();
2783 genAddStatementStart();
2784 *mOut << ElementType->getElementName() << ".createElement(" << mRenderScriptVar << ")";
2785 genAddStatementEnd(VarName, ArraySize);
2786 }
2787 break;
2788 }
2789 case RSExportType::ExportClassRecord: {
2790 // Simalar to case of RSExportType::ExportClassRecord in genPackVarOfType.
2791 //
2792 // TODO(zonr): Generalize these two function such that there's no
2793 // duplicated codes.
2794
2795 // Keep struct/field layout in sync with ReflectionState::declareRecord()
2796
2797 const RSExportRecordType *ERT =
2798 static_cast<const RSExportRecordType *>(ET);
2799 const ReflectionState::Record32 Record32 = mState->getRecord32(ERT);
2800
2801 int Pos = 0; // relative pos from now on
2802
2803 unsigned FieldNum = 0;
2804 for (RSExportRecordType::const_field_iterator I = ERT->fields_begin(),
2805 E = ERT->fields_end();
2806 I != E; I++, FieldNum++) {
2807 const RSExportRecordType::Field *F = *I;
2808 size_t FieldOffset = F->getOffsetInParent();
2809 const RSExportType *T = F->getType();
2810 size_t FieldStoreSize = T->getStoreSize();
2811 size_t FieldAllocSize = T->getAllocSize();
2812
2813 const auto Field32PreAndPostPadding = Record32.getFieldPreAndPostPadding(FieldNum);
2814
2815 std::string FieldName;
2816 if (!VarName.empty())
2817 FieldName = VarName + "." + F->getName();
2818 else
2819 FieldName = F->getName();
2820
2821 // Alignment
2822 genAddPadding(FieldOffset - Pos, Field32PreAndPostPadding.first /* pre */);
2823
2824 // eb.add(...)
2825 mReflection->addFieldIndexMapping(F);
2826 if (F->getType()->getClass() != RSExportType::ExportClassRecord) {
2827 genAddElement(F->getType(), FieldName, 0);
2828 } else {
2829 genAddStatementStart();
2830 *mOut << F->getType()->getElementName() << ".createElement(" << mRenderScriptVar << ")";
2831 genAddStatementEnd(FieldName, ArraySize);
2832 }
2833
2834 if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) {
2835 // There is padding within the field type. This is only necessary
2836 // for HC-targeted APIs.
2837 genAddPadding(FieldAllocSize - FieldStoreSize, Field32PreAndPostPadding.second /* post */);
2838 }
2839
2840 Pos = FieldOffset + FieldAllocSize;
2841 }
2842
2843 // There maybe some padding after the struct
2844 size_t RecordAllocSize = ERT->getAllocSize();
2845 genAddPadding(RecordAllocSize - Pos, Record32.getRecordPostPadding());
2846 break;
2847 }
2848 default:
2849 slangAssert(false && "Unknown class of type");
2850 break;
2851 }
2852 }
2853 }
2854
genAddPadding(int PaddingSize,unsigned Which)2855 void RSReflectionJavaElementBuilder::genAddPadding(int PaddingSize, unsigned Which) {
2856 while (PaddingSize > 0) {
2857 const std::string &VarName = createPaddingField();
2858 genAddStatementStart();
2859 if (PaddingSize >= 4) {
2860 *mOut << "Element.U32(" << mRenderScriptVar << ")";
2861 PaddingSize -= 4;
2862 } else if (PaddingSize >= 2) {
2863 *mOut << "Element.U16(" << mRenderScriptVar << ")";
2864 PaddingSize -= 2;
2865 } else if (PaddingSize >= 1) {
2866 *mOut << "Element.U8(" << mRenderScriptVar << ")";
2867 PaddingSize -= 1;
2868 }
2869 genAddStatementEnd(VarName, 0, Which);
2870 }
2871 }
2872
genAddPadding(int PaddingSize,ReflectionState::Val32 Field32PaddingSize)2873 void RSReflectionJavaElementBuilder::genAddPadding(int PaddingSize,
2874 ReflectionState::Val32 Field32PaddingSize) {
2875 if (!Field32PaddingSize.first || (PaddingSize == Field32PaddingSize.second)) {
2876 // Either we're ignoring the 32-bit case, or 32-bit and 64-bit
2877 // padding are the same.
2878 genAddPadding(PaddingSize, RSReflectionJava::FieldIndex | RSReflectionJava::Field32Index);
2879 return;
2880 }
2881
2882 // We cannot ignore the 32-bit case, and 32-bit and 64-bit padding differ.
2883
2884 if ((PaddingSize == 0) != (Field32PaddingSize.second == 0)) {
2885 // Only pad one of the two cases.
2886
2887 mOut->indent() << "if (";
2888 if (PaddingSize == 0)
2889 *mOut << '!';
2890 genCheck64Bit(PaddingSize == 0);
2891 *mOut << ')';
2892
2893 mOut->startBlock();
2894 if (PaddingSize != 0)
2895 genAddPadding(PaddingSize, RSReflectionJava::FieldIndex);
2896 else
2897 genAddPadding(Field32PaddingSize.second, RSReflectionJava::Field32Index);
2898 mOut->endBlock();
2899 return;
2900 }
2901
2902 // Pad both of the two cases, differently.
2903 mOut->indent() << "if (";
2904 genCheck64Bit(false);
2905 *mOut << ')';
2906 mOut->startBlock();
2907 genAddPadding(PaddingSize, RSReflectionJava::FieldIndex);
2908 mOut->endBlock();
2909 mOut->indent() << "else";
2910 mOut->startBlock();
2911 genAddPadding(Field32PaddingSize.second, RSReflectionJava::Field32Index);
2912 mOut->endBlock();
2913 }
2914
genAddStatementStart()2915 void RSReflectionJavaElementBuilder::genAddStatementStart() {
2916 mOut->indent() << mElementBuilderName << ".add(";
2917 }
2918
2919 void
genAddStatementEnd(const std::string & VarName,unsigned ArraySize,unsigned Which)2920 RSReflectionJavaElementBuilder::genAddStatementEnd(const std::string &VarName,
2921 unsigned ArraySize,
2922 unsigned Which) {
2923 *mOut << ", \"" << VarName << "\"";
2924 if (ArraySize > 0) {
2925 *mOut << ", " << ArraySize;
2926 }
2927 *mOut << ");\n";
2928 // TODO Review incFieldIndex. It's probably better to assign the numbers at
2929 // the start rather
2930 // than as we're generating the code.
2931 mReflection->incFieldIndex(Which);
2932 }
2933
2934 /******** Methods to create Element in Java of given record type /end ********/
2935
reflect()2936 bool RSReflectionJava::reflect() {
2937 // Note that we may issue declareRecord() in many places during the
2938 // reflection process.
2939 mState->beginRecords();
2940
2941 std::string ErrorMsg;
2942 if (!genScriptClass(mScriptClassName, ErrorMsg)) {
2943 std::cerr << "Failed to generate class " << mScriptClassName << " ("
2944 << ErrorMsg << ")\n";
2945 return false;
2946 }
2947
2948 // class ScriptField_<TypeName>
2949 for (RSContext::const_export_type_iterator
2950 TI = mRSContext->export_types_begin(),
2951 TE = mRSContext->export_types_end();
2952 TI != TE; TI++) {
2953 const RSExportType *ET = TI->getValue();
2954
2955 if (ET->getClass() == RSExportType::ExportClassRecord) {
2956 const RSExportRecordType *ERT =
2957 static_cast<const RSExportRecordType *>(ET);
2958
2959 if (!ERT->isArtificial() && !genTypeClass(ERT, ErrorMsg)) {
2960 std::cerr << "Failed to generate type class for struct '"
2961 << ERT->getName() << "' (" << ErrorMsg << ")\n";
2962 return false;
2963 }
2964 }
2965 }
2966
2967 mState->endRecords();
2968
2969 return true;
2970 }
2971
AccessModifierStr(AccessModifier AM)2972 const char *RSReflectionJava::AccessModifierStr(AccessModifier AM) {
2973 switch (AM) {
2974 case AM_Public:
2975 return "public";
2976 break;
2977 case AM_Protected:
2978 return "protected";
2979 break;
2980 case AM_Private:
2981 return "private";
2982 break;
2983 case AM_PublicSynchronized:
2984 return "public synchronized";
2985 break;
2986 default:
2987 return "";
2988 break;
2989 }
2990 }
2991
startClass(AccessModifier AM,bool IsStatic,const std::string & ClassName,const char * SuperClassName,std::string & ErrorMsg)2992 bool RSReflectionJava::startClass(AccessModifier AM, bool IsStatic,
2993 const std::string &ClassName,
2994 const char *SuperClassName,
2995 std::string &ErrorMsg) {
2996 // Open file for class
2997 std::string FileName = ClassName + ".java";
2998 if (!mOut.startFile(mOutputDirectory, FileName, mRSSourceFileName,
2999 mRSContext->getLicenseNote(), true,
3000 mRSContext->getVerbose())) {
3001 return false;
3002 }
3003
3004 // Package
3005 if (!mPackageName.empty()) {
3006 mOut << "package " << mPackageName << ";\n";
3007 }
3008 mOut << "\n";
3009
3010 // Imports
3011 //
3012 // The first few imports are only needed for divergent classes, but
3013 // at this point we don't know whether we are emitting a divergent
3014 // class.
3015 //
3016 if (!mRSContext->isCompatLib()) {
3017 mOut << "import android.os.Build;\n";
3018 mOut << "import android.os.Process;\n";
3019 mOut << "import java.lang.reflect.Field;\n";
3020 }
3021 // (End of imports needed for divergent classes.)
3022 mOut << "import " << mRSPackageName << ".*;\n";
3023 if (getEmbedBitcodeInJava()) {
3024 mOut << "import " << mPackageName << "."
3025 << RSSlangReflectUtils::JavaBitcodeClassNameFromRSFileName(
3026 mRSSourceFileName.c_str()) << ";\n";
3027 } else {
3028 mOut << "import android.content.res.Resources;\n";
3029 }
3030 mOut << "\n";
3031
3032 // All reflected classes should be annotated as hidden, so that they won't
3033 // be exposed in SDK.
3034 mOut << "/**\n";
3035 mOut << " * @hide\n";
3036 mOut << " */\n";
3037
3038 mOut << AccessModifierStr(AM) << ((IsStatic) ? " static" : "") << " class "
3039 << ClassName;
3040 if (SuperClassName != nullptr)
3041 mOut << " extends " << SuperClassName;
3042
3043 mOut.startBlock();
3044
3045 mClassName = ClassName;
3046
3047 return true;
3048 }
3049
endClass()3050 void RSReflectionJava::endClass() {
3051 mOut.endBlock();
3052 mOut.closeFile();
3053 clear();
3054 }
3055
startTypeClass(const std::string & ClassName)3056 void RSReflectionJava::startTypeClass(const std::string &ClassName) {
3057 mOut.indent() << "public static class " << ClassName;
3058 mOut.startBlock();
3059 }
3060
endTypeClass()3061 void RSReflectionJava::endTypeClass() { mOut.endBlock(); }
3062
startFunction(AccessModifier AM,bool IsStatic,const char * ReturnType,const std::string & FunctionName,int Argc,...)3063 void RSReflectionJava::startFunction(AccessModifier AM, bool IsStatic,
3064 const char *ReturnType,
3065 const std::string &FunctionName, int Argc,
3066 ...) {
3067 ArgTy Args;
3068 va_list vl;
3069 va_start(vl, Argc);
3070
3071 for (int i = 0; i < Argc; i++) {
3072 const char *ArgType = va_arg(vl, const char *);
3073 const char *ArgName = va_arg(vl, const char *);
3074
3075 Args.push_back(std::make_pair(ArgType, ArgName));
3076 }
3077 va_end(vl);
3078
3079 startFunction(AM, IsStatic, ReturnType, FunctionName, Args);
3080 }
3081
startFunction(AccessModifier AM,bool IsStatic,const char * ReturnType,const std::string & FunctionName,const ArgTy & Args)3082 void RSReflectionJava::startFunction(AccessModifier AM, bool IsStatic,
3083 const char *ReturnType,
3084 const std::string &FunctionName,
3085 const ArgTy &Args) {
3086 mOut.indent() << AccessModifierStr(AM) << ((IsStatic) ? " static " : " ")
3087 << ((ReturnType) ? ReturnType : "") << " " << FunctionName
3088 << "(";
3089
3090 bool FirstArg = true;
3091 for (ArgTy::const_iterator I = Args.begin(), E = Args.end(); I != E; I++) {
3092 if (!FirstArg)
3093 mOut << ", ";
3094 else
3095 FirstArg = false;
3096
3097 mOut << I->first << " " << I->second;
3098 }
3099
3100 mOut << ")";
3101 mOut.startBlock();
3102 }
3103
endFunction()3104 void RSReflectionJava::endFunction() { mOut.endBlock(); }
3105
addTypeNameForElement(const std::string & TypeName)3106 bool RSReflectionJava::addTypeNameForElement(const std::string &TypeName) {
3107 if (mTypesToCheck.find(TypeName) == mTypesToCheck.end()) {
3108 mTypesToCheck.insert(TypeName);
3109 return true;
3110 } else {
3111 return false;
3112 }
3113 }
3114
addTypeNameForFieldPacker(const std::string & TypeName)3115 bool RSReflectionJava::addTypeNameForFieldPacker(const std::string &TypeName) {
3116 if (mFieldPackerTypes.find(TypeName) == mFieldPackerTypes.end()) {
3117 mFieldPackerTypes.insert(TypeName);
3118 return true;
3119 } else {
3120 return false;
3121 }
3122 }
3123
3124 } // namespace slang
3125