1 /**************************************************************************
2 *
3 * Copyright 2009 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28
29 #include "util/u_debug.h"
30
31 #include "lp_bld_type.h"
32 #include "lp_bld_const.h"
33 #include "lp_bld_init.h"
34
35
36 LLVMTypeRef
lp_build_elem_type(struct gallivm_state * gallivm,struct lp_type type)37 lp_build_elem_type(struct gallivm_state *gallivm, struct lp_type type)
38 {
39 if (type.floating) {
40 switch(type.width) {
41 case 16:
42 return LLVMIntTypeInContext(gallivm->context, 16);
43 break;
44 case 32:
45 return LLVMFloatTypeInContext(gallivm->context);
46 break;
47 case 64:
48 return LLVMDoubleTypeInContext(gallivm->context);
49 break;
50 default:
51 assert(0);
52 return LLVMFloatTypeInContext(gallivm->context);
53 }
54 }
55 else {
56 return LLVMIntTypeInContext(gallivm->context, type.width);
57 }
58 }
59
60
61 LLVMTypeRef
lp_build_vec_type(struct gallivm_state * gallivm,struct lp_type type)62 lp_build_vec_type(struct gallivm_state *gallivm,struct lp_type type)
63 {
64 LLVMTypeRef elem_type = lp_build_elem_type(gallivm, type);
65 if (type.length == 1)
66 return elem_type;
67 else
68 return LLVMVectorType(elem_type, type.length);
69 }
70
71
72 /**
73 * This function is a mirror of lp_build_elem_type() above.
74 *
75 * XXX: I'm not sure if it wouldn't be easier/efficient to just recreate the
76 * type and check for identity.
77 */
78 boolean
lp_check_elem_type(struct lp_type type,LLVMTypeRef elem_type)79 lp_check_elem_type(struct lp_type type, LLVMTypeRef elem_type)
80 {
81 LLVMTypeKind elem_kind;
82
83 assert(elem_type);
84 if(!elem_type)
85 return FALSE;
86
87 elem_kind = LLVMGetTypeKind(elem_type);
88
89 if (type.floating) {
90 switch(type.width) {
91 case 16:
92 if(elem_kind != LLVMIntegerTypeKind)
93 return FALSE;
94 break;
95 case 32:
96 if(elem_kind != LLVMFloatTypeKind)
97 return FALSE;
98 break;
99 case 64:
100 if(elem_kind != LLVMDoubleTypeKind)
101 return FALSE;
102 break;
103 default:
104 assert(0);
105 return FALSE;
106 }
107 }
108 else {
109 if(elem_kind != LLVMIntegerTypeKind)
110 return FALSE;
111
112 if(LLVMGetIntTypeWidth(elem_type) != type.width)
113 return FALSE;
114 }
115
116 return TRUE;
117 }
118
119
120 boolean
lp_check_vec_type(struct lp_type type,LLVMTypeRef vec_type)121 lp_check_vec_type(struct lp_type type, LLVMTypeRef vec_type)
122 {
123 LLVMTypeRef elem_type;
124
125 assert(vec_type);
126 if(!vec_type)
127 return FALSE;
128
129 if (type.length == 1)
130 return lp_check_elem_type(type, vec_type);
131
132 if(LLVMGetTypeKind(vec_type) != LLVMVectorTypeKind)
133 return FALSE;
134
135 if(LLVMGetVectorSize(vec_type) != type.length)
136 return FALSE;
137
138 elem_type = LLVMGetElementType(vec_type);
139
140 return lp_check_elem_type(type, elem_type);
141 }
142
143
144 boolean
lp_check_value(struct lp_type type,LLVMValueRef val)145 lp_check_value(struct lp_type type, LLVMValueRef val)
146 {
147 LLVMTypeRef vec_type;
148
149 assert(val);
150 if(!val)
151 return FALSE;
152
153 vec_type = LLVMTypeOf(val);
154
155 return lp_check_vec_type(type, vec_type);
156 }
157
158
159 LLVMTypeRef
lp_build_int_elem_type(struct gallivm_state * gallivm,struct lp_type type)160 lp_build_int_elem_type(struct gallivm_state *gallivm, struct lp_type type)
161 {
162 return LLVMIntTypeInContext(gallivm->context, type.width);
163 }
164
165
166 LLVMTypeRef
lp_build_int_vec_type(struct gallivm_state * gallivm,struct lp_type type)167 lp_build_int_vec_type(struct gallivm_state *gallivm, struct lp_type type)
168 {
169 LLVMTypeRef elem_type = lp_build_int_elem_type(gallivm, type);
170 if (type.length == 1)
171 return elem_type;
172 else
173 return LLVMVectorType(elem_type, type.length);
174 }
175
176
177 /**
178 * Create element of vector type
179 */
180 struct lp_type
lp_elem_type(struct lp_type type)181 lp_elem_type(struct lp_type type)
182 {
183 struct lp_type res_type;
184
185 assert(type.length > 1);
186 res_type = type;
187 res_type.length = 1;
188
189 return res_type;
190 }
191
192
193 /**
194 * Create unsigned integer type variation of given type.
195 */
196 struct lp_type
lp_uint_type(struct lp_type type)197 lp_uint_type(struct lp_type type)
198 {
199 struct lp_type res_type;
200
201 assert(type.length <= LP_MAX_VECTOR_LENGTH);
202 memset(&res_type, 0, sizeof res_type);
203 res_type.width = type.width;
204 res_type.length = type.length;
205
206 return res_type;
207 }
208
209
210 /**
211 * Create signed integer type variation of given type.
212 */
213 struct lp_type
lp_int_type(struct lp_type type)214 lp_int_type(struct lp_type type)
215 {
216 struct lp_type res_type;
217
218 assert(type.length <= LP_MAX_VECTOR_LENGTH);
219 memset(&res_type, 0, sizeof res_type);
220 res_type.width = type.width;
221 res_type.length = type.length;
222 res_type.sign = 1;
223
224 return res_type;
225 }
226
227
228 /**
229 * Return the type with twice the bit width (hence half the number of elements).
230 */
231 struct lp_type
lp_wider_type(struct lp_type type)232 lp_wider_type(struct lp_type type)
233 {
234 struct lp_type res_type;
235
236 memcpy(&res_type, &type, sizeof res_type);
237 res_type.width *= 2;
238 res_type.length /= 2;
239
240 assert(res_type.length);
241
242 return res_type;
243 }
244
245
246 /**
247 * Return the size of the LLVMType in bits.
248 * XXX this function doesn't necessarily handle all LLVM types.
249 */
250 unsigned
lp_sizeof_llvm_type(LLVMTypeRef t)251 lp_sizeof_llvm_type(LLVMTypeRef t)
252 {
253 LLVMTypeKind k = LLVMGetTypeKind(t);
254
255 switch (k) {
256 case LLVMIntegerTypeKind:
257 return LLVMGetIntTypeWidth(t);
258 case LLVMFloatTypeKind:
259 return 8 * sizeof(float);
260 case LLVMDoubleTypeKind:
261 return 8 * sizeof(double);
262 case LLVMVectorTypeKind:
263 {
264 LLVMTypeRef elem = LLVMGetElementType(t);
265 unsigned len = LLVMGetVectorSize(t);
266 return len * lp_sizeof_llvm_type(elem);
267 }
268 break;
269 case LLVMArrayTypeKind:
270 {
271 LLVMTypeRef elem = LLVMGetElementType(t);
272 unsigned len = LLVMGetArrayLength(t);
273 return len * lp_sizeof_llvm_type(elem);
274 }
275 break;
276 default:
277 assert(0 && "Unexpected type in lp_get_llvm_type_size()");
278 return 0;
279 }
280 }
281
282
283 /**
284 * Return string name for a LLVMTypeKind. Useful for debugging.
285 */
286 const char *
lp_typekind_name(LLVMTypeKind t)287 lp_typekind_name(LLVMTypeKind t)
288 {
289 switch (t) {
290 case LLVMVoidTypeKind:
291 return "LLVMVoidTypeKind";
292 case LLVMFloatTypeKind:
293 return "LLVMFloatTypeKind";
294 case LLVMDoubleTypeKind:
295 return "LLVMDoubleTypeKind";
296 case LLVMX86_FP80TypeKind:
297 return "LLVMX86_FP80TypeKind";
298 case LLVMFP128TypeKind:
299 return "LLVMFP128TypeKind";
300 case LLVMPPC_FP128TypeKind:
301 return "LLVMPPC_FP128TypeKind";
302 case LLVMLabelTypeKind:
303 return "LLVMLabelTypeKind";
304 case LLVMIntegerTypeKind:
305 return "LLVMIntegerTypeKind";
306 case LLVMFunctionTypeKind:
307 return "LLVMFunctionTypeKind";
308 case LLVMStructTypeKind:
309 return "LLVMStructTypeKind";
310 case LLVMArrayTypeKind:
311 return "LLVMArrayTypeKind";
312 case LLVMPointerTypeKind:
313 return "LLVMPointerTypeKind";
314 case LLVMVectorTypeKind:
315 return "LLVMVectorTypeKind";
316 case LLVMMetadataTypeKind:
317 return "LLVMMetadataTypeKind";
318 default:
319 return "unknown LLVMTypeKind";
320 }
321 }
322
323
324 /**
325 * Print an LLVMTypeRef. Like LLVMDumpValue(). For debugging.
326 */
327 void
lp_dump_llvmtype(LLVMTypeRef t)328 lp_dump_llvmtype(LLVMTypeRef t)
329 {
330 LLVMTypeKind k = LLVMGetTypeKind(t);
331
332 if (k == LLVMVectorTypeKind) {
333 LLVMTypeRef te = LLVMGetElementType(t);
334 LLVMTypeKind ke = LLVMGetTypeKind(te);
335 unsigned len = LLVMGetVectorSize(t);
336 if (ke == LLVMIntegerTypeKind) {
337 unsigned b = LLVMGetIntTypeWidth(te);
338 debug_printf("Vector [%u] of %u-bit Integer\n", len, b);
339 }
340 else {
341 debug_printf("Vector [%u] of %s\n", len, lp_typekind_name(ke));
342 }
343 }
344 else if (k == LLVMArrayTypeKind) {
345 LLVMTypeRef te = LLVMGetElementType(t);
346 LLVMTypeKind ke = LLVMGetTypeKind(te);
347 unsigned len = LLVMGetArrayLength(t);
348 debug_printf("Array [%u] of %s\n", len, lp_typekind_name(ke));
349 }
350 else if (k == LLVMIntegerTypeKind) {
351 unsigned b = LLVMGetIntTypeWidth(t);
352 debug_printf("%u-bit Integer\n", b);
353 }
354 else if (k == LLVMPointerTypeKind) {
355 LLVMTypeRef te = LLVMGetElementType(t);
356 debug_printf("Pointer to ");
357 lp_dump_llvmtype(te);
358 }
359 else {
360 debug_printf("%s\n", lp_typekind_name(k));
361 }
362 }
363
364
365 void
lp_build_context_init(struct lp_build_context * bld,struct gallivm_state * gallivm,struct lp_type type)366 lp_build_context_init(struct lp_build_context *bld,
367 struct gallivm_state *gallivm,
368 struct lp_type type)
369 {
370 bld->gallivm = gallivm;
371 bld->type = type;
372
373 bld->int_elem_type = lp_build_int_elem_type(gallivm, type);
374 if (type.floating)
375 bld->elem_type = lp_build_elem_type(gallivm, type);
376 else
377 bld->elem_type = bld->int_elem_type;
378
379 if (type.length == 1) {
380 bld->int_vec_type = bld->int_elem_type;
381 bld->vec_type = bld->elem_type;
382 }
383 else {
384 bld->int_vec_type = LLVMVectorType(bld->int_elem_type, type.length);
385 bld->vec_type = LLVMVectorType(bld->elem_type, type.length);
386 }
387
388 bld->undef = LLVMGetUndef(bld->vec_type);
389 bld->zero = LLVMConstNull(bld->vec_type);
390 bld->one = lp_build_one(gallivm, type);
391 }
392
393
394 /**
395 * Count the number of instructions in a function.
396 */
397 static unsigned
lp_build_count_instructions(LLVMValueRef function)398 lp_build_count_instructions(LLVMValueRef function)
399 {
400 unsigned num_instrs = 0;
401 LLVMBasicBlockRef block;
402
403 block = LLVMGetFirstBasicBlock(function);
404 while (block) {
405 LLVMValueRef instr;
406 instr = LLVMGetFirstInstruction(block);
407 while (instr) {
408 ++num_instrs;
409
410 instr = LLVMGetNextInstruction(instr);
411 }
412 block = LLVMGetNextBasicBlock(block);
413 }
414
415 return num_instrs;
416 }
417
418
419 /**
420 * Count the number of instructions in a module.
421 */
422 unsigned
lp_build_count_ir_module(LLVMModuleRef module)423 lp_build_count_ir_module(LLVMModuleRef module)
424 {
425 LLVMValueRef func;
426 unsigned num_instrs = 0;
427
428 func = LLVMGetFirstFunction(module);
429 while (func) {
430 num_instrs += lp_build_count_instructions(func);
431 func = LLVMGetNextFunction(func);
432 }
433 return num_instrs;
434 }
435