Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 193a03d

Browse files
committed
Update IR
IR commit: d60d92516dc5f89b93cdf1df7a54141e83226b07
1 parent 487b22f commit 193a03d

File tree

10 files changed

+161
-144
lines changed

10 files changed

+161
-144
lines changed

‎ext/opcache/jit/ir/ir.c‎

Lines changed: 38 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -144,7 +144,7 @@ void ir_print_const(const ir_ctx *ctx, const ir_insn *insn, FILE *f, bool quoted
144144
if (isnan(insn->val.f)) {
145145
fprintf(f, "nan");
146146
} else {
147-
fprintf(f, "%f", insn->val.f);
147+
fprintf(f, "%g", insn->val.f);
148148
}
149149
break;
150150
default:
@@ -301,58 +301,17 @@ void ir_init(ir_ctx *ctx, uint32_t flags, ir_ref consts_limit, ir_ref insns_limi
301301
IR_ASSERT(consts_limit >= IR_CONSTS_LIMIT_MIN);
302302
IR_ASSERT(insns_limit >= IR_INSNS_LIMIT_MIN);
303303

304+
memset(ctx, 0, sizeof(ir_ctx));
305+
304306
ctx->insns_count = IR_UNUSED + 1;
305307
ctx->insns_limit = insns_limit;
306308
ctx->consts_count = -(IR_TRUE - 1);
307309
ctx->consts_limit = consts_limit;
308310
ctx->fold_cse_limit = IR_UNUSED + 1;
309311
ctx->flags = flags;
310-
ctx->mflags = 0;
311-
ctx->status = 0;
312-
313-
ctx->binding = NULL;
314-
315-
ctx->use_lists = NULL;
316-
ctx->use_edges = NULL;
317-
ctx->use_edges_count = 0;
318-
319-
ctx->cfg_blocks_count = 0;
320-
ctx->cfg_edges_count = 0;
321-
ctx->cfg_blocks = NULL;
322-
ctx->cfg_edges = NULL;
323-
ctx->cfg_map = NULL;
324-
ctx->rules = NULL;
325-
ctx->vregs = NULL;
326-
ctx->vregs_count = 0;
312+
327313
ctx->spill_base = -1;
328-
ctx->fixed_stack_red_zone = 0;
329314
ctx->fixed_stack_frame_size = -1;
330-
ctx->fixed_call_stack_size = 0;
331-
ctx->fixed_regset = 0;
332-
ctx->fixed_save_regset = 0;
333-
ctx->live_intervals = NULL;
334-
ctx->arena = NULL;
335-
ctx->unused_ranges = NULL;
336-
ctx->regs = NULL;
337-
ctx->prev_ref = NULL;
338-
ctx->data = NULL;
339-
ctx->snapshot_create = NULL;
340-
ctx->entries_count = 0;
341-
ctx->entries = NULL;
342-
ctx->osr_entry_loads = NULL;
343-
344-
ctx->code_buffer = NULL;
345-
ctx->code_buffer_size = 0;
346-
347-
#if defined(IR_TARGET_AARCH64)
348-
ctx->deoptimization_exits = 0;
349-
ctx->veneers_size = 0;
350-
ctx->get_exit_addr = NULL;
351-
ctx->get_veneer = NULL;
352-
ctx->set_veneer = NULL;
353-
#endif
354-
355-
ctx->strtab.data = NULL;
356315

357316
buf = ir_mem_malloc((consts_limit + insns_limit) * sizeof(ir_insn));
358317
ctx->ir_base = buf + consts_limit;
@@ -364,9 +323,6 @@ void ir_init(ir_ctx *ctx, uint32_t flags, ir_ref consts_limit, ir_ref insns_limi
364323
ctx->ir_base[IR_FALSE].val.u64 = 0;
365324
ctx->ir_base[IR_TRUE].optx = IR_OPT(IR_C_BOOL, IR_BOOL);
366325
ctx->ir_base[IR_TRUE].val.u64 = 1;
367-
368-
memset(ctx->prev_insn_chain, 0, sizeof(ctx->prev_insn_chain));
369-
memset(ctx->prev_const_chain, 0, sizeof(ctx->prev_const_chain));
370326
}
371327

372328
void ir_free(ir_ctx *ctx)
@@ -1991,13 +1947,21 @@ void _ir_UNREACHABLE(ir_ctx *ctx)
19911947
void _ir_TAILCALL(ir_ctx *ctx, ir_type type, ir_ref func)
19921948
{
19931949
IR_ASSERT(ctx->control);
1950+
if (ctx->ret_type == (ir_type)-1) {
1951+
ctx->ret_type = type;
1952+
}
1953+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
19941954
ctx->control = ir_emit2(ctx, IR_OPTX(IR_TAILCALL, type, 2), ctx->control, func);
19951955
_ir_UNREACHABLE(ctx);
19961956
}
19971957

19981958
void _ir_TAILCALL_1(ir_ctx *ctx, ir_type type, ir_ref func, ir_ref arg1)
19991959
{
20001960
IR_ASSERT(ctx->control);
1961+
if (ctx->ret_type == (ir_type)-1) {
1962+
ctx->ret_type = type;
1963+
}
1964+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
20011965
ctx->control = ir_emit3(ctx, IR_OPTX(IR_TAILCALL, type, 3), ctx->control, func, arg1);
20021966
_ir_UNREACHABLE(ctx);
20031967
}
@@ -2007,6 +1971,10 @@ void _ir_TAILCALL_2(ir_ctx *ctx, ir_type type, ir_ref func, ir_ref arg1, ir_ref
20071971
ir_ref call;
20081972

20091973
IR_ASSERT(ctx->control);
1974+
if (ctx->ret_type == (ir_type)-1) {
1975+
ctx->ret_type = type;
1976+
}
1977+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
20101978
call = ir_emit_N(ctx, IR_OPT(IR_TAILCALL, type), 4);
20111979
ir_set_op(ctx, call, 1, ctx->control);
20121980
ir_set_op(ctx, call, 2, func);
@@ -2021,6 +1989,10 @@ void _ir_TAILCALL_3(ir_ctx *ctx, ir_type type, ir_ref func, ir_ref arg1, ir_ref
20211989
ir_ref call;
20221990

20231991
IR_ASSERT(ctx->control);
1992+
if (ctx->ret_type == (ir_type)-1) {
1993+
ctx->ret_type = type;
1994+
}
1995+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
20241996
call = ir_emit_N(ctx, IR_OPT(IR_TAILCALL, type), 5);
20251997
ir_set_op(ctx, call, 1, ctx->control);
20261998
ir_set_op(ctx, call, 2, func);
@@ -2036,6 +2008,10 @@ void _ir_TAILCALL_4(ir_ctx *ctx, ir_type type, ir_ref func, ir_ref arg1, ir_ref
20362008
ir_ref call;
20372009

20382010
IR_ASSERT(ctx->control);
2011+
if (ctx->ret_type == (ir_type)-1) {
2012+
ctx->ret_type = type;
2013+
}
2014+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
20392015
call = ir_emit_N(ctx, IR_OPT(IR_TAILCALL, type), 6);
20402016
ir_set_op(ctx, call, 1, ctx->control);
20412017
ir_set_op(ctx, call, 2, func);
@@ -2052,6 +2028,10 @@ void _ir_TAILCALL_5(ir_ctx *ctx, ir_type type, ir_ref func, ir_ref arg1, ir_ref
20522028
ir_ref call;
20532029

20542030
IR_ASSERT(ctx->control);
2031+
if (ctx->ret_type == (ir_type)-1) {
2032+
ctx->ret_type = type;
2033+
}
2034+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
20552035
call = ir_emit_N(ctx, IR_OPT(IR_TAILCALL, type), 7);
20562036
ir_set_op(ctx, call, 1, ctx->control);
20572037
ir_set_op(ctx, call, 2, func);
@@ -2070,6 +2050,10 @@ void _ir_TAILCALL_N(ir_ctx *ctx, ir_type type, ir_ref func, uint32_t count, ir_r
20702050
uint32_t i;
20712051

20722052
IR_ASSERT(ctx->control);
2053+
if (ctx->ret_type == (ir_type)-1) {
2054+
ctx->ret_type = type;
2055+
}
2056+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
20732057
call = ir_emit_N(ctx, IR_OPT(IR_TAILCALL, type), count + 2);
20742058
ir_set_op(ctx, call, 1, ctx->control);
20752059
ir_set_op(ctx, call, 2, func);
@@ -2104,7 +2088,13 @@ void _ir_CASE_DEFAULT(ir_ctx *ctx, ir_ref switch_ref)
21042088

21052089
void _ir_RETURN(ir_ctx *ctx, ir_ref val)
21062090
{
2091+
ir_type type = (val != IR_UNUSED) ? ctx->ir_base[val].type : IR_VOID;
2092+
21072093
IR_ASSERT(ctx->control);
2094+
if (ctx->ret_type == (ir_type)-1) {
2095+
ctx->ret_type = type;
2096+
}
2097+
IR_ASSERT(ctx->ret_type == type && "conflicting return type");
21082098
ctx->control = ir_emit3(ctx, IR_RETURN, ctx->control, val, ctx->ir_base[1].op1);
21092099
ctx->ir_base[1].op1 = ctx->control;
21102100
ctx->control = IR_UNUSED;
@@ -2330,52 +2320,3 @@ void _ir_STORE(ir_ctx *ctx, ir_ref addr, ir_ref val)
23302320
}
23312321
ctx->control = ir_emit3(ctx, IR_STORE, ctx->control, addr, val);
23322322
}
2333-
2334-
ir_type ir_get_return_type(ir_ctx *ctx)
2335-
{
2336-
ir_ref ref;
2337-
ir_insn *insn;
2338-
uint8_t ret_type = 255;
2339-
ir_type type;
2340-
2341-
/* Check all RETURN nodes */
2342-
ref = ctx->ir_base[1].op1;
2343-
while (ref) {
2344-
insn = &ctx->ir_base[ref];
2345-
if (insn->op == IR_RETURN) {
2346-
type = ctx->ir_base[insn->op2].type;
2347-
check_type:
2348-
if (ret_type == 255) {
2349-
if (insn->op2) {
2350-
ret_type = type;
2351-
} else {
2352-
ret_type = IR_VOID;
2353-
}
2354-
} else if (insn->op2) {
2355-
if (ret_type != type) {
2356-
IR_ASSERT(0 && "conflicting return types");
2357-
return IR_VOID;
2358-
}
2359-
} else {
2360-
if (ret_type != IR_VOID) {
2361-
IR_ASSERT(0 && "conflicting return types");
2362-
return IR_VOID;
2363-
}
2364-
}
2365-
} else if (insn->op == IR_UNREACHABLE) {
2366-
insn = &ctx->ir_base[insn->op1];
2367-
if (insn->op == IR_TAILCALL) {
2368-
type = insn->type;
2369-
if (type != IR_VOID) {
2370-
goto check_type;
2371-
}
2372-
}
2373-
}
2374-
ref = ctx->ir_base[ref].op3;
2375-
}
2376-
2377-
if (ret_type == 255) {
2378-
ret_type = IR_VOID;
2379-
}
2380-
return (ir_type)ret_type;
2381-
}

‎ext/opcache/jit/ir/ir.h‎

Lines changed: 43 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -465,27 +465,32 @@ void ir_strtab_free(ir_strtab *strtab);
465465
/* IR Context Flags */
466466
#define IR_FUNCTION (1<<0) /* Generate a function. */
467467
#define IR_FASTCALL_FUNC (1<<1) /* Generate a function with fastcall calling convention, x86 32-bit only. */
468-
#define IR_SKIP_PROLOGUE (1<<2) /* Don't generate function prologue. */
469-
#define IR_USE_FRAME_POINTER (1<<3)
470-
#define IR_PREALLOCATED_STACK (1<<4)
471-
#define IR_HAS_ALLOCA (1<<5)
472-
#define IR_HAS_CALLS (1<<6)
473-
#define IR_NO_STACK_COMBINE (1<<7)
474-
#define IR_START_BR_TARGET (1<<8)
475-
#define IR_ENTRY_BR_TARGET (1<<9)
476-
#define IR_GEN_ENDBR (1<<10)
477-
#define IR_MERGE_EMPTY_ENTRIES (1<<11)
478-
479-
#define IR_CFG_HAS_LOOPS (1<<14)
480-
#define IR_IRREDUCIBLE_CFG (1<<15)
481-
482-
#define IR_OPT_FOLDING (1<<16)
483-
#define IR_OPT_CFG (1<<17) /* merge BBs, by remove END->BEGIN nodes during CFG construction */
484-
#define IR_OPT_CODEGEN (1<<18)
485-
#define IR_OPT_IN_SCCP (1<<19)
486-
#define IR_LINEAR (1<<20)
487-
#define IR_GEN_NATIVE (1<<21)
488-
#define IR_GEN_CODE (1<<22) /* C or LLVM */
468+
#define IR_VARARG_FUNC (1<<2)
469+
#define IR_STATIC (1<<3)
470+
#define IR_EXTERN (1<<4)
471+
#define IR_CONST (1<<5)
472+
473+
#define IR_SKIP_PROLOGUE (1<<6) /* Don't generate function prologue. */
474+
#define IR_USE_FRAME_POINTER (1<<7)
475+
#define IR_PREALLOCATED_STACK (1<<8)
476+
#define IR_HAS_ALLOCA (1<<9)
477+
#define IR_HAS_CALLS (1<<10)
478+
#define IR_NO_STACK_COMBINE (1<<11)
479+
#define IR_START_BR_TARGET (1<<12)
480+
#define IR_ENTRY_BR_TARGET (1<<13)
481+
#define IR_GEN_ENDBR (1<<14)
482+
#define IR_MERGE_EMPTY_ENTRIES (1<<15)
483+
484+
#define IR_CFG_HAS_LOOPS (1<<16)
485+
#define IR_IRREDUCIBLE_CFG (1<<17)
486+
487+
#define IR_OPT_FOLDING (1<<18)
488+
#define IR_OPT_CFG (1<<19) /* merge BBs, by remove END->BEGIN nodes during CFG construction */
489+
#define IR_OPT_CODEGEN (1<<20)
490+
#define IR_OPT_IN_SCCP (1<<21)
491+
#define IR_LINEAR (1<<22)
492+
#define IR_GEN_NATIVE (1<<23)
493+
#define IR_GEN_CODE (1<<24) /* C or LLVM */
489494

490495
/* Temporary: SCCP -> CFG */
491496
#define IR_SCCP_DONE (1<<25)
@@ -514,6 +519,7 @@ typedef struct _ir_block ir_block;
514519
typedef struct _ir_arena ir_arena;
515520
typedef struct _ir_live_interval ir_live_interval;
516521
typedef struct _ir_live_range ir_live_range;
522+
typedef struct _ir_loader ir_loader;
517523
typedef int8_t ir_regs[4];
518524

519525
typedef void (*ir_snapshot_create_t)(ir_ctx *ctx, ir_ref addr);
@@ -531,6 +537,7 @@ struct _ir_ctx {
531537
ir_ref consts_count; /* number of constants stored in constants buffer */
532538
ir_ref consts_limit; /* size of allocated constants buffer (it's extended when overflow) */
533539
uint32_t flags; /* IR context flags (see IR_* defines above) */
540+
ir_type ret_type; /* Function return type */
534541
uint32_t mflags; /* CPU specific flags (see IR_X86_... macros below) */
535542
int32_t status; /* non-zero error code (see IR_ERROR_... macros), app may use negative codes */
536543
ir_ref fold_cse_limit; /* CSE finds identical insns backward from "insn_count" to "fold_cse_limit" */
@@ -588,6 +595,7 @@ struct _ir_ctx {
588595
ir_get_veneer_t get_veneer;
589596
ir_set_veneer_t set_veneer;
590597
#endif
598+
ir_loader *loader;
591599
ir_strtab strtab;
592600
ir_ref prev_insn_chain[IR_LAST_FOLDABLE_OP + 1];
593601
ir_ref prev_const_chain[IR_LAST_TYPE];
@@ -748,23 +756,25 @@ void ir_gdb_unregister_all(void);
748756
bool ir_gdb_present(void);
749757

750758
/* IR load API (implementation in ir_load.c) */
751-
752-
typedef struct _ir_loader ir_loader;
753-
754759
struct _ir_loader {
755760
uint32_t default_func_flags;
756761
bool (*init_module) (ir_loader *loader, const char *name, const char *filename, const char *target);
757-
bool (*external_sym_dcl) (ir_loader *loader, const char *name, bool is_const);
758-
bool (*sym_dcl) (ir_loader *loader, const char *name, bool is_const, bool is_static, size_t size, const void *data);
759-
bool (*external_func_dcl) (ir_loader *loader, const char *name);
760-
bool (*forward_func_dcl) (ir_loader *loader, const char *name, bool is_static);
761-
bool (*init_func) (ir_loader *loader, ir_ctx *ctx, const char *name);
762-
bool (*process_func) (ir_loader *loader, ir_ctx *ctx, const char *name);
762+
bool (*external_sym_dcl) (ir_loader *loader, const char *name, uint32_t flags);
763+
bool (*external_func_dcl) (ir_loader *loader, const char *name,
764+
uint32_t flags, ir_type ret_type, uint32_t params_count, ir_type *param_types);
765+
bool (*forward_func_dcl) (ir_loader *loader, const char *name,
766+
uint32_t flags, ir_type ret_type, uint32_t params_count, ir_type *param_types);
767+
bool (*sym_dcl) (ir_loader *loader, const char *name, uint32_t flags, size_t size, bool has_data);
768+
bool (*sym_data) (ir_loader *loader, ir_type type, uint32_t count, const void *data);
769+
bool (*sym_data_end) (ir_loader *loader);
770+
bool (*func_init) (ir_loader *loader, ir_ctx *ctx, const char *name);
771+
bool (*func_process) (ir_loader *loader, ir_ctx *ctx, const char *name);
772+
void*(*resolve_sym_name) (ir_loader *loader, const char *name);
763773
};
764774

765775
void ir_loader_init(void);
766776
void ir_loader_free(void);
767-
int ir_load(ir_ctx*ctx, FILE *f);
777+
int ir_load(ir_loader*loader, FILE *f);
768778

769779
/* IR LLVM load API (implementation in ir_load_llvm.c) */
770780
int ir_load_llvm_bitcode(ir_loader *loader, const char *filename);
@@ -784,9 +794,11 @@ void ir_dump_codegen(const ir_ctx *ctx, FILE *f);
784794

785795
/* IR to C conversion (implementation in ir_emit_c.c) */
786796
int ir_emit_c(ir_ctx *ctx, const char *name, FILE *f);
797+
void ir_emit_c_func_decl(const char *name, uint32_t flags, ir_type ret_type, uint32_t params_count, ir_type *param_types, FILE *f);
787798

788799
/* IR to LLVM conversion (implementation in ir_emit_llvm.c) */
789800
int ir_emit_llvm(ir_ctx *ctx, const char *name, FILE *f);
801+
void ir_emit_llvm_func_decl(const char *name, uint32_t flags, ir_type ret_type, uint32_t params_count, ir_type *param_types, FILE *f);
790802

791803
/* IR verification API (implementation in ir_check.c) */
792804
bool ir_check(const ir_ctx *ctx);

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /