ia32_intrinsics.c 21.9 KB
Newer Older
Christian Würdig's avatar
Christian Würdig committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/*
 * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
 *
 * 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.
 */

20
/**
Christian Würdig's avatar
Christian Würdig committed
21
22
23
24
25
 * @file
 * @brief       This file implements the mapping of 64Bit intrinsic
 *              functions to code or library calls.
 * @author      Michael Beck
 * @version     $Id$
26
 */
27
28
29
30
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

31
#include "irgmod.h"
32
33
34
35
#include "irop.h"
#include "irnode_t.h"
#include "ircons.h"
#include "irprog_t.h"
36
#include "lowering.h"
37
38
#include "array.h"

39
#include "ia32_new_nodes.h"
40
41
#include "bearch_ia32_t.h"
#include "gen_ia32_regalloc_if.h"
42

43
44
45
46
/** The array of all intrinsics that must be mapped. */
static i_record *intrinsics;

/** An array to cache all entities */
47
static ir_entity *i_ents[iro_MaxOpcode];
48

49
/*
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 * Maps all intrinsic calls that the backend support
 * and map all instructions the backend did not support
 * to runtime calls.
 */
void ia32_handle_intrinsics(void) {
	if (intrinsics && ARR_LEN(intrinsics) > 0)
		lower_intrinsics(intrinsics, ARR_LEN(intrinsics));
}

#define BINOP_Left_Low   0
#define BINOP_Left_High  1
#define BINOP_Right_Low  2
#define BINOP_Right_High 3

64
65
66
/**
 * Replace a call be a tuple of l_res, h_res.
 */
67
68
static void resolve_call(ir_node *call, ir_node *l_res, ir_node *h_res, ir_graph *irg, ir_node *block) {
	ir_node *res, *in[2];
69
70
71

	in[0] = l_res;
	in[1] = h_res;
72
	res = new_r_Tuple(irg, block, h_res == NULL ? 1 : 2, in);
73
74
75

	turn_into_tuple(call, pn_Call_max);
	set_Tuple_pred(call, pn_Call_M_regular,        get_irg_no_mem(irg));
76
	set_Tuple_pred(call, pn_Call_X_regular,        new_r_Jmp(irg, block));
77
78
	set_Tuple_pred(call, pn_Call_X_except,         get_irg_bad(irg));
	set_Tuple_pred(call, pn_Call_T_result,         res);
Christian Würdig's avatar
Christian Würdig committed
79
	set_Tuple_pred(call, pn_Call_M_except,         get_irg_no_mem(irg));
80
	set_Tuple_pred(call, pn_Call_P_value_res_base, get_irg_bad(irg));
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
}

/**
 * Map an Add (a_l, a_h, b_l, b_h)
 */
static int map_Add(ir_node *call, void *ctx) {
	ir_graph *irg        = current_ir_graph;
	dbg_info *dbg        = get_irn_dbg_info(call);
	ir_node  *block      = get_nodes_block(call);
	ir_node  **params    = get_Call_param_arr(call);
	ir_type  *method     = get_Call_type(call);
	ir_node  *a_l        = params[BINOP_Left_Low];
	ir_node  *a_h        = params[BINOP_Left_High];
	ir_node  *b_l        = params[BINOP_Right_Low];
	ir_node  *b_h        = params[BINOP_Right_High];
	ir_mode  *l_res_mode = get_type_mode(get_method_res_type(method, 0));
	ir_mode  *h_res_mode = get_type_mode(get_method_res_type(method, 1));
98
	ir_node  *l_res, *h_res, *add;
Matthias Braun's avatar
Matthias Braun committed
99
	(void) ctx;
100
101
102

	/* l_res = a_l + b_l */
	/* h_res = a_h + b_h + carry */
103
104
105
106

	add   = new_rd_ia32_Add64Bit(dbg, irg, block, a_l, a_h, b_l, b_h);
	l_res = new_r_Proj(irg, block, add, l_res_mode, pn_ia32_Add64Bit_low_res);
	h_res = new_r_Proj(irg, block, add, h_res_mode, pn_ia32_Add64Bit_high_res);
107

108
	resolve_call(call, l_res, h_res, irg, block);
109
110
111
112
113
114
115
	return 1;
}

/**
 * Map a Sub (a_l, a_h, b_l, b_h)
 */
