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 <cstdio>
18 #include <cstring>
19
20 #include <string>
21
22 #include "slang_rs_type_spec.h"
23
24 enum {
25 #define ENUM_PRIMITIVE_DATA_TYPE(x, name, bits) x,
26 #define PRIMITIVE_DATA_TYPE_RANGE(x, y) \
27 FirstPrimitiveType = x, \
28 LastPrimitiveType = y,
29 PRIMITIVE_DATA_TYPE_ENUMS
30 #undef ENUM_PRIMITIVE_DATA_TYPE
31 #undef PRIMITIVE_DATA_TYPE_RANGE
32
33 #define ENUM_RS_MATRIX_DATA_TYPE(x, name, dim) x,
34 #define RS_MATRIX_DATA_TYPE_RANGE(x, y) \
35 FirstRSMatrixType = x, \
36 LastRSMatrixType = y,
37 RS_MATRIX_DATA_TYPE_ENUMS
38 #undef ENUM_RS_MATRIX_DATA_TYPE
39 #undef RS_MATRIX_DATA_TYPE_RANGE
40
41 #define ENUM_RS_OBJECT_DATA_TYPE(x, name) x,
42 #define RS_OBJECT_DATA_TYPE_RANGE(x, y) \
43 FirstRSObjectType = x, \
44 LastRSObjectType = y,
45 RS_OBJECT_DATA_TYPE_ENUMS
46 #undef ENUM_RS_OBJECT_DATA_TYPE
47 #undef RS_OBJECT_DATA_TYPE_RANGE
48 };
49
50 enum {
51 #define ENUM_RS_DATA_KIND(x) x,
52 RS_DATA_KIND_ENUMS
53 #undef ENUM_RS_DATA_KIND
54 };
55
56 class RSDataTypeSpec {
57 private:
58 const char *mTypeName; // e.g. Float32
59 // FIXME: better name
60 const char *mTypePragmaName; // e.g. float
61 size_t mBits;
62
63 protected:
64 enum {
65 DT_PrimitiveClass,
66 DT_RSMatrixClass,
67 DT_RSObjectClass
68 } mClass;
69
70 public:
RSDataTypeSpec(const char * TypeName,const char * TypePragmaName,size_t Bits)71 RSDataTypeSpec(const char *TypeName,
72 const char *TypePragmaName,
73 size_t Bits)
74 : mTypeName(TypeName),
75 mTypePragmaName(TypePragmaName),
76 mBits(Bits),
77 mClass(DT_PrimitiveClass) {
78 return;
79 }
80
getTypeName() const81 inline const char *getTypeName() const { return mTypeName; }
getTypePragmaName() const82 inline const char *getTypePragmaName() const { return mTypePragmaName; }
getSizeInBit() const83 inline size_t getSizeInBit() const { return mBits; }
isRSMatrix() const84 inline bool isRSMatrix() const { return (mClass == DT_RSMatrixClass); }
isRSObject() const85 inline bool isRSObject() const { return (mClass == DT_RSObjectClass); }
86 };
87
88 class RSMatrixDataTypeSpec : public RSDataTypeSpec {
89 private:
90 unsigned mDim;
91 static float ignore;
92
93 public:
RSMatrixDataTypeSpec(const char * TypeName,const char * TypePragmaName,unsigned Dim)94 RSMatrixDataTypeSpec(const char *TypeName,
95 const char *TypePragmaName,
96 unsigned Dim)
97 : RSDataTypeSpec(TypeName, TypePragmaName, Dim * Dim * sizeof(ignore)),
98 mDim(Dim) {
99 mClass = DT_RSMatrixClass;
100 return;
101 }
102
getDim() const103 inline unsigned getDim() const { return mDim; }
104 };
105
106 class RSObjectDataTypeSpec : public RSDataTypeSpec {
107 public:
RSObjectDataTypeSpec(const char * TypeName,const char * TypePragmaName)108 RSObjectDataTypeSpec(const char *TypeName,
109 const char *TypePragmaName)
110 : RSDataTypeSpec(TypeName, TypePragmaName, 32 /* opaque pointer */) {
111 mClass = DT_RSObjectClass;
112 return;
113 }
114 };
115
116 /////////////////////////////////////////////////////////////////////////////
117
118 // clang::BuiltinType::Kind -> RSDataTypeSpec
119 class ClangBuiltinTypeMap {
120 const char *mBuiltinTypeKind;
121 const RSDataTypeSpec *mDataType;
122
123 public:
ClangBuiltinTypeMap(const char * BuiltinTypeKind,const RSDataTypeSpec * DataType)124 ClangBuiltinTypeMap(const char *BuiltinTypeKind,
125 const RSDataTypeSpec *DataType)
126 : mBuiltinTypeKind(BuiltinTypeKind),
127 mDataType(DataType) {
128 return;
129 }
130
getBuiltinTypeKind() const131 inline const char *getBuiltinTypeKind() const { return mBuiltinTypeKind; }
getDataType() const132 inline const RSDataTypeSpec *getDataType() const { return mDataType; }
133 };
134
135 /////////////////////////////////////////////////////////////////////////////
136
137 class RSDataKindSpec {
138 private:
139 const char *mKindName;
140
141 public:
RSDataKindSpec(const char * KindName)142 explicit RSDataKindSpec(const char *KindName) : mKindName(KindName) {
143 return;
144 }
145
getKindName() const146 inline const char *getKindName() const { return mKindName; }
147 };
148
149 /////////////////////////////////////////////////////////////////////////////
150
151 class RSDataElementSpec {
152 private:
153 const char *mElementName;
154 const RSDataKindSpec *mDataKind;
155 const RSDataTypeSpec *mDataType;
156 bool mIsNormal;
157 unsigned mVectorSize;
158
159 public:
RSDataElementSpec(const char * ElementName,const RSDataKindSpec * DataKind,const RSDataTypeSpec * DataType,bool IsNormal,unsigned VectorSize)160 RSDataElementSpec(const char *ElementName,
161 const RSDataKindSpec *DataKind,
162 const RSDataTypeSpec *DataType,
163 bool IsNormal,
164 unsigned VectorSize)
165 : mElementName(ElementName),
166 mDataKind(DataKind),
167 mDataType(DataType),
168 mIsNormal(IsNormal),
169 mVectorSize(VectorSize) {
170 return;
171 }
172
getElementName() const173 inline const char *getElementName() const { return mElementName; }
getDataKind() const174 inline const RSDataKindSpec *getDataKind() const { return mDataKind; }
getDataType() const175 inline const RSDataTypeSpec *getDataType() const { return mDataType; }
isNormal() const176 inline bool isNormal() const { return mIsNormal; }
getVectorSize() const177 inline unsigned getVectorSize() const { return mVectorSize; }
178 };
179
180 /////////////////////////////////////////////////////////////////////////////
181
182 // -gen-rs-data-type-enums
183 //
184 // ENUM_PRIMITIVE_DATA_TYPE(type, cname, bits)
185 // ENUM_PRIMITIVE_DATA_TYPE_RANGE(begin_type, end_type)
186 // ENUM_RS_MATRIX_DATA_TYPE(type, cname, bits)
187 // ENUM_RS_MATRIX_DATA_TYPE_RANGE(begin_type, end_type)
188 // ENUM_RS_OBJECT_DATA_TYPE(type, cname, bits)
189 // ENUM_RS_OBJECT_DATA_TYPE_RANGE(begin_type, end_type)
190 //
191 // ENUM_RS_DATA_TYPE(type, cname, bits)
192 // e.g., ENUM_RS_DATA_TYPE(Float32, "float", 256)
GenRSDataTypeEnums(const RSDataTypeSpec * const DataTypes[],unsigned NumDataTypes)193 static int GenRSDataTypeEnums(const RSDataTypeSpec *const DataTypes[],
194 unsigned NumDataTypes) {
195 // Alias missing #define
196 #define ALIAS_DEF(x, y) \
197 printf("#ifndef " #x "\n"); \
198 printf("#define " #x "(type, cname, bits) " #y "(type, cname, bits)\n"); \
199 printf("#endif\n\n")
200 ALIAS_DEF(ENUM_PRIMITIVE_DATA_TYPE, ENUM_RS_DATA_TYPE);
201 ALIAS_DEF(ENUM_RS_MATRIX_DATA_TYPE, ENUM_RS_DATA_TYPE);
202 ALIAS_DEF(ENUM_RS_OBJECT_DATA_TYPE, ENUM_RS_DATA_TYPE);
203 #undef ALIAS_DEF
204
205 #define ALIAS_DEF(x) \
206 printf("#ifndef " #x "\n"); \
207 printf("#define " #x "(begin_type, end_type)\n"); \
208 printf("#endif\n\n")
209 ALIAS_DEF(ENUM_PRIMITIVE_DATA_TYPE_RANGE);
210 ALIAS_DEF(ENUM_RS_MATRIX_DATA_TYPE_RANGE);
211 ALIAS_DEF(ENUM_RS_OBJECT_DATA_TYPE_RANGE);
212 #undef ALIAS_DEF
213
214 #define DEF(x) \
215 printf(#x "(%s, \"%s\", %lu)\n", \
216 DataTypes[i]->getTypeName(), \
217 DataTypes[i]->getTypePragmaName(), \
218 (unsigned long) DataTypes[i]->getSizeInBit()); // NOLINT(runtime/int)
219 #define DEF_RANGE(x, begin, end) \
220 printf(#x "(%s, %s)\n\n", \
221 DataTypes[begin]->getTypeName(), \
222 DataTypes[end]->getTypeName())
223 for (unsigned i = FirstPrimitiveType; i <= LastPrimitiveType; i++)
224 DEF(ENUM_PRIMITIVE_DATA_TYPE);
225 DEF_RANGE(ENUM_PRIMITIVE_DATA_TYPE_RANGE,
226 FirstPrimitiveType, LastPrimitiveType);
227 for (unsigned i = FirstRSMatrixType; i <= LastRSMatrixType; i++)
228 DEF(ENUM_RS_MATRIX_DATA_TYPE)
229 DEF_RANGE(ENUM_RS_MATRIX_DATA_TYPE_RANGE,
230 FirstRSMatrixType, LastRSMatrixType);
231 for (unsigned i = FirstRSObjectType; i <= LastRSObjectType; i++)
232 DEF(ENUM_RS_OBJECT_DATA_TYPE)
233 DEF_RANGE(ENUM_RS_OBJECT_DATA_TYPE_RANGE,
234 FirstRSObjectType, LastRSObjectType);
235 #undef DEF
236 #undef DEF_RANGE
237
238 #define UNDEF(x) \
239 printf("#undef " #x "\n")
240 UNDEF(ENUM_PRIMITIVE_DATA_TYPE);
241 UNDEF(ENUM_RS_MATRIX_DATA_TYPE);
242 UNDEF(ENUM_RS_OBJECT_DATA_TYPE);
243 UNDEF(ENUM_PRIMITIVE_DATA_TYPE_RANGE);
244 UNDEF(ENUM_RS_MATRIX_DATA_TYPE_RANGE);
245 UNDEF(ENUM_RS_OBJECT_DATA_TYPE_RANGE);
246 UNDEF(ENUM_RS_DATA_TYPE);
247 return 0;
248 }
249
250 // -gen-clang-builtin-cnames
251 //
252 // ENUM_SUPPORT_BUILTIN_TYPE(builtin_type, type, cname)
253 // e.g., ENUM_SUPPORT_BUILTIN_TYPE(clang::BuiltinType::Float, Float32, "float")
GenClangBuiltinEnum(const ClangBuiltinTypeMap * const ClangBuilitinsMap[],unsigned NumClangBuilitins)254 static int GenClangBuiltinEnum(
255 const ClangBuiltinTypeMap *const ClangBuilitinsMap[],
256 unsigned NumClangBuilitins) {
257 for (unsigned i = 0; i < NumClangBuilitins; i++)
258 printf("ENUM_SUPPORT_BUILTIN_TYPE(%s, %s, \"%s\")\n",
259 ClangBuilitinsMap[i]->getBuiltinTypeKind(),
260 ClangBuilitinsMap[i]->getDataType()->getTypeName(),
261 ClangBuilitinsMap[i]->getDataType()->getTypePragmaName());
262 printf("#undef ENUM_SUPPORT_BUILTIN_TYPE\n");
263 return 0;
264 }
265
266 // -gen-rs-matrix-type-enums
267 //
268 // ENUM_RS_MATRIX_TYPE(type, cname, dim)
269 // e.g., ENUM_RS_MATRIX_TYPE(RSMatrix2x2, "rs_matrix2x2", 2)
GenRSMatrixTypeEnums(const RSDataTypeSpec * const DataTypes[],unsigned NumDataTypes)270 static int GenRSMatrixTypeEnums(const RSDataTypeSpec *const DataTypes[],
271 unsigned NumDataTypes) {
272 for (unsigned i = 0; i < NumDataTypes; i++)
273 if (DataTypes[i]->isRSMatrix()) {
274 const RSMatrixDataTypeSpec *const MatrixDataType =
275 static_cast<const RSMatrixDataTypeSpec *const>(DataTypes[i]);
276 printf("ENUM_RS_MATRIX_TYPE(%s, \"%s\", %u)\n",
277 MatrixDataType->getTypeName(),
278 MatrixDataType->getTypePragmaName(),
279 MatrixDataType->getDim());
280 }
281 printf("#undef ENUM_RS_MATRIX_TYPE\n");
282 return 0;
283 }
284
285 // -gen-rs-object-type-enums
286 //
287 // ENUM_RS_OBJECT_TYPE(type, cname)
288 // e.g., ENUM_RS_OBJECT_TYPE(RSElement, "rs_element")
GenRSObjectTypeEnums(const RSDataTypeSpec * const DataTypes[],unsigned NumDataTypes)289 static int GenRSObjectTypeEnums(const RSDataTypeSpec *const DataTypes[],
290 unsigned NumDataTypes) {
291 for (unsigned i = 0; i < NumDataTypes; i++)
292 if (DataTypes[i]->isRSObject())
293 printf("ENUM_RS_OBJECT_TYPE(%s, \"%s\")\n",
294 DataTypes[i]->getTypeName(),
295 DataTypes[i]->getTypePragmaName());
296 printf("#undef ENUM_RS_OBJECT_TYPE\n");
297 return 0;
298 }
299
300 // -gen-rs-data-kind-enums
301 //
302 // ENUM_RS_DATA_KIND(kind)
303 // e.g., ENUM_RS_DATA_KIND(PixelRGB)
GenRSDataKindEnums(const RSDataKindSpec * const DataKinds[],unsigned NumDataKinds)304 int GenRSDataKindEnums(const RSDataKindSpec *const DataKinds[],
305 unsigned NumDataKinds) {
306 for (unsigned i = 0; i < NumDataKinds; i++)
307 printf("ENUM_RS_DATA_KIND(%s)\n", DataKinds[i]->getKindName());
308 printf("#undef ENUM_RS_DATA_KIND\n");
309 return 0;
310 }
311
312 // -gen-rs-data-element-enums
313 //
314 // ENUM_RS_DATA_ELEMENT(name, dt, dk, normailized, vsize)
315 // e.g., ENUM_RS_DATA_ELEMENT("rs_pixel_rgba", PixelRGB, Unsigned8, true, 4)
GenRSDataElementEnums(const RSDataElementSpec * const DataElements[],unsigned NumDataElements)316 int GenRSDataElementEnums(const RSDataElementSpec *const DataElements[],
317 unsigned NumDataElements) {
318 for (unsigned i = 0; i < NumDataElements; i++)
319 printf("ENUM_RS_DATA_ELEMENT(\"%s\", %s, %s, %s, %d)\n",
320 DataElements[i]->getElementName(),
321 DataElements[i]->getDataKind()->getKindName(),
322 DataElements[i]->getDataType()->getTypeName(),
323 ((DataElements[i]->isNormal()) ? "true" : "false"),
324 DataElements[i]->getVectorSize());
325 printf("#undef ENUM_RS_DATA_ELEMENT\n");
326 return 0;
327 }
328
main(int argc,char ** argv)329 int main(int argc, char **argv) {
330 if (argc < 2) {
331 fprintf(stderr, "usage: %s [gen type]\n", argv[0]);
332 return 1;
333 }
334
335 RSDataTypeSpec *DataTypes[] = {
336 #define ENUM_PRIMITIVE_DATA_TYPE(x, name, bits) \
337 new RSDataTypeSpec(#x , name, bits),
338 #define PRIMITIVE_DATA_TYPE_RANGE(x, y)
339 PRIMITIVE_DATA_TYPE_ENUMS
340 #undef ENUM_PRIMITIVE_DATA_TYPE
341 #undef PRIMITIVE_DATA_TYPE_RANGE
342
343 #define ENUM_RS_MATRIX_DATA_TYPE(x, name, dim) \
344 new RSMatrixDataTypeSpec(#x , name, dim),
345 #define RS_MATRIX_DATA_TYPE_RANGE(x, y)
346 RS_MATRIX_DATA_TYPE_ENUMS
347 #undef ENUM_RS_MATRIX_DATA_TYPE
348 #undef RS_MATRIX_DATA_TYPE_RANGE
349
350 #define ENUM_RS_OBJECT_DATA_TYPE(x, name) \
351 new RSObjectDataTypeSpec(#x, name),
352 #define RS_OBJECT_DATA_TYPE_RANGE(x, y)
353 RS_OBJECT_DATA_TYPE_ENUMS
354 #undef ENUM_RS_OBJECT_DATA_TYPE
355 #undef RS_OBJECT_DATA_TYPE_RANGE
356 };
357
358 unsigned NumDataTypes = sizeof(DataTypes) / sizeof(DataTypes[0]);
359 /////////////////////////////////////////////////////////////////////////////
360
361 ClangBuiltinTypeMap *ClangBuilitinsMap[] = {
362 new ClangBuiltinTypeMap("clang::BuiltinType::Bool", DataTypes[Boolean]),
363 new ClangBuiltinTypeMap("clang::BuiltinType::Char_U", DataTypes[Unsigned8]),
364 new ClangBuiltinTypeMap("clang::BuiltinType::UChar", DataTypes[Unsigned8]),
365 new ClangBuiltinTypeMap("clang::BuiltinType::Char16", DataTypes[Signed16]),
366 new ClangBuiltinTypeMap("clang::BuiltinType::Char32", DataTypes[Signed32]),
367 new ClangBuiltinTypeMap(
368 "clang::BuiltinType::UShort", DataTypes[Unsigned16]),
369 new ClangBuiltinTypeMap(
370 "clang::BuiltinType::UInt", DataTypes[Unsigned32]),
371 new ClangBuiltinTypeMap(
372 "clang::BuiltinType::ULong", DataTypes[Unsigned32]),
373 new ClangBuiltinTypeMap(
374 "clang::BuiltinType::ULongLong", DataTypes[Unsigned64]),
375
376 new ClangBuiltinTypeMap("clang::BuiltinType::Char_S", DataTypes[Signed8]),
377 new ClangBuiltinTypeMap("clang::BuiltinType::SChar", DataTypes[Signed8]),
378 new ClangBuiltinTypeMap("clang::BuiltinType::Short", DataTypes[Signed16]),
379 new ClangBuiltinTypeMap("clang::BuiltinType::Int", DataTypes[Signed32]),
380 new ClangBuiltinTypeMap("clang::BuiltinType::Long", DataTypes[Signed64]),
381 new ClangBuiltinTypeMap(
382 "clang::BuiltinType::LongLong", DataTypes[Signed64]),
383
384 new ClangBuiltinTypeMap("clang::BuiltinType::Float", DataTypes[Float32]),
385 new ClangBuiltinTypeMap("clang::BuiltinType::Double", DataTypes[Float64])
386 };
387
388 unsigned NumClangBuilitins =
389 sizeof(ClangBuilitinsMap) / sizeof(ClangBuilitinsMap[0]);
390
391 /////////////////////////////////////////////////////////////////////////////
392
393 RSDataKindSpec *DataKinds[] = {
394 #define ENUM_RS_DATA_KIND(x) \
395 new RSDataKindSpec(#x),
396 RS_DATA_KIND_ENUMS
397 #undef ENUM_RS_DATA_KIND
398 };
399
400 unsigned NumDataKinds = sizeof(DataKinds) / sizeof(DataKinds[0]);
401 /////////////////////////////////////////////////////////////////////////////
402
403 RSDataElementSpec *DataElements[] = {
404 new RSDataElementSpec("rs_pixel_l",
405 DataKinds[PixelL],
406 DataTypes[Unsigned8],
407 /* IsNormal = */true, /* VectorSize = */1),
408 new RSDataElementSpec("rs_pixel_a",
409 DataKinds[PixelA],
410 DataTypes[Unsigned8],
411 true, 1),
412 new RSDataElementSpec("rs_pixel_la",
413 DataKinds[PixelLA],
414 DataTypes[Unsigned8],
415 true, 2),
416 new RSDataElementSpec("rs_pixel_rgb",
417 DataKinds[PixelRGB],
418 DataTypes[Unsigned8],
419 true, 3),
420 new RSDataElementSpec("rs_pixel_rgba",
421 DataKinds[PixelRGB],
422 DataTypes[Unsigned8],
423 true, 4),
424 new RSDataElementSpec("rs_pixel_rgb565",
425 DataKinds[PixelRGB],
426 DataTypes[Unsigned8],
427 true, 3),
428 new RSDataElementSpec("rs_pixel_rgb5551",
429 DataKinds[PixelRGBA],
430 DataTypes[Unsigned8],
431 true, 4),
432 new RSDataElementSpec("rs_pixel_rgb4444",
433 DataKinds[PixelRGBA],
434 DataTypes[Unsigned8],
435 true, 4),
436 };
437
438 unsigned NumDataElements = sizeof(DataElements) / sizeof(DataElements[0]);
439 /////////////////////////////////////////////////////////////////////////////
440 int Result = 1;
441
442 if (::strcmp(argv[1], "-gen-rs-data-type-enums") == 0)
443 Result = GenRSDataTypeEnums(DataTypes, NumDataTypes);
444 else if (::strcmp(argv[1], "-gen-clang-builtin-enums") == 0)
445 Result = GenClangBuiltinEnum(ClangBuilitinsMap, NumClangBuilitins);
446 else if (::strcmp(argv[1], "-gen-rs-matrix-type-enums") == 0)
447 Result = GenRSMatrixTypeEnums(DataTypes, NumDataTypes);
448 else if (::strcmp(argv[1], "-gen-rs-object-type-enums") == 0)
449 Result = GenRSObjectTypeEnums(DataTypes, NumDataTypes);
450 else if (::strcmp(argv[1], "-gen-rs-data-kind-enums") == 0)
451 Result = GenRSDataKindEnums(DataKinds, NumDataKinds);
452 else if (::strcmp(argv[1], "-gen-rs-data-element-enums") == 0)
453 Result = GenRSDataElementEnums(DataElements, NumDataElements);
454 else
455 fprintf(stderr, "%s: Unknown table generation type '%s'\n",
456 argv[0], argv[1]);
457
458
459 /////////////////////////////////////////////////////////////////////////////
460 for (unsigned i = 0; i < NumDataTypes; i++)
461 delete DataTypes[i];
462 for (unsigned i = 0; i < NumClangBuilitins; i++)
463 delete ClangBuilitinsMap[i];
464 for (unsigned i = 0; i < NumDataKinds; i++)
465 delete DataKinds[i];
466 for (unsigned i = 0; i < NumDataElements; i++)
467 delete DataElements[i];
468
469 return Result;
470 }
471