irmode.c 21.3 KB
Newer Older
Christian Würdig's avatar
Christian Würdig committed
1
/*
Michael Beck's avatar
Michael Beck committed
2
 * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
Christian Würdig's avatar
Christian Würdig committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 *
 * This file is part of libFirm.
 *
 * This file may be distributed and/or modified under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation and appearing in the file LICENSE.GPL included in the
 * packaging of this file.
 *
 * Licensees holding valid libFirm Professional Edition licenses may use
 * this file in accordance with the libFirm Commercial License.
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.
 */

Matthias Braun's avatar
Matthias Braun committed
20
21
22
23
24
/**
 * @file
 * @brief    Data modes of operations.
 * @author   Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Mathias Heil
 * @version  $Id$
Götz Lindenmaier's avatar
Götz Lindenmaier committed
25
 */
Boris Boesler's avatar
added    
Boris Boesler committed
26
#ifdef HAVE_CONFIG_H
Michael Beck's avatar
Michael Beck committed
27
# include "config.h"
Boris Boesler's avatar
added    
Boris Boesler committed
28
29
#endif

Michael Beck's avatar
Michael Beck committed
30
#ifdef HAVE_STDLIB_H
31
# include <stdlib.h>
Michael Beck's avatar
Michael Beck committed
32
33
#endif
#ifdef HAVE_STRING_H
34
# include <string.h>
Michael Beck's avatar
Michael Beck committed
35
36
37
#endif

# include <stddef.h>
38

39
# include "irprog_t.h"
40
41
# include "irmode_t.h"
# include "ident.h"
Michael Beck's avatar
Michael Beck committed
42
# include "tv_t.h"
43
# include "obst.h"
44
# include "irhooks.h"
45
# include "irtools.h"
Matthias Braun's avatar
Matthias Braun committed
46
# include "array.h"
Christian Schäfer's avatar
Christian Schäfer committed
47

48
49
50
/* * *
 * local values
 * * */
51

Christian Schäfer's avatar
Christian Schäfer committed
52

Michael Beck's avatar
Michael Beck committed
53
/** dynamic array to hold all modes */
54
static struct obstack modes;
Christian Schäfer's avatar
Christian Schäfer committed
55

Michael Beck's avatar
Michael Beck committed
56
/** number of defined modes */
57
static int num_modes = 0;
Christian Schäfer's avatar
Christian Schäfer committed
58

Matthias Braun's avatar
Matthias Braun committed
59
60
static ir_mode **mode_list;

61
62
63
/* * *
 * local functions
 * * */
Christian Schäfer's avatar
Christian Schäfer committed
64

65
/**
66
 * Compare modes that don't need to have their code field
67
 * correctly set
68
69
70
 *
 * TODO: Add other fields
 **/
71
72
73
74
75
76
77
78
79
INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n) {
	if (m == n) return 1;
	if (m->sort         == n->sort &&
		m->arithmetic   == n->arithmetic &&
		m->size         == n->size &&
		m->sign         == n->sign  &&
		m->modulo_shift == n->modulo_shift &&
		m->vector_elem  == n->vector_elem)
		return 1;
Christian Schäfer's avatar
Christian Schäfer committed
80

81
	return 0;
82
}
Matthias Heil's avatar
Matthias Heil committed
83

84
/**
85
 * searches the modes obstack for the given mode and returns
86
 * a pointer on an equal mode already in the array, NULL if
87
88
 * none found
 */
89
static ir_mode *find_mode(const ir_mode *m) {
Matthias Braun's avatar
Matthias Braun committed
90
91
92
93
94
	unsigned len = ARR_LEN(mode_list);
	unsigned i;

	for(i = 0; i < len; ++i) {
		ir_mode *n = mode_list[i];
95
96
97
98
99
		if (modes_are_equal(n, m))
			return n;
	}

	return NULL;
100
}
Christian Schäfer's avatar
Christian Schäfer committed
101

102
103
104
/**
 * sets special values of modes
 */
105
106
static void set_mode_values(ir_mode* mode) {
	switch (get_mode_sort(mode))    {
107
	case irms_reference:
108
109
110
111
112
113
114
	case irms_int_number:
	case irms_float_number:
		mode->min  = get_tarval_min(mode);
		mode->max  = get_tarval_max(mode);
		mode->null = get_tarval_null(mode);
		mode->one  = get_tarval_one(mode);
		mode->minus_one = get_tarval_minus_one(mode);
115
116
117
118
119
		if(get_mode_sort(mode) != irms_float_number) {
			mode->all_one = get_tarval_all_one(mode);
		} else {
			mode->all_one = tarval_bad;
		}
120
121
122
123
124
125
126
127
		break;

	case irms_internal_boolean:
		mode->min  = tarval_b_false;
		mode->max  = tarval_b_true;
		mode->null = tarval_b_false;
		mode->one  = tarval_b_true;
		mode->minus_one = tarval_bad;
128
		mode->all_one = tarval_b_true;
129
130
131
132
133
134
135
136
137
138
139
140
		break;

	case irms_auxiliary:
	case irms_memory:
	case irms_control_flow:
		mode->min  = tarval_bad;
		mode->max  = tarval_bad;
		mode->null = tarval_bad;
		mode->one  = tarval_bad;
		mode->minus_one = tarval_bad;
		break;
	}
141
}
142

143
144
145
/* * *
 * globals defined in irmode.h
 * * */
Matthias Heil's avatar
Matthias Heil committed
146

147
/* --- Predefined modes --- */
Christian Schäfer's avatar
Christian Schäfer committed
148

149
150
151
152
153
/* FIRM internal modes: */
ir_mode *mode_T;
ir_mode *mode_X;
ir_mode *mode_M;
ir_mode *mode_BB;
154
155
ir_mode *mode_ANY;
ir_mode *mode_BAD;
Christian Schäfer's avatar
Christian Schäfer committed
156

157
158
159
160
/* predefined numerical modes: */
ir_mode *mode_F;    /* float */
ir_mode *mode_D;    /* double */
ir_mode *mode_E;    /* long double */
Christian Schäfer's avatar
Christian Schäfer committed
161

162
163
164
165
166
167
168
169
ir_mode *mode_Bs;   /* integral values, signed and unsigned */
ir_mode *mode_Bu;   /* 8 bit */
ir_mode *mode_Hs;   /* 16 bit */
ir_mode *mode_Hu;
ir_mode *mode_Is;   /* 32 bit */
ir_mode *mode_Iu;
ir_mode *mode_Ls;   /* 64 bit */
ir_mode *mode_Lu;
170
171
ir_mode *mode_LLs;  /* 128 bit */
ir_mode *mode_LLu;
Christian Schäfer's avatar
Christian Schäfer committed
172

173
174
ir_mode *mode_b;
ir_mode *mode_P;
Michael Beck's avatar
fixed:    
Michael Beck committed
175
176

/* machine specific modes */
177
178
ir_mode *mode_P_code;   /**< machine specific pointer mode for code addresses */
ir_mode *mode_P_data;   /**< machine specific pointer mode for data addresses */
179

180
181
182
183
184
/* * *
 * functions defined in irmode.h
 * * */

/* JNI access functions */
185
186
187
188
189
190
191
192
193
194
195
196
ir_mode *get_modeT(void) { return mode_T; }
ir_mode *get_modeF(void) { return mode_F; }
ir_mode *get_modeD(void) { return mode_D; }
ir_mode *get_modeE(void) { return mode_E; }
ir_mode *get_modeBs(void) { return mode_Bs; }
ir_mode *get_modeBu(void) { return mode_Bu; }
ir_mode *get_modeHs(void) { return mode_Hs; }
ir_mode *get_modeHu(void) { return mode_Hu; }
ir_mode *get_modeIs(void) { return mode_Is; }
ir_mode *get_modeIu(void) { return mode_Iu; }
ir_mode *get_modeLs(void) { return mode_Ls; }
ir_mode *get_modeLu(void) { return mode_Lu; }
197
198
ir_mode *get_modeLLs(void){ return mode_LLs; }
ir_mode *get_modeLLu(void){ return mode_LLu; }
199
200
201
202
203
204
205
ir_mode *get_modeb(void) { return mode_b; }
ir_mode *get_modeP(void) { return mode_P; }
ir_mode *get_modeX(void) { return mode_X; }
ir_mode *get_modeM(void) { return mode_M; }
ir_mode *get_modeBB(void) { return mode_BB; }
ir_mode *get_modeANY(void) { return mode_ANY; }
ir_mode *get_modeBAD(void) { return mode_BAD; }
206

207

208
ir_mode *(get_modeP_code)(void) {
209
	return _get_modeP_code();
Michael Beck's avatar
Michael Beck committed
210
211
}

212
ir_mode *(get_modeP_data)(void) {
213
	return _get_modeP_data();
214
215
216
}

void set_modeP_code(ir_mode *p) {
217
218
	assert(mode_is_reference(p));
	mode_P_code = p;
219
220
221
}

void set_modeP_data(ir_mode *p) {
222
223
	assert(mode_is_reference(p));
	mode_P_data = p;
Michael Beck's avatar
Michael Beck committed
224
}
225

226
/**
227
228
229
 * Registers a new mode.
 *
 * @param new_mode  The new mode template.
230
 */
231
232
static ir_mode *register_mode(const ir_mode *new_mode) {
	ir_mode *mode = NULL;
233

234
	assert(new_mode);
235

236
237
	/* copy mode struct to modes array */
	mode = (ir_mode *)obstack_copy(&modes, new_mode, sizeof(*mode));
Matthias Braun's avatar
Matthias Braun committed
238
	ARR_APP1(ir_mode*, mode_list, mode);
239

240
	mode->kind = k_ir_mode;
241
242
243
244
	if (num_modes >= irm_max)  {
		mode->code = num_modes;
	}
	num_modes++;
245

246
247
	/* add the new mode to the irp list of modes */
	add_irp_mode(mode);
248

249
	set_mode_values(mode);
250

251
252
	hook_new_mode(new_mode, mode);
	return mode;
253
254
255
256
257
}

/*
 * Creates a new mode.
 */
Michael Beck's avatar
Michael Beck committed
258
ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int sign,
259
                     mode_arithmetic arithmetic, unsigned int modulo_shift)
260
{
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
	ir_mode mode_tmpl;
	ir_mode *mode = NULL;

	mode_tmpl.name         = new_id_from_str(name);
	mode_tmpl.sort         = sort;
	mode_tmpl.size         = bit_size;
	mode_tmpl.sign         = sign ? 1 : 0;
	mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
	mode_tmpl.vector_elem  = 1;
	mode_tmpl.arithmetic   = arithmetic;
	mode_tmpl.link         = NULL;
	mode_tmpl.tv_priv      = NULL;

	mode = find_mode(&mode_tmpl);
	if (mode) {
		hook_new_mode(&mode_tmpl, mode);
		return mode;
	}

	/* sanity checks */
	switch (sort) {
	case irms_auxiliary:
	case irms_control_flow:
	case irms_memory:
	case irms_internal_boolean:
		assert(0 && "internal modes cannot be user defined");
		break;

	case irms_float_number:
	case irms_int_number:
	case irms_reference:
		mode = register_mode(&mode_tmpl);
	}
	return mode;
295
296
}

297
298
299
/*
 * Creates a new vector mode.
 */
Michael Beck's avatar
Michael Beck committed
300
ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int sign,
301
                            mode_arithmetic arithmetic, unsigned int modulo_shift)
302
{
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
	ir_mode mode_tmpl;
	ir_mode *mode = NULL;

	mode_tmpl.name         = new_id_from_str(name);
	mode_tmpl.sort         = sort;
	mode_tmpl.size         = bit_size * num_of_elem;
	mode_tmpl.sign         = sign ? 1 : 0;
	mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
	mode_tmpl.vector_elem  = num_of_elem;
	mode_tmpl.arithmetic   = arithmetic;
	mode_tmpl.link         = NULL;
	mode_tmpl.tv_priv      = NULL;

	mode = find_mode(&mode_tmpl);
	if (mode) {
		hook_new_mode(&mode_tmpl, mode);
		return mode;
	}

	if (num_of_elem <= 1) {
		assert(0 && "vector modes should have at least 2 elements");
		return NULL;
	}

	/* sanity checks */
	switch (sort) {
	case irms_auxiliary:
	case irms_control_flow:
	case irms_memory:
	case irms_internal_boolean:
		assert(0 && "internal modes cannot be user defined");
		break;

	case irms_reference:
		assert(0 && "only integer and floating point modes can be vectorized");
		break;

	case irms_float_number:
		assert(0 && "not yet implemented");
		break;

	case irms_int_number:
		mode = register_mode(&mode_tmpl);
	}
	return mode;
348
349
}