static int map_Sub(ir_node *call, void *ctx) {
116
117
118
119
120
121
122
123
124
125
126
	ir_graph *irg        = current_ir_graph;
	dbg_info *dbg        = get_irn_dbg_info(call);
	ir_node  *block      = get_nodes_block(call);
	ir_node  **params    = get_Call_param_arr(call);
	ir_type  *method     = get_Call_type(call);
	ir_node  *a_l        = params[BINOP_Left_Low];
	ir_node  *a_h        = params[BINOP_Left_High];
	ir_node  *b_l        = params[BINOP_Right_Low];
	ir_node  *b_h        = params[BINOP_Right_High];
	ir_mode  *l_res_mode = get_type_mode(get_method_res_type(method, 0));
	ir_mode  *h_res_mode = get_type_mode(get_method_res_type(method, 1));
127
	ir_node  *l_res, *h_res, *res;
Matthias Braun's avatar
Matthias Braun committed
128
	(void) ctx;
129
130

	/* l_res = a_l - b_l */
131
	/* h_res = a_h - b_h - carry */
132

133
134
135
	res   = new_rd_ia32_Sub64Bit(dbg, irg, block, a_l, a_h, b_l, b_h);
	l_res = new_r_Proj(irg, block, res, l_res_mode, pn_ia32_Sub64Bit_low_res);
	h_res = new_r_Proj(irg, block, res, h_res_mode, pn_ia32_Sub64Bit_high_res);
136

137
	resolve_call(call, l_res, h_res, irg, block);
138
139
140
	return 1;
}

141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/**
 * Map a Shl (a_l, a_h, count)
 */
static int map_Shl(ir_node *call, void *ctx) {
	ir_graph *irg        = current_ir_graph;
	dbg_info *dbg        = get_irn_dbg_info(call);
	ir_node  *block      = get_nodes_block(call);
	ir_node  **params    = get_Call_param_arr(call);
	ir_type  *method     = get_Call_type(call);
	ir_node  *a_l        = params[BINOP_Left_Low];
	ir_node  *a_h        = params[BINOP_Left_High];
	ir_node  *cnt        = params[BINOP_Right_Low];
	ir_mode  *l_res_mode = get_type_mode(get_method_res_type(method, 0));
	ir_mode  *h_res_mode = get_type_mode(get_method_res_type(method, 1));
	ir_node  *l_res, *h_res;
Matthias Braun's avatar
Matthias Braun committed
156
	(void) ctx;
157
158

	/* h_res = SHLD a_h, a_l, cnt */
Christian Würdig's avatar
Christian Würdig committed
159
	h_res = new_rd_ia32_l_ShlD(dbg, irg, block, a_h, a_l, cnt, l_res_mode);
160
161

	/* l_res = SHL a_l, cnt */
Christian Würdig's avatar
Christian Würdig committed
162
	l_res = new_rd_ia32_l_Shl(dbg, irg, block, a_l, cnt, h_res_mode);
163

164
	//add_irn_dep(l_res, h_res);
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

	resolve_call(call, l_res, h_res, irg, block);
	return 1;
}

/**
 * Map a Shr (a_l, a_h, count)
 */
static int map_Shr(ir_node *call, void *ctx) {
	ir_graph *irg        = current_ir_graph;
	dbg_info *dbg        = get_irn_dbg_info(call);
	ir_node  *block      = get_nodes_block(call);
	ir_node  **params    = get_Call_param_arr(call);
	ir_type  *method     = get_Call_type(call);
	ir_node  *a_l        = params[BINOP_Left_Low];
	ir_node  *a_h        = params[BINOP_Left_High];
	ir_node  *cnt        = params[BINOP_Right_Low];
	ir_mode  *l_res_mode = get_type_mode(get_method_res_type(method, 0));
	ir_mode  *h_res_mode = get_type_mode(get_method_res_type(method, 1));
	ir_node  *l_res, *h_res;
Matthias Braun's avatar
Matthias Braun committed
185
	(void) ctx;
186
187
188
189
190
191

	/* l_res = SHRD a_l, a_h, cnt */
	l_res = new_rd_ia32_l_ShrD(dbg, irg, block, a_l, a_h, cnt, l_res_mode);

	/* h_res = SHR a_h, cnt */
	h_res = new_rd_ia32_l_Shr(dbg, irg, block, a_h, cnt, h_res_mode);
192

193
	//add_irn_dep(h_res, l_res);
194
195
196
197
198
199
200
201
202

	resolve_call(call, l_res, h_res, irg, block);
	return 1;
}

/**
 * Map a Shrs (a_l, a_h, count)
 */
static int map_Shrs(ir_node *call, void *ctx) {
Michael Beck's avatar
Michael Beck committed
203
204
205
206
207
208
209
210
211
	ir_graph *irg     = current_ir_graph;
	dbg_info *dbg     = get_irn_dbg_info(call);
	ir_node  *block   = get_nodes_block(call);
	ir_node  **params = get_Call_param_arr(call);
	ir_type  *method  = get_Call_type(call);
	ir_node  *a_l     = params[BINOP_Left_Low];
	ir_node  *a_h     = params[BINOP_Left_High];
	ir_node  *cnt     = params[BINOP_Right_Low];
	ir_mode  *l_mode  = get_type_mode(get_method_res_type(method, 0));
212
	ir_node  *l_res, *h_res;
Matthias Braun's avatar
Matthias Braun committed
213
	(void) ctx;
214

Michael Beck's avatar
Michael Beck committed
215
216
	assert(l_mode == get_type_mode(get_method_res_type(method, 1)) && "64bit lowered into different modes");

217
	/* l_res = SHRD a_l, a_h, cnt */
Michael Beck's avatar
Michael Beck committed
218
	l_res = new_rd_ia32_l_ShrD(dbg, irg, block, a_l, a_h, cnt, l_mode);
219
220

	/* h_res = SAR a_h, cnt */
Michael Beck's avatar
Michael Beck committed
221
	h_res = new_rd_ia32_l_Sar(dbg, irg, block, a_h, cnt, l_mode);
222

223
	//add_irn_dep(h_res, l_res);
224
225
226
227
228
229
230
231
232

	resolve_call(call, l_res, h_res, irg, block);
	return 1;
}

/**
 * Map a Mul (a_l, a_h, b_l, b_h)
 */
static int map_Mul(ir_node *call, void *ctx) {
Michael Beck's avatar
Michael Beck committed
233
234
235
236
237
238
239
240
241
242
	ir_graph *irg     = current_ir_graph;
	dbg_info *dbg     = get_irn_dbg_info(call);
	ir_node  *block   = get_nodes_block(call);
	ir_node  **params = get_Call_param_arr(call);
	ir_type  *method  = get_Call_type(call);
	ir_node  *a_l     = params[BINOP_Left_Low];
	ir_node  *a_h     = params[BINOP_Left_High];
	ir_node  *b_l     = params[BINOP_Right_Low];
	ir_node  *b_h     = params[BINOP_Right_High];
	ir_mode  *l_mode  = get_type_mode(get_method_res_type(method, 0));
243
	ir_node  *l_res, *h_res, *mul, *pEDX, *add;
Matthias Braun's avatar
Matthias Braun committed
244
	(void) ctx;
245

Michael Beck's avatar
Michael Beck committed
246
	assert(l_mode == get_type_mode(get_method_res_type(method, 1)) && "64bit lowered into different modes");
247
248
249
250
251
252
253
254
255
	/*
		EDX:EAX = a_l * b_l
		l_res   = EAX

		t1 = b_l * a_h
		t2 = t1 + EDX
		t3 = a_l * b_h
		h_res = t2 + t3
	*/
Michael Beck's avatar
Michael Beck committed
256

257
	mul   = new_rd_ia32_l_Mul(dbg, irg, block, a_l, b_l);
Michael Beck's avatar
Michael Beck committed
258
259
	pEDX  = new_rd_Proj(dbg, irg, block, mul, l_mode, pn_ia32_l_Mul_EDX);
	l_res = new_rd_Proj(dbg, irg, block, mul, l_mode, pn_ia32_l_Mul_EAX);
260

Michael Beck's avatar
Michael Beck committed
261
262
263
264
	mul   = new_rd_Mul(dbg, irg, block, a_h, b_l, l_mode);
	add   = new_rd_Add(dbg, irg, block, mul, pEDX, l_mode);
	mul   = new_rd_Mul(dbg, irg, block, a_l, b_h, l_mode);
	h_res = new_rd_Add(dbg, irg, block, add, mul, l_mode);
265
266
267
268
269
270

	resolve_call(call, l_res, h_res, irg, block);

	return 1;
}

271
272
273
274
/**
 * Map a Minus (a_l, a_h)
 */
