• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2010-2012, 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_export_type.h"
18 
19 #include <list>
20 #include <vector>
21 
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/Attr.h"
24 #include "clang/AST/RecordLayout.h"
25 
26 #include "llvm/ADT/StringExtras.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/Type.h"
30 
31 #include "slang_assert.h"
32 #include "slang_rs_context.h"
33 #include "slang_rs_export_element.h"
34 #include "slang_version.h"
35 
36 #define CHECK_PARENT_EQUALITY(ParentClass, E) \
37   if (!ParentClass::matchODR(E, true))        \
38     return false;
39 
40 namespace slang {
41 
42 namespace {
43 
44 // For the data types we support:
45 //  Category      - data type category
46 //  SName         - "common name" in script (C99)
47 //  RsType        - element name in RenderScript
48 //  RsShortType   - short element name in RenderScript
49 //  SizeInBits    - size in bits
50 //  CName         - reflected C name
51 //  JavaName      - reflected Java name
52 //  JavaArrayElementName - reflected name in Java arrays
53 //  CVecName      - prefix for C vector types
54 //  JavaVecName   - prefix for Java vector type
55 //  JavaPromotion - unsigned type undergoing Java promotion
56 //
57 // IMPORTANT: The data types in this table should be at the same index as
58 // specified by the corresponding DataType enum.
59 //
60 // TODO: Pull this information out into a separate file.
61 static RSReflectionType gReflectionTypes[] = {
62 #define _ nullptr
63   //      Category     SName              RsType       RsST           CName         JN      JAEN       CVN       JVN     JP
64 {PrimitiveDataType,   "half",         "FLOAT_16",     "F16", 16,     "half",   "short",  "short",   "Half",  "Short", false},
65 {PrimitiveDataType,  "float",         "FLOAT_32",     "F32", 32,    "float",   "float",  "float",  "Float",  "Float", false},
66 {PrimitiveDataType, "double",         "FLOAT_64",     "F64", 64,   "double",  "double", "double", "Double", "Double", false},
67 {PrimitiveDataType,   "char",         "SIGNED_8",      "I8",  8,   "int8_t",    "byte",   "byte",   "Byte",   "Byte", false},
68 {PrimitiveDataType,  "short",        "SIGNED_16",     "I16", 16,  "int16_t",   "short",  "short",  "Short",  "Short", false},
69 {PrimitiveDataType,    "int",        "SIGNED_32",     "I32", 32,  "int32_t",     "int",    "int",    "Int",    "Int", false},
70 {PrimitiveDataType,   "long",        "SIGNED_64",     "I64", 64,  "int64_t",    "long",   "long",   "Long",   "Long", false},
71 {PrimitiveDataType,  "uchar",       "UNSIGNED_8",      "U8",  8,  "uint8_t",   "short",   "byte",  "UByte",  "Short",  true},
72 {PrimitiveDataType, "ushort",      "UNSIGNED_16",     "U16", 16, "uint16_t",     "int",  "short", "UShort",    "Int",  true},
73 {PrimitiveDataType,   "uint",      "UNSIGNED_32",     "U32", 32, "uint32_t",    "long",    "int",   "UInt",   "Long",  true},
74 {PrimitiveDataType,  "ulong",      "UNSIGNED_64",     "U64", 64, "uint64_t",    "long",   "long",  "ULong",   "Long", false},
75 {PrimitiveDataType,   "bool",          "BOOLEAN", "BOOLEAN",  8,     "bool", "boolean",   "byte",        _,        _, false},
76 {PrimitiveDataType,        _,   "UNSIGNED_5_6_5",         _, 16,          _,         _,        _,        _,        _, false},
77 {PrimitiveDataType,        _, "UNSIGNED_5_5_5_1",         _, 16,          _,         _,        _,        _,        _, false},
78 {PrimitiveDataType,        _, "UNSIGNED_4_4_4_4",         _, 16,          _,         _,        _,        _,        _, false},
79 
80 {MatrixDataType, "rs_matrix2x2", "MATRIX_2X2", _,  4*32, "rs_matrix2x2", "Matrix2f", _, _, _, false},
81 {MatrixDataType, "rs_matrix3x3", "MATRIX_3X3", _,  9*32, "rs_matrix3x3", "Matrix3f", _, _, _, false},
82 {MatrixDataType, "rs_matrix4x4", "MATRIX_4X4", _, 16*32, "rs_matrix4x4", "Matrix4f", _, _, _, false},
83 
84 // RS object types are 32 bits in 32-bit RS, but 256 bits in 64-bit RS.
85 // This is handled specially by the GetElementSizeInBits() method.
86 {ObjectDataType, _,          "RS_ELEMENT",          "ELEMENT", 32,         "Element",         "Element", _, _, _, false},
87 {ObjectDataType, _,             "RS_TYPE",             "TYPE", 32,            "Type",            "Type", _, _, _, false},
88 {ObjectDataType, _,       "RS_ALLOCATION",       "ALLOCATION", 32,      "Allocation",      "Allocation", _, _, _, false},
89 {ObjectDataType, _,          "RS_SAMPLER",          "SAMPLER", 32,         "Sampler",         "Sampler", _, _, _, false},
90 {ObjectDataType, _,           "RS_SCRIPT",           "SCRIPT", 32,          "Script",          "Script", _, _, _, false},
91 {ObjectDataType, _,             "RS_MESH",             "MESH", 32,            "Mesh",            "Mesh", _, _, _, false},
92 {ObjectDataType, _,             "RS_PATH",             "PATH", 32,            "Path",            "Path", _, _, _, false},
93 {ObjectDataType, _, "RS_PROGRAM_FRAGMENT", "PROGRAM_FRAGMENT", 32, "ProgramFragment", "ProgramFragment", _, _, _, false},
94 {ObjectDataType, _,   "RS_PROGRAM_VERTEX",   "PROGRAM_VERTEX", 32,   "ProgramVertex",   "ProgramVertex", _, _, _, false},
95 {ObjectDataType, _,   "RS_PROGRAM_RASTER",   "PROGRAM_RASTER", 32,   "ProgramRaster",   "ProgramRaster", _, _, _, false},
96 {ObjectDataType, _,    "RS_PROGRAM_STORE",    "PROGRAM_STORE", 32,    "ProgramStore",    "ProgramStore", _, _, _, false},
97 {ObjectDataType, _,             "RS_FONT",             "FONT", 32,            "Font",            "Font", _, _, _, false},
98 #undef _
99 };
100 
101 const int kMaxVectorSize = 4;
102 
103 struct BuiltinInfo {
104   clang::BuiltinType::Kind builtinTypeKind;
105   DataType type;
106   /* TODO If we return std::string instead of llvm::StringRef, we could build
107    * the name instead of duplicating the entries.
108    */
109   const char *cname[kMaxVectorSize];
110 };
111 
112 
113 BuiltinInfo BuiltinInfoTable[] = {
114     {clang::BuiltinType::Bool, DataTypeBoolean,
115      {"bool", "bool2", "bool3", "bool4"}},
116     {clang::BuiltinType::Char_U, DataTypeUnsigned8,
117      {"uchar", "uchar2", "uchar3", "uchar4"}},
118     {clang::BuiltinType::UChar, DataTypeUnsigned8,
119      {"uchar", "uchar2", "uchar3", "uchar4"}},
120     {clang::BuiltinType::Char16, DataTypeSigned16,
121      {"short", "short2", "short3", "short4"}},
122     {clang::BuiltinType::Char32, DataTypeSigned32,
123      {"int", "int2", "int3", "int4"}},
124     {clang::BuiltinType::UShort, DataTypeUnsigned16,
125      {"ushort", "ushort2", "ushort3", "ushort4"}},
126     {clang::BuiltinType::UInt, DataTypeUnsigned32,
127      {"uint", "uint2", "uint3", "uint4"}},
128     {clang::BuiltinType::ULong, DataTypeUnsigned64,
129      {"ulong", "ulong2", "ulong3", "ulong4"}},
130     {clang::BuiltinType::ULongLong, DataTypeUnsigned64,
131      {"ulong", "ulong2", "ulong3", "ulong4"}},
132 
133     {clang::BuiltinType::Char_S, DataTypeSigned8,
134      {"char", "char2", "char3", "char4"}},
135     {clang::BuiltinType::SChar, DataTypeSigned8,
136      {"char", "char2", "char3", "char4"}},
137     {clang::BuiltinType::Short, DataTypeSigned16,
138      {"short", "short2", "short3", "short4"}},
139     {clang::BuiltinType::Int, DataTypeSigned32,
140      {"int", "int2", "int3", "int4"}},
141     {clang::BuiltinType::Long, DataTypeSigned64,
142      {"long", "long2", "long3", "long4"}},
143     {clang::BuiltinType::LongLong, DataTypeSigned64,
144      {"long", "long2", "long3", "long4"}},
145     {clang::BuiltinType::Half, DataTypeFloat16,
146      {"half", "half2", "half3", "half4"}},
147     {clang::BuiltinType::Float, DataTypeFloat32,
148      {"float", "float2", "float3", "float4"}},
149     {clang::BuiltinType::Double, DataTypeFloat64,
150      {"double", "double2", "double3", "double4"}},
151 };
152 const int BuiltinInfoTableCount = sizeof(BuiltinInfoTable) / sizeof(BuiltinInfoTable[0]);
153 
154 struct NameAndPrimitiveType {
155   const char *name;
156   DataType dataType;
157 };
158 
159 static NameAndPrimitiveType MatrixAndObjectDataTypes[] = {
160     {"rs_matrix2x2", DataTypeRSMatrix2x2},
161     {"rs_matrix3x3", DataTypeRSMatrix3x3},
162     {"rs_matrix4x4", DataTypeRSMatrix4x4},
163     {"rs_element", DataTypeRSElement},
164     {"rs_type", DataTypeRSType},
165     {"rs_allocation", DataTypeRSAllocation},
166     {"rs_sampler", DataTypeRSSampler},
167     {"rs_script", DataTypeRSScript},
168     {"rs_mesh", DataTypeRSMesh},
169     {"rs_path", DataTypeRSPath},
170     {"rs_program_fragment", DataTypeRSProgramFragment},
171     {"rs_program_vertex", DataTypeRSProgramVertex},
172     {"rs_program_raster", DataTypeRSProgramRaster},
173     {"rs_program_store", DataTypeRSProgramStore},
174     {"rs_font", DataTypeRSFont},
175 };
176 
177 const int MatrixAndObjectDataTypesCount =
178     sizeof(MatrixAndObjectDataTypes) / sizeof(MatrixAndObjectDataTypes[0]);
179 
180 static const clang::Type *TypeExportableHelper(
181     const clang::Type *T,
182     llvm::SmallPtrSet<const clang::Type*, 8>& SPS,
183     slang::RSContext *Context,
184     const clang::VarDecl *VD,
185     const clang::RecordDecl *TopLevelRecord,
186     ExportKind EK);
187 
188 template <unsigned N>
ReportTypeError(slang::RSContext * Context,const clang::NamedDecl * ND,const clang::RecordDecl * TopLevelRecord,const char (& Message)[N],unsigned int TargetAPI=0)189 static void ReportTypeError(slang::RSContext *Context,
190                             const clang::NamedDecl *ND,
191                             const clang::RecordDecl *TopLevelRecord,
192                             const char (&Message)[N],
193                             unsigned int TargetAPI = 0) {
194   // Attempt to use the type declaration first (if we have one).
195   // Fall back to the variable definition, if we are looking at something
196   // like an array declaration that can't be exported.
197   if (TopLevelRecord) {
198     Context->ReportError(TopLevelRecord->getLocation(), Message)
199         << TopLevelRecord->getName() << TargetAPI;
200   } else if (ND) {
201     Context->ReportError(ND->getLocation(), Message) << ND->getName()
202                                                      << TargetAPI;
203   } else {
204     slangAssert(false && "Variables should be validated before exporting");
205   }
206 }
207 
ConstantArrayTypeExportableHelper(const clang::ConstantArrayType * CAT,llvm::SmallPtrSet<const clang::Type *,8> & SPS,slang::RSContext * Context,const clang::VarDecl * VD,const clang::RecordDecl * TopLevelRecord,ExportKind EK)208 static const clang::Type *ConstantArrayTypeExportableHelper(
209     const clang::ConstantArrayType *CAT,
210     llvm::SmallPtrSet<const clang::Type*, 8>& SPS,
211     slang::RSContext *Context,
212     const clang::VarDecl *VD,
213     const clang::RecordDecl *TopLevelRecord,
214     ExportKind EK) {
215   // Check element type
216   const clang::Type *ElementType = GetConstantArrayElementType(CAT);
217   if (ElementType->isArrayType()) {
218     ReportTypeError(Context, VD, TopLevelRecord,
219                     "multidimensional arrays cannot be exported: '%0'");
220     return nullptr;
221   } else if (ElementType->isExtVectorType()) {
222     const clang::ExtVectorType *EVT =
223         static_cast<const clang::ExtVectorType*>(ElementType);
224     unsigned numElements = EVT->getNumElements();
225 
226     const clang::Type *BaseElementType = GetExtVectorElementType(EVT);
227     if (!RSExportPrimitiveType::IsPrimitiveType(BaseElementType)) {
228       ReportTypeError(Context, VD, TopLevelRecord,
229         "vectors of non-primitive types cannot be exported: '%0'");
230       return nullptr;
231     }
232 
233     if (numElements == 3 && CAT->getSize() != 1) {
234       ReportTypeError(Context, VD, TopLevelRecord,
235         "arrays of width 3 vector types cannot be exported: '%0'");
236       return nullptr;
237     }
238   }
239 
240   if (TypeExportableHelper(ElementType, SPS, Context, VD,
241                            TopLevelRecord, EK) == nullptr) {
242     return nullptr;
243   } else {
244     return CAT;
245   }
246 }
247 
FindBuiltinType(clang::BuiltinType::Kind builtinTypeKind)248 BuiltinInfo *FindBuiltinType(clang::BuiltinType::Kind builtinTypeKind) {
249   for (int i = 0; i < BuiltinInfoTableCount; i++) {
250     if (builtinTypeKind == BuiltinInfoTable[i].builtinTypeKind) {
251       return &BuiltinInfoTable[i];
252     }
253   }
254   return nullptr;
255 }
256 
TypeExportableHelper(clang::Type const * T,llvm::SmallPtrSet<clang::Type const *,8> & SPS,slang::RSContext * Context,clang::VarDecl const * VD,clang::RecordDecl const * TopLevelRecord,ExportKind EK)257 static const clang::Type *TypeExportableHelper(
258     clang::Type const *T,
259     llvm::SmallPtrSet<clang::Type const *, 8> &SPS,
260     slang::RSContext *Context,
261     clang::VarDecl const *VD,
262     clang::RecordDecl const *TopLevelRecord,
263     ExportKind EK) {
264   // Normalize first
265   if ((T = GetCanonicalType(T)) == nullptr)
266     return nullptr;
267 
268   if (SPS.count(T))
269     return T;
270 
271   const clang::Type *CTI = T->getCanonicalTypeInternal().getTypePtr();
272 
273   switch (T->getTypeClass()) {
274     case clang::Type::Builtin: {
275       const clang::BuiltinType *BT = static_cast<const clang::BuiltinType*>(CTI);
276       return FindBuiltinType(BT->getKind()) == nullptr ? nullptr : T;
277     }
278     case clang::Type::Record: {
279       if (RSExportPrimitiveType::GetRSSpecificType(T) != DataTypeUnknown) {
280         return T;  // RS object type, no further checks are needed
281       }
282 
283       // Check internal struct
284       if (T->isUnionType()) {
285         ReportTypeError(Context, VD, T->getAsUnionType()->getDecl(),
286                         "unions cannot be exported: '%0'");
287         return nullptr;
288       } else if (!T->isStructureType()) {
289         slangAssert(false && "Unknown type cannot be exported");
290         return nullptr;
291       }
292 
293       clang::RecordDecl *RD = T->getAsStructureType()->getDecl();
294       if (RD != nullptr) {
295         RD = RD->getDefinition();
296         if (RD == nullptr) {
297           ReportTypeError(Context, nullptr, T->getAsStructureType()->getDecl(),
298                           "struct is not defined in this module");
299           return nullptr;
300         }
301       }
302 
303       if (!TopLevelRecord) {
304         TopLevelRecord = RD;
305       }
306       if (RD->getName().empty()) {
307         ReportTypeError(Context, nullptr, RD,
308                         "anonymous structures cannot be exported");
309         return nullptr;
310       }
311 
312       // Fast check
313       if (RD->hasFlexibleArrayMember() || RD->hasObjectMember())
314         return nullptr;
315 
316       // Insert myself into checking set
317       SPS.insert(T);
318 
319       // Check all element
320       for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
321                FE = RD->field_end();
322            FI != FE;
323            FI++) {
324         const clang::FieldDecl *FD = *FI;
325         const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
326         FT = GetCanonicalType(FT);
327 
328         if (!TypeExportableHelper(FT, SPS, Context, VD, TopLevelRecord,
329                                   EK)) {
330           return nullptr;
331         }
332 
333         // We don't support bit fields yet
334         //
335         // TODO(zonr/srhines): allow bit fields of size 8, 16, 32
336         if (FD->isBitField()) {
337           Context->ReportError(
338               FD->getLocation(),
339               "bit fields are not able to be exported: '%0.%1'")
340               << RD->getName() << FD->getName();
341           return nullptr;
342         }
343       }
344 
345       return T;
346     }
347     case clang::Type::FunctionProto:
348     case clang::Type::FunctionNoProto:
349       ReportTypeError(Context, VD, TopLevelRecord,
350                       "function types cannot be exported: '%0'");
351       return nullptr;
352     case clang::Type::Pointer: {
353       if (TopLevelRecord) {
354         ReportTypeError(Context, VD, TopLevelRecord,
355             "structures containing pointers cannot be used as the type of "
356             "an exported global variable or the parameter to an exported "
357             "function: '%0'");
358         return nullptr;
359       }
360 
361       const clang::PointerType *PT = static_cast<const clang::PointerType*>(CTI);
362       const clang::Type *PointeeType = GetPointeeType(PT);
363 
364       if (PointeeType->getTypeClass() == clang::Type::Pointer) {
365         ReportTypeError(Context, VD, TopLevelRecord,
366             "multiple levels of pointers cannot be exported: '%0'");
367         return nullptr;
368       }
369 
370       // Void pointers are forbidden for export, although we must accept
371       // void pointers that come in as arguments to a legacy kernel.
372       if (PointeeType->isVoidType() && EK != LegacyKernelArgument) {
373         ReportTypeError(Context, VD, TopLevelRecord,
374             "void pointers cannot be exported: '%0'");
375         return nullptr;
376       }
377 
378       // We don't support pointer with array-type pointee
379       if (PointeeType->isArrayType()) {
380         ReportTypeError(Context, VD, TopLevelRecord,
381             "pointers to arrays cannot be exported: '%0'");
382         return nullptr;
383       }
384 
385       // Check for unsupported pointee type
386       if (TypeExportableHelper(PointeeType, SPS, Context, VD,
387                                 TopLevelRecord, EK) == nullptr)
388         return nullptr;
389       else
390         return T;
391     }
392     case clang::Type::ExtVector: {
393       const clang::ExtVectorType *EVT =
394               static_cast<const clang::ExtVectorType*>(CTI);
395       // Only vector with size 2, 3 and 4 are supported.
396       if (EVT->getNumElements() < 2 || EVT->getNumElements() > 4)
397         return nullptr;
398 
399       // Check base element type
400       const clang::Type *ElementType = GetExtVectorElementType(EVT);
401 
402       if ((ElementType->getTypeClass() != clang::Type::Builtin) ||
403           (TypeExportableHelper(ElementType, SPS, Context, VD,
404                                 TopLevelRecord, EK) == nullptr))
405         return nullptr;
406       else
407         return T;
408     }
409     case clang::Type::ConstantArray: {
410       const clang::ConstantArrayType *CAT =
411               static_cast<const clang::ConstantArrayType*>(CTI);
412 
413       return ConstantArrayTypeExportableHelper(CAT, SPS, Context, VD,
414                                                TopLevelRecord, EK);
415     }
416     case clang::Type::Enum: {
417       // FIXME: We currently convert enums to integers, rather than reflecting
418       // a more complete (and nicer type-safe Java version).
419       return Context->getASTContext().IntTy.getTypePtr();
420     }
421     default: {
422       slangAssert(false && "Unknown type cannot be validated");
423       return nullptr;
424     }
425   }
426 }
427 
428 // Return the type that can be used to create RSExportType, will always return
429 // the canonical type.
430 //
431 // If the Type T is not exportable, this function returns nullptr. DiagEngine is
432 // used to generate proper Clang diagnostic messages when a non-exportable type
433 // is detected. TopLevelRecord is used to capture the highest struct (in the
434 // case of a nested hierarchy) for detecting other types that cannot be exported
435 // (mostly pointers within a struct).
TypeExportable(const clang::Type * T,slang::RSContext * Context,const clang::VarDecl * VD,ExportKind EK)436 static const clang::Type *TypeExportable(const clang::Type *T,
437                                          slang::RSContext *Context,
438                                          const clang::VarDecl *VD,
439                                          ExportKind EK) {
440   llvm::SmallPtrSet<const clang::Type*, 8> SPS =
441       llvm::SmallPtrSet<const clang::Type*, 8>();
442 
443   return TypeExportableHelper(T, SPS, Context, VD, nullptr, EK);
444 }
445 
ValidateRSObjectInVarDecl(slang::RSContext * Context,const clang::VarDecl * VD,bool InCompositeType,unsigned int TargetAPI)446 static bool ValidateRSObjectInVarDecl(slang::RSContext *Context,
447                                       const clang::VarDecl *VD, bool InCompositeType,
448                                       unsigned int TargetAPI) {
449   if (TargetAPI < SLANG_JB_TARGET_API) {
450     // Only if we are already in a composite type (like an array or structure).
451     if (InCompositeType) {
452       // Only if we are actually exported (i.e. non-static).
453       if (VD->hasLinkage() &&
454           (VD->getFormalLinkage() == clang::ExternalLinkage)) {
455         // Only if we are not a pointer to an object.
456         const clang::Type *T = GetCanonicalType(VD->getType().getTypePtr());
457         if (T->getTypeClass() != clang::Type::Pointer) {
458           ReportTypeError(Context, VD, nullptr,
459                           "arrays/structures containing RS object types "
460                           "cannot be exported in target API < %1: '%0'",
461                           SLANG_JB_TARGET_API);
462           return false;
463         }
464       }
465     }
466   }
467 
468   return true;
469 }
470 
471 // Helper function for ValidateType(). We do a recursive descent on the
472 // type hierarchy to ensure that we can properly export/handle the
473 // declaration.
474 // \return true if the variable declaration is valid,
475 //         false if it is invalid (along with proper diagnostics).
476 //
477 // C - ASTContext (for diagnostics + builtin types).
478 // T - sub-type that we are validating.
479 // ND - (optional) top-level named declaration that we are validating.
480 // SPS - set of types we have already seen/validated.
481 // InCompositeType - true if we are within an outer composite type.
482 // UnionDecl - set if we are in a sub-type of a union.
483 // TargetAPI - target SDK API level.
484 // IsFilterscript - whether or not we are compiling for Filterscript
485 // IsExtern - is this type externally visible (i.e. extern global or parameter
486 //                                             to an extern function)
ValidateTypeHelper(slang::RSContext * Context,clang::ASTContext & C,const clang::Type * & T,const clang::NamedDecl * ND,clang::SourceLocation Loc,llvm::SmallPtrSet<const clang::Type *,8> & SPS,bool InCompositeType,clang::RecordDecl * UnionDecl,unsigned int TargetAPI,bool IsFilterscript,bool IsExtern)487 static bool ValidateTypeHelper(
488     slang::RSContext *Context,
489     clang::ASTContext &C,
490     const clang::Type *&T,
491     const clang::NamedDecl *ND,
492     clang::SourceLocation Loc,
493     llvm::SmallPtrSet<const clang::Type*, 8>& SPS,
494     bool InCompositeType,
495     clang::RecordDecl *UnionDecl,
496     unsigned int TargetAPI,
497     bool IsFilterscript,
498     bool IsExtern) {
499   if ((T = GetCanonicalType(T)) == nullptr)
500     return true;
501 
502   if (SPS.count(T))
503     return true;
504 
505   const clang::Type *CTI = T->getCanonicalTypeInternal().getTypePtr();
506 
507   switch (T->getTypeClass()) {
508     case clang::Type::Record: {
509       if (RSExportPrimitiveType::IsRSObjectType(T)) {
510         const clang::VarDecl *VD = (ND ? llvm::dyn_cast<clang::VarDecl>(ND) : nullptr);
511         if (VD && !ValidateRSObjectInVarDecl(Context, VD, InCompositeType,
512                                              TargetAPI)) {
513           return false;
514         }
515       }
516 
517       if (RSExportPrimitiveType::GetRSSpecificType(T) != DataTypeUnknown) {
518         if (!UnionDecl) {
519           return true;
520         } else if (RSExportPrimitiveType::IsRSObjectType(T)) {
521           ReportTypeError(Context, nullptr, UnionDecl,
522               "unions containing RS object types are not allowed");
523           return false;
524         }
525       }
526 
527       clang::RecordDecl *RD = nullptr;
528 
529       // Check internal struct
530       if (T->isUnionType()) {
531         RD = T->getAsUnionType()->getDecl();
532         UnionDecl = RD;
533       } else if (T->isStructureType()) {
534         RD = T->getAsStructureType()->getDecl();
535       } else {
536         slangAssert(false && "Unknown type cannot be exported");
537         return false;
538       }
539 
540       if (RD != nullptr) {
541         RD = RD->getDefinition();
542         if (RD == nullptr) {
543           // FIXME
544           return true;
545         }
546       }
547 
548       // Fast check
549       if (RD->hasFlexibleArrayMember() || RD->hasObjectMember())
550         return false;
551 
552       // Insert myself into checking set
553       SPS.insert(T);
554 
555       // Check all elements
556       for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
557                FE = RD->field_end();
558            FI != FE;
559            FI++) {
560         const clang::FieldDecl *FD = *FI;
561         const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
562         FT = GetCanonicalType(FT);
563 
564         if (!ValidateTypeHelper(Context, C, FT, ND, Loc, SPS, true, UnionDecl,
565                                 TargetAPI, IsFilterscript, IsExtern)) {
566           return false;
567         }
568       }
569 
570       return true;
571     }
572 
573     case clang::Type::Builtin: {
574       if (IsFilterscript) {
575         clang::QualType QT = T->getCanonicalTypeInternal();
576         if (QT == C.DoubleTy ||
577             QT == C.LongDoubleTy ||
578             QT == C.LongTy ||
579             QT == C.LongLongTy) {
580           if (ND) {
581             Context->ReportError(
582                 Loc,
583                 "Builtin types > 32 bits in size are forbidden in "
584                 "Filterscript: '%0'")
585                 << ND->getName();
586           } else {
587             Context->ReportError(
588                 Loc,
589                 "Builtin types > 32 bits in size are forbidden in "
590                 "Filterscript");
591           }
592           return false;
593         }
594       }
595       break;
596     }
597 
598     case clang::Type::Pointer: {
599       if (IsFilterscript) {
600         if (ND) {
601           Context->ReportError(Loc,
602                                "Pointers are forbidden in Filterscript: '%0'")
603               << ND->getName();
604           return false;
605         } else {
606           // TODO(srhines): Find a better way to handle expressions (i.e. no
607           // NamedDecl) involving pointers in FS that should be allowed.
608           // An example would be calls to library functions like
609           // rsMatrixMultiply() that take rs_matrixNxN * types.
610         }
611       }
612 
613       // Forbid pointers in structures that are externally visible.
614       if (InCompositeType && IsExtern) {
615         if (ND) {
616           Context->ReportError(Loc,
617               "structures containing pointers cannot be used as the type of "
618               "an exported global variable or the parameter to an exported "
619               "function: '%0'")
620             << ND->getName();
621         } else {
622           Context->ReportError(Loc,
623               "structures containing pointers cannot be used as the type of "
624               "an exported global variable or the parameter to an exported "
625               "function");
626         }
627         return false;
628       }
629 
630       const clang::PointerType *PT = static_cast<const clang::PointerType*>(CTI);
631       const clang::Type *PointeeType = GetPointeeType(PT);
632 
633       return ValidateTypeHelper(Context, C, PointeeType, ND, Loc, SPS,
634                                 InCompositeType, UnionDecl, TargetAPI,
635                                 IsFilterscript, IsExtern);
636     }
637 
638     case clang::Type::ExtVector: {
639       const clang::ExtVectorType *EVT =
640               static_cast<const clang::ExtVectorType*>(CTI);
641       const clang::Type *ElementType = GetExtVectorElementType(EVT);
642       if (TargetAPI < SLANG_ICS_TARGET_API &&
643           InCompositeType &&
644           EVT->getNumElements() == 3 &&
645           ND &&
646           ND->getFormalLinkage() == clang::ExternalLinkage) {
647         ReportTypeError(Context, ND, nullptr,
648                         "structs containing vectors of dimension 3 cannot "
649                         "be exported at this API level: '%0'");
650         return false;
651       }
652       return ValidateTypeHelper(Context, C, ElementType, ND, Loc, SPS, true,
653                                 UnionDecl, TargetAPI, IsFilterscript, IsExtern);
654     }
655 
656     case clang::Type::ConstantArray: {
657       const clang::ConstantArrayType *CAT = static_cast<const clang::ConstantArrayType*>(CTI);
658       const clang::Type *ElementType = GetConstantArrayElementType(CAT);
659       return ValidateTypeHelper(Context, C, ElementType, ND, Loc, SPS, true,
660                                 UnionDecl, TargetAPI, IsFilterscript, IsExtern);
661     }
662 
663     default: {
664       break;
665     }
666   }
667 
668   return true;
669 }
670 
671 }  // namespace
672 
CreateDummyName(const char * type,const std::string & name)673 std::string CreateDummyName(const char *type, const std::string &name) {
674   std::stringstream S;
675   S << "<" << type;
676   if (!name.empty()) {
677     S << ":" << name;
678   }
679   S << ">";
680   return S.str();
681 }
682 
683 /****************************** RSExportType ******************************/
NormalizeType(const clang::Type * & T,llvm::StringRef & TypeName,RSContext * Context,const clang::VarDecl * VD,ExportKind EK)684 bool RSExportType::NormalizeType(const clang::Type *&T,
685                                  llvm::StringRef &TypeName,
686                                  RSContext *Context,
687                                  const clang::VarDecl *VD,
688                                  ExportKind EK) {
689   if ((T = TypeExportable(T, Context, VD, EK)) == nullptr) {
690     return false;
691   }
692   // Get type name
693   TypeName = RSExportType::GetTypeName(T);
694   if (Context && TypeName.empty()) {
695     if (VD) {
696       Context->ReportError(VD->getLocation(),
697                            "anonymous types cannot be exported");
698     } else {
699       Context->ReportError("anonymous types cannot be exported");
700     }
701     return false;
702   }
703 
704   return true;
705 }
706 
ValidateType(slang::RSContext * Context,clang::ASTContext & C,clang::QualType QT,const clang::NamedDecl * ND,clang::SourceLocation Loc,unsigned int TargetAPI,bool IsFilterscript,bool IsExtern)707 bool RSExportType::ValidateType(slang::RSContext *Context, clang::ASTContext &C,
708                                 clang::QualType QT, const clang::NamedDecl *ND,
709                                 clang::SourceLocation Loc,
710                                 unsigned int TargetAPI, bool IsFilterscript,
711                                 bool IsExtern) {
712   const clang::Type *T = QT.getTypePtr();
713   llvm::SmallPtrSet<const clang::Type*, 8> SPS =
714       llvm::SmallPtrSet<const clang::Type*, 8>();
715 
716   // If this is an externally visible variable declaration, we check if the
717   // type is able to be exported first.
718   if (auto VD = llvm::dyn_cast_or_null<clang::VarDecl>(ND)) {
719     if (VD->getFormalLinkage() == clang::ExternalLinkage) {
720       if (!TypeExportable(T, Context, VD, NotLegacyKernelArgument)) {
721         return false;
722       }
723     }
724   }
725   return ValidateTypeHelper(Context, C, T, ND, Loc, SPS, false, nullptr, TargetAPI,
726                             IsFilterscript, IsExtern);
727 }
728 
ValidateVarDecl(slang::RSContext * Context,clang::VarDecl * VD,unsigned int TargetAPI,bool IsFilterscript)729 bool RSExportType::ValidateVarDecl(slang::RSContext *Context,
730                                    clang::VarDecl *VD, unsigned int TargetAPI,
731                                    bool IsFilterscript) {
732   return ValidateType(Context, VD->getASTContext(), VD->getType(), VD,
733                       VD->getLocation(), TargetAPI, IsFilterscript,
734                       (VD->getFormalLinkage() == clang::ExternalLinkage));
735 }
736 
737 const clang::Type
GetTypeOfDecl(const clang::DeclaratorDecl * DD)738 *RSExportType::GetTypeOfDecl(const clang::DeclaratorDecl *DD) {
739   if (DD) {
740     clang::QualType T = DD->getType();
741 
742     if (T.isNull())
743       return nullptr;
744     else
745       return T.getTypePtr();
746   }
747   return nullptr;
748 }
749 
GetTypeName(const clang::Type * T)750 llvm::StringRef RSExportType::GetTypeName(const clang::Type* T) {
751   T = GetCanonicalType(T);
752   if (T == nullptr)
753     return llvm::StringRef();
754 
755   const clang::Type *CTI = T->getCanonicalTypeInternal().getTypePtr();
756 
757   switch (T->getTypeClass()) {
758     case clang::Type::Builtin: {
759       const clang::BuiltinType *BT = static_cast<const clang::BuiltinType*>(CTI);
760       BuiltinInfo *info = FindBuiltinType(BT->getKind());
761       if (info != nullptr) {
762         return info->cname[0];
763       }
764       slangAssert(false && "Unknown data type of the builtin");
765       break;
766     }
767     case clang::Type::Record: {
768       clang::RecordDecl *RD;
769       if (T->isStructureType()) {
770         RD = T->getAsStructureType()->getDecl();
771       } else {
772         break;
773       }
774 
775       llvm::StringRef Name = RD->getName();
776       if (Name.empty()) {
777         if (RD->getTypedefNameForAnonDecl() != nullptr) {
778           Name = RD->getTypedefNameForAnonDecl()->getName();
779         }
780 
781         if (Name.empty()) {
782           // Try to find a name from redeclaration (i.e. typedef)
783           for (clang::TagDecl::redecl_iterator RI = RD->redecls_begin(),
784                    RE = RD->redecls_end();
785                RI != RE;
786                RI++) {
787             slangAssert(*RI != nullptr && "cannot be NULL object");
788 
789             Name = (*RI)->getName();
790             if (!Name.empty())
791               break;
792           }
793         }
794       }
795       return Name;
796     }
797     case clang::Type::Pointer: {
798       // "*" plus pointee name
799       const clang::PointerType *P = static_cast<const clang::PointerType*>(CTI);
800       const clang::Type *PT = GetPointeeType(P);
801       llvm::StringRef PointeeName;
802       if (NormalizeType(PT, PointeeName, nullptr, nullptr,
803                         NotLegacyKernelArgument)) {
804         char *Name = new char[ 1 /* * */ + PointeeName.size() + 1 ];
805         Name[0] = '*';
806         memcpy(Name + 1, PointeeName.data(), PointeeName.size());
807         Name[PointeeName.size() + 1] = '\0';
808         return Name;
809       }
810       break;
811     }
812     case clang::Type::ExtVector: {
813       const clang::ExtVectorType *EVT =
814               static_cast<const clang::ExtVectorType*>(CTI);
815       return RSExportVectorType::GetTypeName(EVT);
816       break;
817     }
818     case clang::Type::ConstantArray : {
819       // Construct name for a constant array is too complicated.
820       return "<ConstantArray>";
821     }
822     default: {
823       break;
824     }
825   }
826 
827   return llvm::StringRef();
828 }
829 
830 
Create(RSContext * Context,const clang::Type * T,const llvm::StringRef & TypeName,ExportKind EK)831 RSExportType *RSExportType::Create(RSContext *Context,
832                                    const clang::Type *T,
833                                    const llvm::StringRef &TypeName,
834                                    ExportKind EK) {
835   // Lookup the context to see whether the type was processed before.
836   // Newly created RSExportType will insert into context
837   // in RSExportType::RSExportType()
838   RSContext::export_type_iterator ETI = Context->findExportType(TypeName);
839 
840   if (ETI != Context->export_types_end())
841     return ETI->second;
842 
843   const clang::Type *CTI = T->getCanonicalTypeInternal().getTypePtr();
844 
845   RSExportType *ET = nullptr;
846   switch (T->getTypeClass()) {
847     case clang::Type::Record: {
848       DataType dt = RSExportPrimitiveType::GetRSSpecificType(TypeName);
849       switch (dt) {
850         case DataTypeUnknown: {
851           // User-defined types
852           ET = RSExportRecordType::Create(Context,
853                                           T->getAsStructureType(),
854                                           TypeName);
855           break;
856         }
857         case DataTypeRSMatrix2x2: {
858           // 2 x 2 Matrix type
859           ET = RSExportMatrixType::Create(Context,
860                                           T->getAsStructureType(),
861                                           TypeName,
862                                           2);
863           break;
864         }
865         case DataTypeRSMatrix3x3: {
866           // 3 x 3 Matrix type
867           ET = RSExportMatrixType::Create(Context,
868                                           T->getAsStructureType(),
869                                           TypeName,
870                                           3);
871           break;
872         }
873         case DataTypeRSMatrix4x4: {
874           // 4 x 4 Matrix type
875           ET = RSExportMatrixType::Create(Context,
876                                           T->getAsStructureType(),
877                                           TypeName,
878                                           4);
879           break;
880         }
881         default: {
882           // Others are primitive types
883           ET = RSExportPrimitiveType::Create(Context, T, TypeName);
884           break;
885         }
886       }
887       break;
888     }
889     case clang::Type::Builtin: {
890       ET = RSExportPrimitiveType::Create(Context, T, TypeName);
891       break;
892     }
893     case clang::Type::Pointer: {
894       ET = RSExportPointerType::Create(Context,
895                                        static_cast<const clang::PointerType*>(CTI),
896                                        TypeName);
897       // FIXME: free the name (allocated in RSExportType::GetTypeName)
898       delete [] TypeName.data();
899       break;
900     }
901     case clang::Type::ExtVector: {
902       ET = RSExportVectorType::Create(Context,
903                                       static_cast<const clang::ExtVectorType*>(CTI),
904                                       TypeName);
905       break;
906     }
907     case clang::Type::ConstantArray: {
908       ET = RSExportConstantArrayType::Create(
909               Context,
910               static_cast<const clang::ConstantArrayType*>(CTI));
911       break;
912     }
913     default: {
914       Context->ReportError("unknown type cannot be exported: '%0'")
915           << T->getTypeClassName();
916       break;
917     }
918   }
919 
920   return ET;
921 }
922 
Create(RSContext * Context,const clang::Type * T,ExportKind EK,const clang::VarDecl * VD)923 RSExportType *RSExportType::Create(RSContext *Context, const clang::Type *T,
924                                    ExportKind EK, const clang::VarDecl *VD) {
925   llvm::StringRef TypeName;
926   if (NormalizeType(T, TypeName, Context, VD, EK)) {
927     return Create(Context, T, TypeName, EK);
928   } else {
929     return nullptr;
930   }
931 }
932 
CreateFromDecl(RSContext * Context,const clang::VarDecl * VD)933 RSExportType *RSExportType::CreateFromDecl(RSContext *Context,
934                                            const clang::VarDecl *VD) {
935   return RSExportType::Create(Context, GetTypeOfDecl(VD),
936                               NotLegacyKernelArgument, VD);
937 }
938 
getStoreSize() const939 size_t RSExportType::getStoreSize() const {
940   return getRSContext()->getDataLayout().getTypeStoreSize(getLLVMType());
941 }
942 
getAllocSize() const943 size_t RSExportType::getAllocSize() const {
944     return getRSContext()->getDataLayout().getTypeAllocSize(getLLVMType());
945 }
946 
RSExportType(RSContext * Context,ExportClass Class,const llvm::StringRef & Name)947 RSExportType::RSExportType(RSContext *Context,
948                            ExportClass Class,
949                            const llvm::StringRef &Name)
950     : RSExportable(Context, RSExportable::EX_TYPE),
951       mClass(Class),
952       // Make a copy on Name since memory stored @Name is either allocated in
953       // ASTContext or allocated in GetTypeName which will be destroyed later.
954       mName(Name.data(), Name.size()),
955       mLLVMType(nullptr) {
956   // Don't cache the type whose name start with '<'. Those type failed to
957   // get their name since constructing their name in GetTypeName() requiring
958   // complicated work.
959   if (!IsDummyName(Name)) {
960     // TODO(zonr): Need to check whether the insertion is successful or not.
961     Context->insertExportType(llvm::StringRef(Name), this);
962   }
963 
964 }
965 
keep()966 bool RSExportType::keep() {
967   if (!RSExportable::keep())
968     return false;
969   // Invalidate converted LLVM type.
970   mLLVMType = nullptr;
971   return true;
972 }
973 
matchODR(const RSExportType * E,bool) const974 bool RSExportType::matchODR(const RSExportType *E, bool /* LookInto */) const {
975   return (E->getClass() == getClass());
976 }
977 
~RSExportType()978 RSExportType::~RSExportType() {
979 }
980 
981 /************************** RSExportPrimitiveType **************************/
982 llvm::ManagedStatic<RSExportPrimitiveType::RSSpecificTypeMapTy>
983 RSExportPrimitiveType::RSSpecificTypeMap;
984 
IsPrimitiveType(const clang::Type * T)985 bool RSExportPrimitiveType::IsPrimitiveType(const clang::Type *T) {
986   if ((T != nullptr) && (T->getTypeClass() == clang::Type::Builtin))
987     return true;
988   else
989     return false;
990 }
991 
992 DataType
GetRSSpecificType(const llvm::StringRef & TypeName)993 RSExportPrimitiveType::GetRSSpecificType(const llvm::StringRef &TypeName) {
994   if (TypeName.empty())
995     return DataTypeUnknown;
996 
997   if (RSSpecificTypeMap->empty()) {
998     for (int i = 0; i < MatrixAndObjectDataTypesCount; i++) {
999       (*RSSpecificTypeMap)[MatrixAndObjectDataTypes[i].name] =
1000           MatrixAndObjectDataTypes[i].dataType;
1001     }
1002   }
1003 
1004   RSSpecificTypeMapTy::const_iterator I = RSSpecificTypeMap->find(TypeName);
1005   if (I == RSSpecificTypeMap->end())
1006     return DataTypeUnknown;
1007   else
1008     return I->getValue();
1009 }
1010 
GetRSSpecificType(const clang::Type * T)1011 DataType RSExportPrimitiveType::GetRSSpecificType(const clang::Type *T) {
1012   T = GetCanonicalType(T);
1013   if ((T == nullptr) || (T->getTypeClass() != clang::Type::Record))
1014     return DataTypeUnknown;
1015 
1016   return GetRSSpecificType( RSExportType::GetTypeName(T) );
1017 }
1018 
IsRSMatrixType(DataType DT)1019 bool RSExportPrimitiveType::IsRSMatrixType(DataType DT) {
1020     if (DT < 0 || DT >= DataTypeMax) {
1021         return false;
1022     }
1023     return gReflectionTypes[DT].category == MatrixDataType;
1024 }
1025 
IsRSObjectType(DataType DT)1026 bool RSExportPrimitiveType::IsRSObjectType(DataType DT) {
1027     if (DT < 0 || DT >= DataTypeMax) {
1028         return false;
1029     }
1030     return gReflectionTypes[DT].category == ObjectDataType;
1031 }
1032 
IsStructureTypeWithRSObject(const clang::Type * T)1033 bool RSExportPrimitiveType::IsStructureTypeWithRSObject(const clang::Type *T) {
1034   bool RSObjectTypeSeen = false;
1035   while (T && T->isArrayType()) {
1036     T = T->getArrayElementTypeNoTypeQual();
1037   }
1038 
1039   const clang::RecordType *RT = T->getAsStructureType();
1040   if (!RT) {
1041     return false;
1042   }
1043 
1044   const clang::RecordDecl *RD = RT->getDecl();
1045   if (RD) {
1046     RD = RD->getDefinition();
1047   }
1048   if (!RD) {
1049     return false;
1050   }
1051 
1052   for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
1053          FE = RD->field_end();
1054        FI != FE;
1055        FI++) {
1056     // We just look through all field declarations to see if we find a
1057     // declaration for an RS object type (or an array of one).
1058     const clang::FieldDecl *FD = *FI;
1059     const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
1060     while (FT && FT->isArrayType()) {
1061       FT = FT->getArrayElementTypeNoTypeQual();
1062     }
1063 
1064     DataType DT = GetRSSpecificType(FT);
1065     if (IsRSObjectType(DT)) {
1066       // RS object types definitely need to be zero-initialized
1067       RSObjectTypeSeen = true;
1068     } else {
1069       switch (DT) {
1070         case DataTypeRSMatrix2x2:
1071         case DataTypeRSMatrix3x3:
1072         case DataTypeRSMatrix4x4:
1073           // Matrix types should get zero-initialized as well
1074           RSObjectTypeSeen = true;
1075           break;
1076         default:
1077           // Ignore all other primitive types
1078           break;
1079       }
1080       while (FT && FT->isArrayType()) {
1081         FT = FT->getArrayElementTypeNoTypeQual();
1082       }
1083       if (FT->isStructureType()) {
1084         // Recursively handle structs of structs (even though these can't
1085         // be exported, it is possible for a user to have them internally).
1086         RSObjectTypeSeen |= IsStructureTypeWithRSObject(FT);
1087       }
1088     }
1089   }
1090 
1091   return RSObjectTypeSeen;
1092 }
1093 
GetElementSizeInBits(const RSExportPrimitiveType * EPT)1094 size_t RSExportPrimitiveType::GetElementSizeInBits(const RSExportPrimitiveType *EPT) {
1095   int type = EPT->getType();
1096   slangAssert((type > DataTypeUnknown && type < DataTypeMax) &&
1097               "RSExportPrimitiveType::GetElementSizeInBits : unknown data type");
1098   // All RS object types are 256 bits in 64-bit RS.
1099   if (EPT->isRSObjectType() && EPT->getRSContext()->is64Bit()) {
1100     return 256;
1101   }
1102   return gReflectionTypes[type].size_in_bits;
1103 }
1104 
1105 DataType
GetDataType(RSContext * Context,const clang::Type * T)1106 RSExportPrimitiveType::GetDataType(RSContext *Context, const clang::Type *T) {
1107   if (T == nullptr)
1108     return DataTypeUnknown;
1109 
1110   switch (T->getTypeClass()) {
1111     case clang::Type::Builtin: {
1112       const clang::BuiltinType *BT =
1113               static_cast<const clang::BuiltinType*>(T->getCanonicalTypeInternal().getTypePtr());
1114       BuiltinInfo *info = FindBuiltinType(BT->getKind());
1115       if (info != nullptr) {
1116         return info->type;
1117       }
1118       // The size of type WChar depend on platform so we abandon the support
1119       // to them.
1120       Context->ReportError("built-in type cannot be exported: '%0'")
1121           << T->getTypeClassName();
1122       break;
1123     }
1124     case clang::Type::Record: {
1125       // must be RS object type
1126       return RSExportPrimitiveType::GetRSSpecificType(T);
1127     }
1128     default: {
1129       Context->ReportError("primitive type cannot be exported: '%0'")
1130           << T->getTypeClassName();
1131       break;
1132     }
1133   }
1134 
1135   return DataTypeUnknown;
1136 }
1137 
1138 RSExportPrimitiveType
Create(RSContext * Context,const clang::Type * T,const llvm::StringRef & TypeName,bool Normalized)1139 *RSExportPrimitiveType::Create(RSContext *Context,
1140                                const clang::Type *T,
1141                                const llvm::StringRef &TypeName,
1142                                bool Normalized) {
1143   DataType DT = GetDataType(Context, T);
1144 
1145   if ((DT == DataTypeUnknown) || TypeName.empty())
1146     return nullptr;
1147   else
1148     return new RSExportPrimitiveType(Context, ExportClassPrimitive, TypeName,
1149                                      DT, Normalized);
1150 }
1151 
Create(RSContext * Context,const clang::Type * T)1152 RSExportPrimitiveType *RSExportPrimitiveType::Create(RSContext *Context,
1153                                                      const clang::Type *T) {
1154   llvm::StringRef TypeName;
1155   if (RSExportType::NormalizeType(T, TypeName, Context, nullptr,
1156                                   NotLegacyKernelArgument) &&
1157       IsPrimitiveType(T)) {
1158     return Create(Context, T, TypeName);
1159   } else {
1160     return nullptr;
1161   }
1162 }
1163 
convertToLLVMType() const1164 llvm::Type *RSExportPrimitiveType::convertToLLVMType() const {
1165   llvm::LLVMContext &C = getRSContext()->getLLVMContext();
1166 
1167   if (isRSObjectType()) {
1168     // struct {
1169     //   int *p;
1170     // } __attribute__((packed, aligned(pointer_size)))
1171     //
1172     // which is
1173     //
1174     // <{ [1 x i32] }> in LLVM
1175     //
1176     std::vector<llvm::Type *> Elements;
1177     if (getRSContext()->is64Bit()) {
1178       // 64-bit path
1179       Elements.push_back(llvm::ArrayType::get(llvm::Type::getInt64Ty(C), 4));
1180       return llvm::StructType::get(C, Elements, true);
1181     } else {
1182       // 32-bit legacy path
1183       Elements.push_back(llvm::ArrayType::get(llvm::Type::getInt32Ty(C), 1));
1184       return llvm::StructType::get(C, Elements, true);
1185     }
1186   }
1187 
1188   switch (mType) {
1189     case DataTypeFloat16: {
1190       return llvm::Type::getHalfTy(C);
1191       break;
1192     }
1193     case DataTypeFloat32: {
1194       return llvm::Type::getFloatTy(C);
1195       break;
1196     }
1197     case DataTypeFloat64: {
1198       return llvm::Type::getDoubleTy(C);
1199       break;
1200     }
1201     case DataTypeBoolean: {
1202       return llvm::Type::getInt1Ty(C);
1203       break;
1204     }
1205     case DataTypeSigned8:
1206     case DataTypeUnsigned8: {
1207       return llvm::Type::getInt8Ty(C);
1208       break;
1209     }
1210     case DataTypeSigned16:
1211     case DataTypeUnsigned16:
1212     case DataTypeUnsigned565:
1213     case DataTypeUnsigned5551:
1214     case DataTypeUnsigned4444: {
1215       return llvm::Type::getInt16Ty(C);
1216       break;
1217     }
1218     case DataTypeSigned32:
1219     case DataTypeUnsigned32: {
1220       return llvm::Type::getInt32Ty(C);
1221       break;
1222     }
1223     case DataTypeSigned64:
1224     case DataTypeUnsigned64: {
1225       return llvm::Type::getInt64Ty(C);
1226       break;
1227     }
1228     default: {
1229       slangAssert(false && "Unknown data type");
1230     }
1231   }
1232 
1233   return nullptr;
1234 }
1235 
matchODR(const RSExportType * E,bool) const1236 bool RSExportPrimitiveType::matchODR(const RSExportType *E,
1237                                      bool /* LookInto */) const {
1238   CHECK_PARENT_EQUALITY(RSExportType, E);
1239   return (static_cast<const RSExportPrimitiveType*>(E)->getType() == getType());
1240 }
1241 
getRSReflectionType(DataType DT)1242 RSReflectionType *RSExportPrimitiveType::getRSReflectionType(DataType DT) {
1243   if (DT > DataTypeUnknown && DT < DataTypeMax) {
1244     return &gReflectionTypes[DT];
1245   } else {
1246     return nullptr;
1247   }
1248 }
1249 
1250 /**************************** RSExportPointerType ****************************/
1251 
1252 RSExportPointerType
Create(RSContext * Context,const clang::PointerType * PT,const llvm::StringRef & TypeName)1253 *RSExportPointerType::Create(RSContext *Context,
1254                              const clang::PointerType *PT,
1255                              const llvm::StringRef &TypeName) {
1256   const clang::Type *PointeeType = GetPointeeType(PT);
1257   const RSExportType *PointeeET;
1258 
1259   if (PointeeType->getTypeClass() != clang::Type::Pointer) {
1260     PointeeET = RSExportType::Create(Context, PointeeType,
1261                                      NotLegacyKernelArgument);
1262   } else {
1263     // Double or higher dimension of pointer, export as int*
1264     PointeeET = RSExportPrimitiveType::Create(Context,
1265                     Context->getASTContext().IntTy.getTypePtr());
1266   }
1267 
1268   if (PointeeET == nullptr) {
1269     // Error diagnostic is emitted for corresponding pointee type
1270     return nullptr;
1271   }
1272 
1273   return new RSExportPointerType(Context, TypeName, PointeeET);
1274 }
1275 
convertToLLVMType() const1276 llvm::Type *RSExportPointerType::convertToLLVMType() const {
1277   llvm::Type *PointeeType = mPointeeType->getLLVMType();
1278   return llvm::PointerType::getUnqual(PointeeType);
1279 }
1280 
keep()1281 bool RSExportPointerType::keep() {
1282   if (!RSExportType::keep())
1283     return false;
1284   const_cast<RSExportType*>(mPointeeType)->keep();
1285   return true;
1286 }
1287 
matchODR(const RSExportType * E,bool) const1288 bool RSExportPointerType::matchODR(const RSExportType *E,
1289                                    bool /* LookInto */) const {
1290   // Exported types cannot contain pointers
1291   slangAssert(false && "Not supposed to perform ODR check on pointers");
1292   return false;
1293 }
1294 
1295 /***************************** RSExportVectorType *****************************/
1296 llvm::StringRef
GetTypeName(const clang::ExtVectorType * EVT)1297 RSExportVectorType::GetTypeName(const clang::ExtVectorType *EVT) {
1298   const clang::Type *ElementType = GetExtVectorElementType(EVT);
1299   llvm::StringRef name;
1300 
1301   if ((ElementType->getTypeClass() != clang::Type::Builtin))
1302     return name;
1303 
1304   const clang::BuiltinType *BT =
1305           static_cast<const clang::BuiltinType*>(
1306               ElementType->getCanonicalTypeInternal().getTypePtr());
1307 
1308   if ((EVT->getNumElements() < 1) ||
1309       (EVT->getNumElements() > 4))
1310     return name;
1311 
1312   BuiltinInfo *info = FindBuiltinType(BT->getKind());
1313   if (info != nullptr) {
1314     int I = EVT->getNumElements() - 1;
1315     if (I < kMaxVectorSize) {
1316       name = info->cname[I];
1317     } else {
1318       slangAssert(false && "Max vector is 4");
1319     }
1320   }
1321   return name;
1322 }
1323 
Create(RSContext * Context,const clang::ExtVectorType * EVT,const llvm::StringRef & TypeName,bool Normalized)1324 RSExportVectorType *RSExportVectorType::Create(RSContext *Context,
1325                                                const clang::ExtVectorType *EVT,
1326                                                const llvm::StringRef &TypeName,
1327                                                bool Normalized) {
1328   slangAssert(EVT != nullptr && EVT->getTypeClass() == clang::Type::ExtVector);
1329 
1330   const clang::Type *ElementType = GetExtVectorElementType(EVT);
1331   DataType DT = RSExportPrimitiveType::GetDataType(Context, ElementType);
1332 
1333   if (DT != DataTypeUnknown)
1334     return new RSExportVectorType(Context,
1335                                   TypeName,
1336                                   DT,
1337                                   Normalized,
1338                                   EVT->getNumElements());
1339   else
1340     return nullptr;
1341 }
1342 
convertToLLVMType() const1343 llvm::Type *RSExportVectorType::convertToLLVMType() const {
1344   llvm::Type *ElementType = RSExportPrimitiveType::convertToLLVMType();
1345   return llvm::VectorType::get(ElementType, getNumElement());
1346 }
1347 
matchODR(const RSExportType * E,bool) const1348 bool RSExportVectorType::matchODR(const RSExportType *E,
1349                                   bool /* LookInto*/) const {
1350   CHECK_PARENT_EQUALITY(RSExportPrimitiveType, E);
1351   return (static_cast<const RSExportVectorType*>(E)->getNumElement()
1352               == getNumElement());
1353 }
1354 
1355 /***************************** RSExportMatrixType *****************************/
Create(RSContext * Context,const clang::RecordType * RT,const llvm::StringRef & TypeName,unsigned Dim)1356 RSExportMatrixType *RSExportMatrixType::Create(RSContext *Context,
1357                                                const clang::RecordType *RT,
1358                                                const llvm::StringRef &TypeName,
1359                                                unsigned Dim) {
1360   slangAssert((RT != nullptr) && (RT->getTypeClass() == clang::Type::Record));
1361   slangAssert((Dim > 1) && "Invalid dimension of matrix");
1362 
1363   // Check whether the struct rs_matrix is in our expected form (but assume it's
1364   // correct if we're not sure whether it's correct or not)
1365   const clang::RecordDecl* RD = RT->getDecl();
1366   RD = RD->getDefinition();
1367   if (RD != nullptr) {
1368     // Find definition, perform further examination
1369     if (RD->field_empty()) {
1370       Context->ReportError(
1371           RD->getLocation(),
1372           "invalid matrix struct: must have 1 field for saving values: '%0'")
1373           << RD->getName();
1374       return nullptr;
1375     }
1376 
1377     clang::RecordDecl::field_iterator FIT = RD->field_begin();
1378     const clang::FieldDecl *FD = *FIT;
1379     const clang::Type *FT = RSExportType::GetTypeOfDecl(FD);
1380     if ((FT == nullptr) || (FT->getTypeClass() != clang::Type::ConstantArray)) {
1381       Context->ReportError(RD->getLocation(),
1382                            "invalid matrix struct: first field should"
1383                            " be an array with constant size: '%0'")
1384           << RD->getName();
1385       return nullptr;
1386     }
1387     const clang::ConstantArrayType *CAT =
1388       static_cast<const clang::ConstantArrayType *>(FT);
1389     const clang::Type *ElementType = GetConstantArrayElementType(CAT);
1390     if ((ElementType == nullptr) ||
1391         (ElementType->getTypeClass() != clang::Type::Builtin) ||
1392         (static_cast<const clang::BuiltinType *>(ElementType)->getKind() !=
1393          clang::BuiltinType::Float)) {
1394       Context->ReportError(RD->getLocation(),
1395                            "invalid matrix struct: first field "
1396                            "should be a float array: '%0'")
1397           << RD->getName();
1398       return nullptr;
1399     }
1400 
1401     if (CAT->getSize() != Dim * Dim) {
1402       Context->ReportError(RD->getLocation(),
1403                            "invalid matrix struct: first field "
1404                            "should be an array with size %0: '%1'")
1405           << (Dim * Dim) << (RD->getName());
1406       return nullptr;
1407     }
1408 
1409     FIT++;
1410     if (FIT != RD->field_end()) {
1411       Context->ReportError(RD->getLocation(),
1412                            "invalid matrix struct: must have "
1413                            "exactly 1 field: '%0'")
1414           << RD->getName();
1415       return nullptr;
1416     }
1417   }
1418 
1419   return new RSExportMatrixType(Context, TypeName, Dim);
1420 }
1421 
convertToLLVMType() const1422 llvm::Type *RSExportMatrixType::convertToLLVMType() const {
1423   // Construct LLVM type:
1424   // struct {
1425   //  float X[mDim * mDim];
1426   // }
1427 
1428   llvm::LLVMContext &C = getRSContext()->getLLVMContext();
1429   llvm::ArrayType *X = llvm::ArrayType::get(llvm::Type::getFloatTy(C),
1430                                             mDim * mDim);
1431   return llvm::StructType::get(C, X, false);
1432 }
1433 
matchODR(const RSExportType * E,bool) const1434 bool RSExportMatrixType::matchODR(const RSExportType *E,
1435                                   bool /* LookInto */) const {
1436   CHECK_PARENT_EQUALITY(RSExportType, E);
1437   return (static_cast<const RSExportMatrixType*>(E)->getDim() == getDim());
1438 }
1439 
1440 /************************* RSExportConstantArrayType *************************/
1441 RSExportConstantArrayType
Create(RSContext * Context,const clang::ConstantArrayType * CAT)1442 *RSExportConstantArrayType::Create(RSContext *Context,
1443                                    const clang::ConstantArrayType *CAT) {
1444   slangAssert(CAT != nullptr && CAT->getTypeClass() == clang::Type::ConstantArray);
1445 
1446   slangAssert((CAT->getSize().getActiveBits() < 32) && "array too large");
1447 
1448   unsigned Size = static_cast<unsigned>(CAT->getSize().getZExtValue());
1449   slangAssert((Size > 0) && "Constant array should have size greater than 0");
1450 
1451   const clang::Type *ElementType = GetConstantArrayElementType(CAT);
1452   RSExportType *ElementET = RSExportType::Create(Context, ElementType,
1453                                                  NotLegacyKernelArgument);
1454 
1455   if (ElementET == nullptr) {
1456     return nullptr;
1457   }
1458 
1459   return new RSExportConstantArrayType(Context,
1460                                        ElementET,
1461                                        Size);
1462 }
1463 
convertToLLVMType() const1464 llvm::Type *RSExportConstantArrayType::convertToLLVMType() const {
1465   return llvm::ArrayType::get(mElementType->getLLVMType(), getNumElement());
1466 }
1467 
keep()1468 bool RSExportConstantArrayType::keep() {
1469   if (!RSExportType::keep())
1470     return false;
1471   const_cast<RSExportType*>(mElementType)->keep();
1472   return true;
1473 }
1474 
matchODR(const RSExportType * E,bool LookInto) const1475 bool RSExportConstantArrayType::matchODR(const RSExportType *E,
1476                                          bool LookInto) const {
1477   CHECK_PARENT_EQUALITY(RSExportType, E);
1478   const RSExportConstantArrayType *RHS =
1479       static_cast<const RSExportConstantArrayType*>(E);
1480   return ((getNumElement() == RHS->getNumElement()) &&
1481           (getElementType()->matchODR(RHS->getElementType(), LookInto)));
1482 }
1483 
1484 /**************************** RSExportRecordType ****************************/
Create(RSContext * Context,const clang::RecordType * RT,const llvm::StringRef & TypeName,bool mIsArtificial)1485 RSExportRecordType *RSExportRecordType::Create(RSContext *Context,
1486                                                const clang::RecordType *RT,
1487                                                const llvm::StringRef &TypeName,
1488                                                bool mIsArtificial) {
1489   slangAssert(RT != nullptr && RT->getTypeClass() == clang::Type::Record);
1490 
1491   const clang::RecordDecl *RD = RT->getDecl();
1492   slangAssert(RD->isStruct());
1493 
1494   RD = RD->getDefinition();
1495   if (RD == nullptr) {
1496     slangAssert(false && "struct is not defined in this module");
1497     return nullptr;
1498   }
1499 
1500   // Struct layout construct by clang. We rely on this for obtaining the
1501   // alloc size of a struct and offset of every field in that struct.
1502   const clang::ASTRecordLayout *RL =
1503       &Context->getASTContext().getASTRecordLayout(RD);
1504   slangAssert((RL != nullptr) &&
1505       "Failed to retrieve the struct layout from Clang.");
1506 
1507   RSExportRecordType *ERT =
1508       new RSExportRecordType(Context,
1509                              TypeName,
1510                              RD->hasAttr<clang::PackedAttr>(),
1511                              mIsArtificial,
1512                              RL->getDataSize().getQuantity(),
1513                              RL->getSize().getQuantity());
1514   unsigned int Index = 0;
1515 
1516   for (clang::RecordDecl::field_iterator FI = RD->field_begin(),
1517            FE = RD->field_end();
1518        FI != FE;
1519        FI++, Index++) {
1520 
1521     // FIXME: All fields should be primitive type
1522     slangAssert(FI->getKind() == clang::Decl::Field);
1523     clang::FieldDecl *FD = *FI;
1524 
1525     if (FD->isBitField()) {
1526       return nullptr;
1527     }
1528 
1529     if (FD->isImplicit() && (FD->getName() == RS_PADDING_FIELD_NAME))
1530       continue;
1531 
1532     // Type
1533     RSExportType *ET = RSExportElement::CreateFromDecl(Context, FD);
1534 
1535     if (ET != nullptr) {
1536       ERT->mFields.push_back(
1537           new Field(ET, FD->getName(), ERT,
1538                     static_cast<size_t>(RL->getFieldOffset(Index) >> 3)));
1539     } else {
1540       // clang static analysis complains about a potential memory leak
1541       // for the memory pointed by ERT at the end of this basic
1542       // block. This is a false warning because the compiler does not
1543       // see that the pointer to this memory is saved away in the
1544       // constructor for RSExportRecordType by calling
1545       // RSContext::newExportable(this). So, we disable this
1546       // particular instance of the warning.
1547       Context->ReportError(RD->getLocation(),
1548                            "field type cannot be exported: '%0.%1'")
1549           << RD->getName() << FD->getName(); // NOLINT
1550       return nullptr;
1551     }
1552   }
1553 
1554   return ERT;
1555 }
1556 
convertToLLVMType() const1557 llvm::Type *RSExportRecordType::convertToLLVMType() const {
1558   // Create an opaque type since struct may reference itself recursively.
1559 
1560   // TODO(sliao): LLVM took out the OpaqueType. Any other to migrate to?
1561   std::vector<llvm::Type*> FieldTypes;
1562 
1563   for (const_field_iterator FI = fields_begin(), FE = fields_end();
1564        FI != FE;
1565        FI++) {
1566     const Field *F = *FI;
1567     const RSExportType *FET = F->getType();
1568 
1569     FieldTypes.push_back(FET->getLLVMType());
1570   }
1571 
1572   llvm::StructType *ST = llvm::StructType::get(getRSContext()->getLLVMContext(),
1573                                                FieldTypes,
1574                                                mIsPacked);
1575   if (ST != nullptr) {
1576     return ST;
1577   } else {
1578     return nullptr;
1579   }
1580 }
1581 
keep()1582 bool RSExportRecordType::keep() {
1583   if (!RSExportType::keep())
1584     return false;
1585   for (std::list<const Field*>::iterator I = mFields.begin(),
1586           E = mFields.end();
1587        I != E;
1588        I++) {
1589     const_cast<RSExportType*>((*I)->getType())->keep();
1590   }
1591   return true;
1592 }
1593 
matchODR(const RSExportType * E,bool LookInto) const1594 bool RSExportRecordType::matchODR(const RSExportType *E, bool LookInto) const {
1595   CHECK_PARENT_EQUALITY(RSExportType, E);
1596   // Enforce ODR checking - the type E represents must hold
1597   // *exactly* the same "definition" as the one defined previously. We
1598   // say two record types A and B have the same definition iff:
1599   //
1600   //  struct A {              struct B {
1601   //    Type(a1) a1,            Type(b1) b1,
1602   //    Type(a2) a2,            Type(b1) b2,
1603   //    ...                     ...
1604   //    Type(aN) aN             Type(bM) bM,
1605   //  };                      }
1606   //  Cond. #0. A = B;
1607   //  Cond. #1. They have same number of fields, i.e., N = M;
1608   //  Cond. #2. for (i := 1 to N)
1609   //              Type(ai).matchODR(Type(bi)) must hold;
1610   //  Cond. #3. for (i := 1 to N)
1611   //              Name(ai) = Name(bi) must hold;
1612   //
1613   // where,
1614   //  Type(F) = the type of field F and
1615   //  Name(F) = the field name.
1616 
1617 
1618   const RSExportRecordType *ERT = static_cast<const RSExportRecordType*>(E);
1619   // Cond. #0.
1620   if (getName() != ERT->getName())
1621     return false;
1622 
1623   // Examine fields - types and names
1624   if (LookInto) {
1625     // Cond. #1
1626     if (ERT->getFields().size() != getFields().size())
1627       return false;
1628 
1629     for (RSExportRecordType::const_field_iterator AI = fields_begin(),
1630          BI = ERT->fields_begin(), AE = fields_end(); AI != AE; ++AI, ++BI) {
1631       const RSExportType *AITy = (*AI)->getType();
1632       const RSExportType *BITy = (*BI)->getType();
1633       // Cond. #3; field names must agree
1634       if ((*AI)->getName() != (*BI)->getName())
1635         return false;
1636 
1637       // Cond. #2; field types must agree recursively until we see another
1638       // next level of RSExportRecordType - such field types will be
1639       // examined and reported later when checkODR() encounters them.
1640       if (!AITy->matchODR(BITy, false))
1641         return false;
1642     }
1643   }
1644   return true;
1645 }
1646 
convertToRTD(RSReflectionTypeData * rtd) const1647 void RSExportType::convertToRTD(RSReflectionTypeData *rtd) const {
1648     memset(rtd, 0, sizeof(*rtd));
1649     rtd->vecSize = 1;
1650 
1651     switch(getClass()) {
1652     case RSExportType::ExportClassPrimitive: {
1653             const RSExportPrimitiveType *EPT = static_cast<const RSExportPrimitiveType*>(this);
1654             rtd->type = RSExportPrimitiveType::getRSReflectionType(EPT);
1655             return;
1656         }
1657     case RSExportType::ExportClassPointer: {
1658             const RSExportPointerType *EPT = static_cast<const RSExportPointerType*>(this);
1659             const RSExportType *PointeeType = EPT->getPointeeType();
1660             PointeeType->convertToRTD(rtd);
1661             rtd->isPointer = true;
1662             return;
1663         }
1664     case RSExportType::ExportClassVector: {
1665             const RSExportVectorType *EVT = static_cast<const RSExportVectorType*>(this);
1666             rtd->type = EVT->getRSReflectionType(EVT);
1667             rtd->vecSize = EVT->getNumElement();
1668             return;
1669         }
1670     case RSExportType::ExportClassMatrix: {
1671             const RSExportMatrixType *EMT = static_cast<const RSExportMatrixType*>(this);
1672             unsigned Dim = EMT->getDim();
1673             slangAssert((Dim >= 2) && (Dim <= 4));
1674             rtd->type = &gReflectionTypes[15 + Dim-2];
1675             return;
1676         }
1677     case RSExportType::ExportClassConstantArray: {
1678             const RSExportConstantArrayType* CAT =
1679               static_cast<const RSExportConstantArrayType*>(this);
1680             CAT->getElementType()->convertToRTD(rtd);
1681             rtd->arraySize = CAT->getNumElement();
1682             return;
1683         }
1684     case RSExportType::ExportClassRecord: {
1685             slangAssert(!"RSExportType::ExportClassRecord not implemented");
1686             return;// RS_TYPE_CLASS_NAME_PREFIX + ET->getName() + ".Item";
1687         }
1688     default: {
1689             slangAssert(false && "Unknown class of type");
1690         }
1691     }
1692 }
1693 
1694 
1695 }  // namespace slang
1696