350
/* Functions for the direct access to all attributes of an ir_mode */
351
modecode (get_mode_modecode)(const ir_mode *mode) {
352
	return _get_mode_modecode(mode);
Christian Schäfer's avatar
Christian Schäfer committed
353
354
}

355
ident *(get_mode_ident)(const ir_mode *mode) {
356
	return _get_mode_ident(mode);
Christian Schäfer's avatar
Christian Schäfer committed
357
358
}

359
const char *get_mode_name(const ir_mode *mode) {
360
	return get_id_str(mode->name);
Christian Schäfer's avatar
Christian Schäfer committed
361
362
}

363
mode_sort (get_mode_sort)(const ir_mode* mode) {
364
	return _get_mode_sort(mode);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
365
366
}

367
unsigned (get_mode_size_bits)(const ir_mode *mode) {
368
	return _get_mode_size_bits(mode);
Christian Schäfer's avatar
Christian Schäfer committed
369
370
}

371
unsigned (get_mode_size_bytes)(const ir_mode *mode) {
372
	return _get_mode_size_bytes(mode);
Götz Lindenmaier's avatar
Götz Lindenmaier committed
373
374
}

375
int (get_mode_sign)(const ir_mode *mode) {
376
	return _get_mode_sign(mode);
377
378
}

379
mode_arithmetic (get_mode_arithmetic)(const ir_mode *mode) {
380
	return get_mode_arithmetic(mode);
381
382
}

383
384
385
386
387

/* Attribute modulo shift specifies for modes of kind irms_int_number
 *  whether shift applies modulo to value of bits to shift.  Asserts
 *  if mode is not irms_int_number.
 */
388
unsigned int (get_mode_modulo_shift)(const ir_mode *mode) {
389
	return _get_mode_modulo_shift(mode);
390
391
}

392
unsigned int (get_mode_n_vector_elems)(const ir_mode *mode) {
393
	return _get_mode_vector_elems(mode);
394
395
}

396
void *(get_mode_link)(const ir_mode *mode) {
397
	return _get_mode_link(mode);
398
399
}

400
void (set_mode_link)(ir_mode *mode, void *l) {
401
	_set_mode_link(mode, l);
402
403
}

404
tarval *get_mode_min(ir_mode *mode) {
405
	assert(mode);
406
	assert(get_mode_modecode(mode) < (modecode) num_modes);
407
	assert(mode_is_data(mode));
Christian Schäfer's avatar
Christian Schäfer committed
408

409
	return mode->min;
Christian Schäfer's avatar
Christian Schäfer committed
410
411
}

412
tarval *get_mode_max(ir_mode *mode) {
413
	assert(mode);
414
	assert(get_mode_modecode(mode) < (modecode) num_modes);
415
	assert(mode_is_data(mode));
Christian Schäfer's avatar
Christian Schäfer committed
416

417
	return mode->max;
Christian Schäfer's avatar
Christian Schäfer committed
418
419
}

420
tarval *get_mode_null(ir_mode *mode) {
421
	assert(mode);
422
	assert(get_mode_modecode(mode) < (modecode) num_modes);
423
	assert(mode_is_datab(mode));
Christian Schäfer's avatar
Christian Schäfer committed
424

425
	return mode->null;
Christian Schäfer's avatar
Christian Schäfer committed
426
427
}

428
tarval *get_mode_one(ir_mode *mode) {
429
	assert(mode);
430
	assert(get_mode_modecode(mode) < (modecode) num_modes);
Matthias Braun's avatar
Matthias Braun committed
431
	assert(mode_is_datab(mode));
Christian Schäfer's avatar
Christian Schäfer committed
432

433
	return mode->one;
Christian Schäfer's avatar
Christian Schäfer committed
434
435
}

436
tarval *get_mode_minus_one(ir_mode *mode) {
437
	assert(mode);
438
	assert(get_mode_modecode(mode) < (modecode) num_modes);
439
	assert(mode_is_data(mode));
Michael Beck's avatar
Michael Beck committed
440

441
	return mode->minus_one;
Michael Beck's avatar
Michael Beck committed
442
443
}

444
tarval *get_mode_all_one(ir_mode *mode) {
445
446
	assert(mode);
	assert(get_mode_modecode(mode) < (modecode) num_modes);
Matthias Braun's avatar
Matthias Braun committed
447
	assert(mode_is_datab(mode));
448
449
450
	return mode->all_one;
}

451
tarval *get_mode_infinite(ir_mode *mode) {
452
	assert(mode);
453
	assert(get_mode_modecode(mode) < (modecode) num_modes);
454
	assert(mode_is_float(mode));
455

456
	return get_tarval_plus_inf(mode);
Christian Schäfer's avatar
Christian Schäfer committed
457
458
}

459
tarval *get_mode_NAN(ir_mode *mode) {
460
	assert(mode);
461
	assert(get_mode_modecode(mode) < (modecode) num_modes);
462
	assert(mode_is_float(mode));
463

464
	return get_tarval_nan(mode);
Christian Schäfer's avatar
Christian Schäfer committed
465
466
}

467
int is_mode(void *thing) {
468
469
470
471
	if (get_kind(thing) == k_ir_mode)
		return 1;
	else
		return 0;
472
473
}

474
int (mode_is_signed)(const ir_mode *mode) {
475
	return _mode_is_signed(mode);
Christian Schäfer's avatar
Christian Schäfer committed
476
477
}

478
int (mode_is_float)(const ir_mode *mode) {
479
	return _mode_is_float(mode);
Christian Schäfer's avatar
Christian Schäfer committed
480
481
}

482
int (mode_is_int)(const ir_mode *mode) {
483
	return _mode_is_int(mode);
Christian Schäfer's avatar
Christian Schäfer committed
484
485
}

486
int (mode_is_reference)(const ir_mode *mode) {
487
	return _mode_is_reference(mode);
488
489
}

490
int (mode_is_num)(const ir_mode *mode) {
491
	return _mode_is_num(mode);
Christian Schäfer's avatar
Christian Schäfer committed
492
493
}

494
int (mode_is_data)(const ir_mode *mode) {
495
	return _mode_is_data(mode);
Christian Schäfer's avatar
Christian Schäfer committed
496
497
}

498
int (mode_is_datab)(const ir_mode *mode) {
499
	return _mode_is_datab(mode);
Christian Schäfer's avatar
Christian Schäfer committed
500
501
}

502
int (mode_is_dataM)(const ir_mode *mode) {
503
	return _mode_is_dataM(mode);
Christian Schäfer's avatar
Christian Schäfer committed
504
}
505

506
int (mode_is_float_vector)(const ir_mode *mode) {
507
	return _mode_is_float_vector(mode);
508
509
}

510
int (mode_is_int_vector)(const ir_mode *mode) {
511
	return _mode_is_int_vector(mode);
Michael Beck's avatar
Michael Beck committed
512
513
}

514
/* Returns true if sm can be converted to lm without loss. */
515
int smaller_mode(const ir_mode *sm, const ir_mode *lm) {
516
517
518
519
520
521
522
523
524
525
526
527
528
529
	int sm_bits, lm_bits;

	assert(sm);
	assert(lm);

	if (sm == lm) return 1;

	sm_bits = get_mode_size_bits(sm);
	lm_bits = get_mode_size_bits(lm);

	switch (get_mode_sort(sm)) {
	case irms_int_number:
		switch (get_mode_sort(lm)) {
		case irms_int_number:
Matthias Braun's avatar
Matthias Braun committed
530
531
532
533
534
535
			if(get_mode_arithmetic(sm) != get_mode_arithmetic(lm))
				return 0;

			/* only two complement implemented */
			assert(get_mode_arithmetic(sm)==irma_twos_complement);

536
537
538
539
540
541
			/* integers are convertable if
			 *   - both have the same sign and lm is the larger one
			 *   - lm is the signed one and is at least two bits larger
			 *     (one for the sign, one for the highest bit of sm)
			 *   - sm & lm are two_complement and lm has greater or equal number of bits
			 */
Matthias Braun's avatar
Matthias Braun committed
542
543
544
545
546
547
548
549
550
			if(mode_is_signed(sm)) {
				if(!mode_is_signed(lm))
					return 0;
				return sm_bits <= lm_bits;
			} else {
				if(mode_is_signed(lm)) {
					return sm_bits < lm_bits;
				}
				return sm_bits <= lm_bits;
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
			}
			break;

		case irms_float_number:
			/* int to float works if the float is large enough */
			return 0;

		default:
			break;
		}
		break;

	case irms_float_number:
		if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
			if ( (get_mode_sort(lm) == irms_float_number)
				&& (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
				return 1;
		}
		break;

	case irms_reference:
		/* do exist machines out there with different pointer lenghts ?*/
		return 0;

575
576
577
	case irms_internal_boolean:
		return mode_is_int(lm);

578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
	default:
		break;
	}

	/* else */
	return 0;
}

/* Return the signed integer equivalent mode for an reference mode. */
ir_mode *get_reference_mode_signed_eq(ir_mode *mode) {
	assert(mode_is_reference(mode));
	return mode->eq_signed;
}

/* Sets the signed integer equivalent mode for an reference mode. */
void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode) {
	assert(mode_is_reference(ref_mode));
	assert(mode_is_int(int_mode));
	ref_mode->eq_signed = int_mode;
}