static int map_Minus(ir_node *call, void *ctx) {
Michael Beck's avatar
Michael Beck committed
275
276
277
278
279
280
281
282
	ir_graph *irg     = current_ir_graph;
	dbg_info *dbg     = get_irn_dbg_info(call);
	ir_node  *block   = get_nodes_block(call);
	ir_node  **params = get_Call_param_arr(call);
	ir_type  *method  = get_Call_type(call);
	ir_node  *a_l     = params[BINOP_Left_Low];
	ir_node  *a_h     = params[BINOP_Left_High];
	ir_mode  *l_mode  = get_type_mode(get_method_res_type(method, 0));
283
	ir_node  *l_res, *h_res, *cnst, *res;
Matthias Braun's avatar
Matthias Braun committed
284
	(void) ctx;
285

Michael Beck's avatar
Michael Beck committed
286
287
	assert(l_mode == get_type_mode(get_method_res_type(method, 1)) && "64bit lowered into different modes");

288
	/* too bad: we need 0 in a register here */
Michael Beck's avatar
Michael Beck committed
289
	cnst  = new_Const_long(l_mode, 0);
290

291
	/* l_res = 0 - a_l */
292
293
	/* h_res = 0 - a_h - carry */

294
	res   = new_rd_ia32_Minus64Bit(dbg, irg, block, cnst, a_l, a_h);
Michael Beck's avatar
Michael Beck committed
295
296
	l_res = new_r_Proj(irg, block, res, l_mode, pn_ia32_Minus64Bit_low_res);
	h_res = new_r_Proj(irg, block, res, l_mode, pn_ia32_Minus64Bit_high_res);
297
298
299
300
301
302

	resolve_call(call, l_res, h_res, irg, block);

	return 1;
}

303
304
305
306
/**
 * Map a Abs (a_l, a_h)
 */
static int map_Abs(ir_node *call, void *ctx) {
Michael Beck's avatar
Michael Beck committed
307
308
309
310
311
312
313
314
	ir_graph *irg     = current_ir_graph;
	dbg_info *dbg     = get_irn_dbg_info(call);
	ir_node  *block   = get_nodes_block(call);
	ir_node  **params = get_Call_param_arr(call);
	ir_type  *method  = get_Call_type(call);
	ir_node  *a_l     = params[BINOP_Left_Low];
	ir_node  *a_h     = params[BINOP_Left_High];
	ir_mode  *l_mode  = get_type_mode(get_method_res_type(method, 0));
315
	ir_node  *l_res, *h_res, *sign, *sub_l, *sub_h, *res;
Matthias Braun's avatar
Matthias Braun committed
316
	(void) ctx;
317

Michael Beck's avatar
Michael Beck committed
318
319
	assert(l_mode == get_type_mode(get_method_res_type(method, 1)) && "64bit lowered into different modes");

320
321
322
323
324
325
326
327
328
329
330
331
332
333
	/*
		Code inspired by gcc output :) (although gcc doubles the
		operation for t1 as t2 and uses t1 for operations with low part
		and t2 for operations with high part which is actually unnecessary
		because t1 and t2 represent the same value)

		t1    = SHRS a_h, 31
		t2    = a_l ^ t1
		t3    = a_h ^ t1
		l_res = t2 - t1
		h_res = t3 - t1 - carry

	*/

Michael Beck's avatar
Michael Beck committed
334
335
336
	sign  = new_rd_ia32_l_Sar(dbg, irg, block, a_h, new_Const_long(l_mode, 31), l_mode);
	sub_l = new_rd_ia32_l_Xor(dbg, irg, block, a_l, sign, l_mode);
	sub_h = new_rd_ia32_l_Xor(dbg, irg, block, a_h, sign, l_mode);
337
	res   = new_rd_ia32_Sub64Bit(dbg, irg, block, sub_l, sub_h, sign, sign);
Michael Beck's avatar
Michael Beck committed
338
339
	l_res = new_r_Proj(irg, block, res, l_mode, pn_ia32_Sub64Bit_low_res);
	h_res = new_r_Proj(irg, block, res, l_mode, pn_ia32_Sub64Bit_high_res);
340
341
342
343
344
345

	resolve_call(call, l_res, h_res, irg, block);

	return 1;
}

Christian Würdig's avatar
Christian Würdig committed
346
347
348
349
350
typedef enum {
	IA32_INTRINSIC_DIV,
	IA32_INTRINSIC_MOD,
} ia32_intrinsic_divmod_t;

