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 placeholder 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   // Validity-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, InName);
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