/* Return the unsigned integer equivalent mode for an reference mode. */
ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode) {
	assert(mode_is_reference(mode));
	return mode->eq_unsigned;
}

/* Sets the unsigned integer equivalent mode for an reference mode. */
void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode) {
	assert(mode_is_reference(ref_mode));
	assert(mode_is_int(int_mode));
	ref_mode->eq_unsigned = int_mode;
610
611
}

612
/* initialization, build the default modes */
613
void init_mode(void) {
614
	ir_mode newmode;
615

616
	obstack_init(&modes);
Matthias Braun's avatar
Matthias Braun committed
617
	mode_list = NEW_ARR_F(ir_mode*, 0);
618

619
620
	num_modes  =  0;
	/* initialize predefined modes */
621

622
623
624
625
626
627
628
629
630
631
	/* Internal Modes */
	newmode.arithmetic   = irma_none;
	newmode.size         = 0;
	newmode.sign         = 0;
	newmode.modulo_shift = 0;
	newmode.vector_elem  = 0;
	newmode.eq_signed    = NULL;
	newmode.eq_unsigned  = NULL;
	newmode.link         = NULL;
	newmode.tv_priv      = NULL;
632

633
634
	/* Control Flow Modes*/
	newmode.sort    = irms_control_flow;
635

636
637
638
	/* Basic Block */
	newmode.name    = new_id_from_chars("BB", 2);
	newmode.code    = irm_BB;
639

640
	mode_BB = register_mode(&newmode);
641

642
643
644
	/* eXecution */
	newmode.name    = new_id_from_chars("X", 1);
	newmode.code    = irm_X;
645

646
	mode_X = register_mode(&newmode);
647

648
649
	/* Memory Modes */
	newmode.sort    = irms_memory;
650

651
652
653
	/* Memory */
	newmode.name    = new_id_from_chars("M", 1);
	newmode.code    = irm_M;
654

655
	mode_M = register_mode(&newmode);
656

657
658
	/* Auxiliary Modes */
	newmode.sort    = irms_auxiliary,
659

660
661
662
	/* Tuple */
	newmode.name    = new_id_from_chars("T", 1);
	newmode.code    = irm_T;
663

664
	mode_T = register_mode(&newmode);
665

666
667
668
	/* ANY */
	newmode.name    = new_id_from_chars("ANY", 3);
	newmode.code    = irm_ANY;
669

670
	mode_ANY = register_mode(&newmode);
671

672
673
674
	/* BAD */
	newmode.name    = new_id_from_chars("BAD", 3);
	newmode.code    = irm_BAD;
675

676
	mode_BAD = register_mode(&newmode);
677

678
679
	/* Internal Boolean Modes */
	newmode.sort    = irms_internal_boolean;
680

681
682
683
	/* boolean */
	newmode.name    = new_id_from_chars("b", 1);
	newmode.code    = irm_b;
684

685
	mode_b = register_mode(&newmode);
686

687
688
	/* Data Modes */
	newmode.vector_elem = 1;
689

690
691
692
	/* Float Number Modes */
	newmode.sort       = irms_float_number;
	newmode.arithmetic = irma_ieee754;
693

694
695
696
697
698
	/* float */
	newmode.name    = new_id_from_chars("F", 1);
	newmode.code    = irm_F;
	newmode.sign    = 1;
	newmode.size    = 32;
699

700
	mode_F = register_mode(&newmode);
701

702
703
704
705
706
	/* double */
	newmode.name    = new_id_from_chars("D", 1);
	newmode.code    = irm_D;
	newmode.sign    = 1;
	newmode.size    = 64;
707

708
	mode_D = register_mode(&newmode);
709

710
711
712
713
714
	/* extended */
	newmode.name    = new_id_from_chars("E", 1);
	newmode.code    = irm_E;
	newmode.sign    = 1;
	newmode.size    = 80;
715

716
	mode_E = register_mode(&newmode);
717

718
719
720
	/* Integer Number Modes */
	newmode.sort         = irms_int_number;
	newmode.arithmetic   = irma_twos_complement;
721

722
723
724
725
726
727
	/* signed byte */
	newmode.name         = new_id_from_chars("Bs", 2);
	newmode.code         = irm_Bs;
	newmode.sign         = 1;
	newmode.size         = 8;
	newmode.modulo_shift = 32;
728

729
	mode_Bs = register_mode(&newmode);
730

731
732
733
734
735
736
737
	/* unsigned byte */
	newmode.name         = new_id_from_chars("Bu", 2);
	newmode.code         = irm_Bu;
	newmode.arithmetic   = irma_twos_complement;
	newmode.sign         = 0;
	newmode.size         = 8;
	newmode.modulo_shift = 32;
738

739
	mode_Bu = register_mode(&newmode);
740

741
742
743
744
745
746
	/* signed short integer */
	newmode.name         = new_id_from_chars("Hs", 2);
	newmode.code         = irm_Hs;
	newmode.sign         = 1;
	newmode.size         = 16;
	newmode.modulo_shift = 32;
747

748
	mode_Hs = register_mode(&newmode);
749

750
751
752
753
754
755
	/* unsigned short integer */
	newmode.name         = new_id_from_chars("Hu", 2);
	newmode.code         = irm_Hu;
	newmode.sign         = 0;
	newmode.size         = 16;
	newmode.modulo_shift = 32;
756

757
	mode_Hu = register_mode(&newmode);
758

759
760
761
762
763
764
	/* signed integer */
	newmode.name         = new_id_from_chars("Is", 2);
	newmode.code         = irm_Is;
	newmode.sign         = 1;
	newmode.size         = 32;
	newmode.modulo_shift = 32;
765

766
	mode_Is = register_mode(&newmode);
767

768
769
770
771
772
773
	/* unsigned integer */
	newmode.name         = new_id_from_chars("Iu", 2);
	newmode.code         = irm_Iu;
	newmode.sign         = 0;
	newmode.size         = 32;
	newmode.modulo_shift = 32;
774

775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
	mode_Iu = register_mode(&newmode);

	/* signed long integer */
	newmode.name         = new_id_from_chars("Ls", 2);
	newmode.code         = irm_Ls;
	newmode.sign         = 1;
	newmode.size         = 64;
	newmode.modulo_shift = 64;

	mode_Ls = register_mode(&newmode);

	/* unsigned long integer */
	newmode.name         = new_id_from_chars("Lu", 2);
	newmode.code         = irm_Lu;
	newmode.sign         = 0;
	newmode.size         = 64;
	newmode.modulo_shift = 64;

	mode_Lu = register_mode(&newmode);

795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
	/* signed long long integer */
	newmode.name         = new_id_from_chars("LLs", 3);
	newmode.code         = irm_LLs;
	newmode.sign         = 1;
	newmode.size         = 128;
	newmode.modulo_shift = 128;

	mode_LLs = register_mode(&newmode);

	/* unsigned long long integer */
	newmode.name         = new_id_from_chars("LLu", 3);
	newmode.code         = irm_LLu;
	newmode.sign         = 0;
	newmode.size         = 128;
	newmode.modulo_shift = 128;

	mode_LLu = register_mode(&newmode);

813
814
	/* Reference Mode */
	newmode.sort       = irms_reference;
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
	newmode.arithmetic = irma_twos_complement;

	/* pointer */
	newmode.name         = new_id_from_chars("P", 1);
	newmode.code         = irm_P;
	newmode.sign         = 0;
	newmode.size         = 32;
	newmode.modulo_shift = 0;
	newmode.eq_signed    = mode_Is;
	newmode.eq_unsigned  = mode_Iu;

	mode_P = register_mode(&newmode);

	/* set the machine specific modes to the predefined ones */
	mode_P_code = mode_P;
	mode_P_data = mode_P;
831
}
832