351
352
353
/**
 * Maps a Div/Mod (a_l, a_h, b_l, b_h)
 */
Christian Würdig's avatar
Christian Würdig committed
354
static int DivMod_mapper(ir_node *call, void *ctx, ia32_intrinsic_divmod_t dmtp) {
355
	ia32_intrinsic_env_t *env = ctx;
Michael Beck's avatar
Michael Beck committed
356
357
358
359
360
361
362
363
364
365
366
367
368
	ir_graph  *irg       = current_ir_graph;
	dbg_info  *dbg       = get_irn_dbg_info(call);
	ir_node   *block     = get_nodes_block(call);
	ir_node   **params   = get_Call_param_arr(call);
	ir_type   *method    = get_Call_type(call);
	ir_node   *a_l       = params[BINOP_Left_Low];
	ir_node   *a_h       = params[BINOP_Left_High];
	ir_node   *b_l       = params[BINOP_Right_Low];
	ir_node   *b_h       = params[BINOP_Right_High];
	ir_mode   *l_mode    = get_type_mode(get_method_res_type(method, 0));
	int       mode_bytes = get_mode_size_bytes(ia32_reg_classes[CLASS_ia32_gp].mode);
	ir_entity *ent_a     = env->irg == irg ? env->ll_div_op1 : NULL;
	ir_entity *ent_b     = env->irg == irg ? env->ll_div_op2 : NULL;
369
370
371
372
	ir_node   *l_res, *h_res, *frame;
	ir_node   *store_l, *store_h;
	ir_node   *op_mem[2], *mem, *fa_mem, *fb_mem;
	ir_node   *fa, *fb, *fres;
373

Michael Beck's avatar
Michael Beck committed
374
375
	assert(l_mode == get_type_mode(get_method_res_type(method, 1)) && "64bit lowered into different modes");

376
377
378
379
	/* allocate memory on frame to store args */
	if (! ent_a) {
		ent_a = env->ll_div_op1 =
			frame_alloc_area(get_irg_frame_type(irg), 2 * mode_bytes, 16, 0);
380
		env->irg = irg;
381
382
383
384
385
	}

	if (! ent_b) {
		ent_b = env->ll_div_op2 =
			frame_alloc_area(get_irg_frame_type(irg), 2 * mode_bytes, 16, 0);
386
		env->irg = irg;
387
388
389
390
391
392
393
394
395
	}

	frame = get_irg_frame(irg);

	/* store first arg */
	store_l   = new_rd_ia32_l_Store(dbg, irg, block, frame, a_l, get_irg_no_mem(irg));
	set_ia32_frame_ent(store_l, ent_a);
	set_ia32_use_frame(store_l);
	set_ia32_ls_mode(store_l, get_irn_mode(a_l));
396
	op_mem[0] = store_l;
397
398
399

	store_h   = new_rd_ia32_l_Store(dbg, irg, block, frame, a_h, get_irg_no_mem(irg));
	set_ia32_frame_ent(store_h, ent_a);
400
	add_ia32_am_offs_int(store_h, mode_bytes);
401
402
	set_ia32_use_frame(store_h);
	set_ia32_ls_mode(store_h, get_irn_mode(a_h));
403
	op_mem[1] = store_h;
404
405
406
407
408
409
410
411
412

	mem = new_r_Sync(irg, block, 2, op_mem);

	/* load first arg into FPU */
	fa = new_rd_ia32_l_vfild(dbg, irg, block, frame, mem);
	set_ia32_frame_ent(fa, ent_a);
	set_ia32_use_frame(fa);
	set_ia32_ls_mode(fa, mode_D);
	fa_mem = new_r_Proj(irg, block, fa, mode_M, pn_ia32_l_vfild_M);
413
	fa     = new_r_Proj(irg, block, fa, mode_E, pn_ia32_l_vfild_res);
414
415
416
417
418
419

	/* store second arg */
	store_l   = new_rd_ia32_l_Store(dbg, irg, block, frame, b_l, get_irg_no_mem(irg));
	set_ia32_frame_ent(store_l, ent_b);
	set_ia32_use_frame(store_l);
	set_ia32_ls_mode(store_l, get_irn_mode(b_l));
420
	op_mem[0] = store_l;
421
422
423

	store_h   = new_rd_ia32_l_Store(dbg, irg, block, frame, b_h, get_irg_no_mem(irg));
	set_ia32_frame_ent(store_h, ent_b);
424
	add_ia32_am_offs_int(store_h, mode_bytes);
425
426
	set_ia32_use_frame(store_h);
	set_ia32_ls_mode(store_h, get_irn_mode(b_h));
427
	op_mem[1] = store_h;
428
429
430
431
432
433
434
435
436

	mem = new_r_Sync(irg, block, 2, op_mem);

	/* load second arg into FPU */
	fb = new_rd_ia32_l_vfild(dbg, irg, block, frame, mem);
	set_ia32_frame_ent(fb, ent_b);
	set_ia32_use_frame(fb);
	set_ia32_ls_mode(fb, mode_D);
	fb_mem = new_r_Proj(irg, block, fb, mode_M, pn_ia32_l_vfild_M);
437
	fb     = new_r_Proj(irg, block, fb, mode_E, pn_ia32_l_vfild_res);
438
439
440
441
442
443
444

	op_mem[0] = fa_mem;
	op_mem[1] = fb_mem;

	mem = new_r_Sync(irg, block, 2, op_mem);

	/* perform division */
Christian Würdig's avatar
Christian Würdig committed
445
446
	switch (dmtp) {
		case IA32_INTRINSIC_DIV:
447
			fres = new_rd_ia32_l_vfdiv(dbg, irg, block, fa, fb);
448
			fres = new_rd_Proj(dbg, irg, block, fres, mode_E, pn_ia32_l_vfdiv_res);
Christian Würdig's avatar
Christian Würdig committed
449
450
			break;
		case IA32_INTRINSIC_MOD:
451
			fres = new_rd_ia32_l_vfprem(dbg, irg, block, fa, fb, mode_E);
Christian Würdig's avatar
Christian Würdig committed
452
453
454
			break;
		default:
			assert(0);
455
456
457
458
459
460
461
	}

	/* store back result, we use ent_a here */
	fres = new_rd_ia32_l_vfist(dbg, irg, block, frame, fres, mem);
	set_ia32_frame_ent(fres, ent_a);
	set_ia32_use_frame(fres);
	set_ia32_ls_mode(fres, mode_D);
462
	mem = fres;
463
464
465
466
467

	/* load low part of the result */
	l_res = new_rd_ia32_l_Load(dbg, irg, block, frame, mem);
	set_ia32_frame_ent(l_res, ent_a);
	set_ia32_use_frame(l_res);
Michael Beck's avatar
Michael Beck committed
468
469
	set_ia32_ls_mode(l_res, l_mode);
	l_res = new_r_Proj(irg, block, l_res, l_mode, pn_ia32_l_Load_res);
470
471
472
473

	/* load hight part of the result */
	h_res = new_rd_ia32_l_Load(dbg, irg, block, frame, mem);
	set_ia32_frame_ent(h_res, ent_a);
474
	add_ia32_am_offs_int(h_res, mode_bytes);
475
	set_ia32_use_frame(h_res);
Michael Beck's avatar
Michael Beck committed
476
477
	set_ia32_ls_mode(h_res, l_mode);
	h_res = new_r_Proj(irg, block, h_res, l_mode, pn_ia32_l_Load_res);
478
479
480
481
482
483
484
485

	/* lower the call */
	resolve_call(call, l_res, h_res, irg, block);

	return 1;
}

