1 /*
2 * Copyright 2010, 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_element.h"
18
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/Type.h"
21
22 #include "clang/Basic/SourceLocation.h"
23 #include "clang/Basic/IdentifierTable.h"
24
25 #include "slang_assert.h"
26 #include "slang_rs_context.h"
27 #include "slang_rs_export_type.h"
28
29 namespace slang {
30
31 bool RSExportElement::Initialized = false;
32 RSExportElement::ElementInfoMapTy RSExportElement::ElementInfoMap;
33
34 struct DataElementInfo {
35 const char *name;
36 DataType dataType;
37 bool normalized;
38 int vsize;
39 };
40
41 static DataElementInfo DataElementInfoTable[] = {
42 {"rs_pixel_l", DataTypeUnsigned8, true, 1},
43 {"rs_pixel_a", DataTypeUnsigned8, true, 1},
44 {"rs_pixel_la", DataTypeUnsigned8, true, 2},
45 {"rs_pixel_rgb", DataTypeUnsigned8, true, 3},
46 {"rs_pixel_rgba", DataTypeUnsigned8, true, 4},
47 {"rs_pixel_rgb565", DataTypeUnsigned8, true, 3},
48 {"rs_pixel_rgb5551", DataTypeUnsigned8, true, 4},
49 {"rs_pixel_rgb4444", DataTypeUnsigned8, true, 4},
50 };
51
52 const int DataElementInfoTableCount = sizeof(DataElementInfoTable) / sizeof(DataElementInfoTable[0]);
53
54 // TODO Rename RSExportElement to RSExportDataElement
Init()55 void RSExportElement::Init() {
56 if (!Initialized) {
57 // Initialize ElementInfoMap
58 for (int i = 0; i < DataElementInfoTableCount; i++) {
59 ElementInfo *EI = new ElementInfo;
60 EI->type = DataElementInfoTable[i].dataType;
61 EI->normalized = DataElementInfoTable[i].normalized;
62 EI->vsize = DataElementInfoTable[i].vsize;
63 llvm::StringRef Name(DataElementInfoTable[i].name);
64 ElementInfoMap.insert(ElementInfoMapTy::value_type::Create(
65 Name, ElementInfoMap.getAllocator(), EI));
66 }
67 Initialized = true;
68 }
69 }
70
Create(RSContext * Context,const clang::Type * T,const ElementInfo * EI)71 RSExportType *RSExportElement::Create(RSContext *Context,
72 const clang::Type *T,
73 const ElementInfo *EI) {
74 // Create RSExportType corresponded to the @T first and then verify
75
76 llvm::StringRef TypeName;
77 RSExportType *ET = nullptr;
78
79 if (!Initialized)
80 Init();
81
82 slangAssert(EI != nullptr && "Element info not found");
83
84 if (!RSExportType::NormalizeType(T, TypeName, Context, nullptr))
85 return nullptr;
86
87 switch (T->getTypeClass()) {
88 case clang::Type::Builtin:
89 case clang::Type::Pointer: {
90 slangAssert(EI->vsize == 1 && "Element not a primitive class (please "
91 "check your macro)");
92 RSExportPrimitiveType *EPT =
93 RSExportPrimitiveType::Create(Context,
94 T,
95 TypeName,
96 EI->normalized);
97 // Verify
98 slangAssert(EI->type == EPT->getType() && "Element has unexpected type");
99 ET = EPT;
100 break;
101 }
102 case clang::Type::ExtVector: {
103 slangAssert(EI->vsize > 1 && "Element not a vector class (please check "
104 "your macro)");
105 RSExportVectorType *EVT =
106 RSExportVectorType::Create(Context,
107 static_cast<const clang::ExtVectorType*>(
108 T->getCanonicalTypeInternal()
109 .getTypePtr()),
110 TypeName,
111 EI->normalized);
112 // Verify
113 slangAssert(EI->type == EVT->getType() && "Element has unexpected type");
114 slangAssert(EI->vsize == EVT->getNumElement() && "Element has unexpected "
115 "size of vector");
116 ET = EVT;
117 break;
118 }
119 default: {
120 // TODO(zonr): warn that type is not exportable
121 fprintf(stderr, "RSExportElement::Create : type '%s' is not exportable\n",
122 T->getTypeClassName());
123 break;
124 }
125 }
126
127 return ET;
128 }
129
CreateFromDecl(RSContext * Context,const clang::DeclaratorDecl * DD)130 RSExportType *RSExportElement::CreateFromDecl(RSContext *Context,
131 const clang::DeclaratorDecl *DD) {
132 const clang::Type* T = RSExportType::GetTypeOfDecl(DD);
133 const clang::Type* CT = GetCanonicalType(T);
134 const ElementInfo* EI = nullptr;
135
136 // Note: RS element like rs_pixel_rgb elements are either in the type of
137 // primitive or vector.
138 if ((CT->getTypeClass() != clang::Type::Builtin) &&
139 (CT->getTypeClass() != clang::Type::ExtVector)) {
140 return RSExportType::Create(Context, T);
141 }
142
143 // Following the typedef chain to see whether it's an element name like
144 // rs_pixel_rgb or its alias (via typedef).
145 while (T != CT) {
146 if (T->getTypeClass() != clang::Type::Typedef) {
147 break;
148 } else {
149 const clang::TypedefType *TT = static_cast<const clang::TypedefType*>(T);
150 const clang::TypedefNameDecl *TD = TT->getDecl();
151 EI = GetElementInfo(TD->getName());
152 if (EI != nullptr)
153 break;
154
155 T = TD->getUnderlyingType().getTypePtr();
156 }
157 }
158
159 if (EI == nullptr) {
160 return RSExportType::Create(Context, T);
161 } else {
162 return RSExportElement::Create(Context, T, EI);
163 }
164 }
165
166 const RSExportElement::ElementInfo *
GetElementInfo(const llvm::StringRef & Name)167 RSExportElement::GetElementInfo(const llvm::StringRef &Name) {
168 if (!Initialized)
169 Init();
170
171 ElementInfoMapTy::const_iterator I = ElementInfoMap.find(Name);
172 if (I == ElementInfoMap.end())
173 return nullptr;
174 else
175 return I->getValue();
176 }
177
178 } // namespace slang
179