Michael Beck's avatar
Michael Beck committed
833
834
/* find a signed mode for an unsigned integer mode */
ir_mode *find_unsigned_mode(const ir_mode *mode) {
835
	ir_mode n = *mode;
836

837
838
839
	assert(mode->sort == irms_int_number);
	n.sign = 0;
	return find_mode(&n);
840
841
}

Michael Beck's avatar
Michael Beck committed
842
843
/* find an unsigned mode for a signed integer mode */
ir_mode *find_signed_mode(const ir_mode *mode) {
844
	ir_mode n = *mode;
845

846
847
848
	assert(mode->sort == irms_int_number);
	n.sign = 1;
	return find_mode(&n);
849
850
}

Michael Beck's avatar
Michael Beck committed
851
852
/* finds a integer mode with 2*n bits for an integer mode with n bits. */
ir_mode *find_double_bits_int_mode(const ir_mode *mode) {
853
	ir_mode n = *mode;
Michael Beck's avatar
Michael Beck committed
854

855
	assert(mode->sort == irms_int_number && mode->arithmetic == irma_twos_complement);
Michael Beck's avatar
Michael Beck committed
856

857
858
	n.size = 2*mode->size;
	return find_mode(&n);
Michael Beck's avatar
Michael Beck committed
859
}
860