static int map_Div(ir_node *call, void *ctx) {
Christian Würdig's avatar
Christian Würdig committed
486
	return DivMod_mapper(call, ctx, IA32_INTRINSIC_DIV);
487
488
489
}

static int map_Mod(ir_node *call, void *ctx) {
Christian Würdig's avatar
Christian Würdig committed
490
	return DivMod_mapper(call, ctx, IA32_INTRINSIC_MOD);
491
492
493
494
495
496
497
}

/**
 * Maps a Conv (a_l, a_h)
 */
static int map_Conv(ir_node *call, void *ctx) {
	ia32_intrinsic_env_t *env = ctx;
498
499
500
501
502
503
504
505
506
507
508
	ir_graph  *irg        = current_ir_graph;
	dbg_info  *dbg        = get_irn_dbg_info(call);
	ir_node   *block      = get_nodes_block(call);
	ir_node   **params    = get_Call_param_arr(call);
	ir_type   *method     = get_Call_type(call);
	int       n           = get_Call_n_params(call);
	int       gp_bytes    = get_mode_size_bytes(ia32_reg_classes[CLASS_ia32_gp].mode);
	ir_entity *ent;
	ir_node   *l_res, *h_res, *frame, *fres;
	ir_node   *store_l, *store_h;
	ir_node   *op_mem[2], *mem;
509
510
511
512
513
514
515
516
517
518

	if (n == 1) {
		/* We have a Conv float -> long long here */
		ir_node *a_f        = params[0];
		ir_mode *l_res_mode = get_type_mode(get_method_res_type(method, 0));
		ir_mode *h_res_mode = get_type_mode(get_method_res_type(method, 1));

		assert(mode_is_float(get_irn_mode(a_f)) && "unexpected Conv call");

		/* allocate memory on frame to store args */
519
		ent = env->irg == irg ? env->d_ll_conv : NULL;
520
		if (! ent) {
521
522
			ent      = env->d_ll_conv = frame_alloc_area(get_irg_frame_type(irg), 2 * gp_bytes, 16, 0);
			env->irg = irg;
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
		}

		/* Store arg */
		frame = get_irg_frame(irg);

		/*
			Now we create a node to move the value from a XMM register into
			x87 FPU because it is unknown here, which FPU is used.
			This node is killed in transformation phase when not needed.
			Otherwise it is split up into a movsd + fld
		*/
		a_f = new_rd_ia32_l_SSEtoX87(dbg, irg, block, frame, a_f, get_irg_no_mem(irg), mode_D);
		set_ia32_frame_ent(a_f, ent);
		set_ia32_use_frame(a_f);
		set_ia32_ls_mode(a_f, mode_D);

		/* store from FPU as Int */
		a_f = new_rd_ia32_l_vfist(dbg, irg, block, frame, a_f, get_irg_no_mem(irg));
		set_ia32_frame_ent(a_f, ent);
		set_ia32_use_frame(a_f);
		set_ia32_ls_mode(a_f, mode_D);
544
		mem = a_f;
545
546
547
548
549
550
551
552
553
554
555

		/* load low part of the result */
		l_res = new_rd_ia32_l_Load(dbg, irg, block, frame, mem);
		set_ia32_frame_ent(l_res, ent);
		set_ia32_use_frame(l_res);
		set_ia32_ls_mode(l_res, l_res_mode);
		l_res = new_r_Proj(irg, block, l_res, l_res_mode, pn_ia32_l_Load_res);

		/* load hight part of the result */
		h_res = new_rd_ia32_l_Load(dbg, irg, block, frame, mem);
		set_ia32_frame_ent(h_res, ent);
556
		add_ia32_am_offs_int(h_res, gp_bytes);
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
		set_ia32_use_frame(h_res);
		set_ia32_ls_mode(h_res, h_res_mode);
		h_res = new_r_Proj(irg, block, h_res, h_res_mode, pn_ia32_l_Load_res);

		/* lower the call */
		resolve_call(call, l_res, h_res, irg, block);
	}
	else if (n == 2) {
		/* We have a Conv long long -> float here */
		ir_node *a_l       = params[BINOP_Left_Low];
		ir_node *a_h       = params[BINOP_Left_High];
		ir_mode *mode_a_l  = get_irn_mode(a_l);
		ir_mode *mode_a_h  = get_irn_mode(a_h);
		ir_mode *fres_mode = get_type_mode(get_method_res_type(method, 0));

		assert(! mode_is_float(mode_a_l) && ! mode_is_float(mode_a_h) && "unexpected Conv call");

		/* allocate memory on frame to store args */
575
		ent = env->irg == irg ? env->ll_d_conv : NULL;
576
577
		if (! ent) {
			ent = env->ll_d_conv = frame_alloc_area(get_irg_frame_type(irg), 2 * gp_bytes, 16, 0);
578
			env->irg = irg;
579
580
581
582
583
584
585
586
587
588
		}

		/* Store arg */
		frame = get_irg_frame(irg);

		/* store first arg (low part) */
		store_l   = new_rd_ia32_l_Store(dbg, irg, block, frame, a_l, get_irg_no_mem(irg));
		set_ia32_frame_ent(store_l, ent);
		set_ia32_use_frame(store_l);
		set_ia32_ls_mode(store_l, get_irn_mode(a_l));
589
		op_mem[0] = store_l;
590
591
592
593

		/* store second arg (high part) */
		store_h   = new_rd_ia32_l_Store(dbg, irg, block, frame, a_h, get_irg_no_mem(irg));
		set_ia32_frame_ent(store_h, ent);
594
		add_ia32_am_offs_int(store_h, gp_bytes);
595
596
		set_ia32_use_frame(store_h);
		set_ia32_ls_mode(store_h, get_irn_mode(a_h));
597
		op_mem[1] = store_h;
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629

		mem = new_r_Sync(irg, block, 2, op_mem);

		/* Load arg into x87 FPU (implicit convert) */
		fres = new_rd_ia32_l_vfild(dbg, irg, block, frame, mem);
		set_ia32_frame_ent(fres, ent);
		set_ia32_use_frame(fres);
		set_ia32_ls_mode(fres, mode_D);
		mem  = new_r_Proj(irg, block, fres, mode_M, pn_ia32_l_vfild_M);
		fres = new_r_Proj(irg, block, fres, fres_mode, pn_ia32_l_vfild_res);

		/*
			Now we create a node to move the loaded value into a XMM
			register because it is unknown here, which FPU is used.
			This node is killed in transformation phase when not needed.
			Otherwise it is split up into a fst + movsd
		*/
		fres = new_rd_ia32_l_X87toSSE(dbg, irg, block, frame, fres, mem, fres_mode);
		set_ia32_frame_ent(fres, ent);
		set_ia32_use_frame(fres);
		set_ia32_ls_mode(fres, fres_mode);

		/* lower the call */
		resolve_call(call, fres, NULL, irg, block);
	}
	else {
		assert(0 && "unexpected Conv call");
	}

	return 1;
}

630
/* Ia32 implementation of intrinsic mapping. */
631
632
633
ir_entity *ia32_create_intrinsic_fkt(ir_type *method, const ir_op *op,
                                     const ir_mode *imode, const ir_mode *omode,
                                     void *context)
634
635
{
	i_record      elt;
636
	ir_entity     **ent = NULL;
637
638
639
640
641
642
643
644
645
646
647
648
649
650
	i_mapper_func mapper;

	if (! intrinsics)
		intrinsics = NEW_ARR_F(i_record, 0);

	switch (get_op_code(op)) {
	case iro_Add:
		ent    = &i_ents[iro_Add];
		mapper = map_Add;
		break;
	case iro_Sub:
		ent    = &i_ents[iro_Sub];
		mapper = map_Sub;
		break;
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
	case iro_Shl:
		ent    = &i_ents[iro_Shl];
		mapper = map_Shl;
		break;
	case iro_Shr:
		ent    = &i_ents[iro_Shr];
		mapper = map_Shr;
		break;
	case iro_Shrs:
		ent    = &i_ents[iro_Shrs];
		mapper = map_Shrs;
		break;
	case iro_Mul:
		ent    = &i_ents[iro_Mul];
		mapper = map_Mul;
		break;
667
668
669
670
671
672
673
674
	case iro_Minus:
		ent    = &i_ents[iro_Minus];
		mapper = map_Minus;
		break;
	case iro_Abs:
		ent    = &i_ents[iro_Abs];
		mapper = map_Abs;
		break;
675
676
677
678
679
680
681
682
683
684
685
686
	case iro_Div:
		ent    = &i_ents[iro_Div];
		mapper = map_Div;
		break;
	case iro_Mod:
		ent    = &i_ents[iro_Mod];
		mapper = map_Mod;
		break;
	case iro_Conv:
		ent    = &i_ents[iro_Conv];
		mapper = map_Conv;
		break;
687
	default:
Christian Würdig's avatar
Christian Würdig committed
688
		fprintf(stderr, "FIXME: unhandled op for ia32 intrinsic function %s\n", get_id_str(op->name));
689
690
691
692
693
694
		return def_create_intrinsic_fkt(method, op, imode, omode, context);
	}

	if (ent && ! *ent) {
#define IDENT(s)  new_id_from_chars(s, sizeof(s)-1)

Sebastian Hack's avatar
Sebastian Hack committed
695
		ident *id = mangle(IDENT("L"), get_op_ident(op));
696
697
698
699
700
701
		*ent = new_entity(get_glob_type(), id, method);
	}

	elt.i_call.kind     = INTRINSIC_CALL;
	elt.i_call.i_ent    = *ent;
	elt.i_call.i_mapper = mapper;
702
	elt.i_call.ctx      = context;
703
704
705
	elt.i_call.link     = NULL;

	ARR_APP1(i_record, intrinsics, elt);
Sebastian Hack's avatar
Sebastian Hack committed
706
	return *ent;
707
}