861
862
863
864
/*
 * Returns non-zero if the given mode honors signed zero's, i.e.,
 * a +0 and a -0 exists and handled differently.
 */
865
866
867
868
int mode_honor_signed_zeros(const ir_mode *mode) {
	/* for floating point, we know that IEEE 754 has +0 and -0,
	 * but always handles it identical.
	 */
Christian Würdig's avatar
Christian Würdig committed
869
870
871
	return
		mode->sort == irms_float_number &&
		mode->arithmetic != irma_ieee754;
872
873
}

874
875
876
877
878
/*
 * Returns non-zero if the given mode might overflow on unary Minus.
 *
 * This does NOT happen on IEEE 754.
 */
879
880
881
882
int mode_overflow_on_unary_Minus(const ir_mode *mode) {
	if (mode->sort == irms_float_number)
		return mode->arithmetic == irma_ieee754 ? 0 : 1;
	return 1;
883
884
}

Michael Beck's avatar
Michael Beck committed
885
/*
886
 * Returns non-zero if the mode has a reversed wrap-around
Michael Beck's avatar
Michael Beck committed
887
888
889
890
891
892
 * logic, especially (a + x) - x == a.
 *
 * This is normally true for integer modes, not for floating
 * point modes.
 */
int mode_wrap_around(const ir_mode *mode) {
893
894
	/* FIXME: better would be an extra mode property */
	return mode_is_int(mode);
Michael Beck's avatar
Michael Beck committed
895
896
}

897
void finish_mode(void) {
898
	obstack_free(&modes, 0);
Matthias Braun's avatar
Matthias Braun committed
899
	DEL_ARR_F(mode_list);
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922

	mode_T   = NULL;
	mode_X   = NULL;
	mode_M   = NULL;
	mode_BB  = NULL;
	mode_ANY = NULL;
	mode_BAD = NULL;

	mode_F   = NULL;
	mode_D   = NULL;
	mode_E   = NULL;

	mode_Bs  = NULL;
	mode_Bu  = NULL;
	mode_Hs  = NULL;
	mode_Hu  = NULL;
	mode_Is  = NULL;
	mode_Iu  = NULL;
	mode_Ls  = NULL;
	mode_Lu  = NULL;

	mode_b   = NULL;

923
	mode_P      = NULL;
924
925
	mode_P_code = NULL;
	mode_P_data = NULL;
926
}