1;; Prelude definitions specific to lowering environments (backends) in
2;; ISLE.
3
4;;;; Primitive and External Types ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5
6;; ISLE representation of `Vec<u8>`
7(type VecMask extern (enum))
8
9(type ValueRegs (primitive ValueRegs))
10(type WritableValueRegs (primitive WritableValueRegs))
11(type ValueRegsVec extern (enum))
12
13;; Instruction lowering result: a vector of `ValueRegs`.
14(type InstOutput (primitive InstOutput))
15
16;; Type to hold multiple Regs
17(type MultiReg
18      (enum
19       (Empty)
20       (One (a Reg))
21       (Two (a Reg) (b Reg))
22       (Three (a Reg) (b Reg) (c Reg))
23       (Four (a Reg) (b Reg) (c Reg) (d Reg))
24      ))
25
26;;;; Registers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
27
28(model Reg (type (bv)))
29(type Reg (primitive Reg))
30(type WritableReg (primitive WritableReg))
31(type OptionWritableReg (primitive OptionWritableReg))
32(type VecReg extern (enum))
33(type VecWritableReg extern (enum))
34(type PReg (primitive PReg))
35
36;; Construct a `ValueRegs` of one register.
37(spec (value_reg arg)
38    (provide (= result arg)))
39(decl value_reg (Reg) ValueRegs)
40(extern constructor value_reg value_reg)
41
42;; Construct a `WritableValueRegs` of one register.
43(decl writable_value_reg (WritableReg) WritableValueRegs)
44(extern constructor writable_value_reg writable_value_reg)
45
46;; Construct a `ValueRegs` of two registers.
47(decl value_regs (Reg Reg) ValueRegs)
48(extern constructor value_regs value_regs)
49
50;; Construct a `WritableValueRegs` of two registers.
51(decl writable_value_regs (WritableReg WritableReg) WritableValueRegs)
52(extern constructor writable_value_regs writable_value_regs)
53
54;; Construct an empty `ValueRegs` containing only invalid register sentinels.
55(decl value_regs_invalid () ValueRegs)
56(extern constructor value_regs_invalid value_regs_invalid)
57
58;; Construct an empty `InstOutput`.
59(decl output_none () InstOutput)
60(extern constructor output_none output_none)
61
62;; Construct a single-element `InstOutput`.
63(spec (output arg)
64      (provide (= arg (conv_to (widthof arg) result))))
65(decl output (ValueRegs) InstOutput)
66(extern constructor output output)
67
68;; Construct a two-element `InstOutput`.
69(decl output_pair (ValueRegs ValueRegs) InstOutput)
70(extern constructor output_pair output_pair)
71
72;; Construct a single-element `InstOutput` from a single register.
73(spec (output_reg arg)
74      (provide (= result (conv_to (widthof result) arg))))
75(instantiate output_reg
76    ((args (bv 64)) (ret (bv 8)) (canon (bv 8)))
77    ((args (bv 64)) (ret (bv 16)) (canon (bv 16)))
78    ((args (bv 64)) (ret (bv 32)) (canon (bv 32)))
79    ((args (bv 64)) (ret (bv 64)) (canon (bv 64)))
80)
81(decl output_reg (Reg) InstOutput)
82(rule output_reg (output_reg reg) (output (value_reg reg)))
83
84;; Construct a single-element `InstOutput` from a value.
85(decl output_value (Value) InstOutput)
86(rule (output_value val) (output (put_in_regs val)))
87
88;; Construct an `InstOutput` from a vector.
89(decl output_vec (ValueRegsVec) InstOutput)
90(extern constructor output_vec output_vec)
91
92;; Get a temporary register for writing.
93(decl temp_writable_reg (Type) WritableReg)
94(extern constructor temp_writable_reg temp_writable_reg)
95
96;; Get a temporary register for reading.
97(decl temp_reg (Type) Reg)
98(rule (temp_reg ty)
99      (writable_reg_to_reg (temp_writable_reg ty)))
100
101(decl is_valid_reg (bool) Reg)
102(extern extractor infallible is_valid_reg is_valid_reg)
103
104;; Get or match the invalid register.
105(decl invalid_reg () Reg)
106(extern constructor invalid_reg invalid_reg)
107(extractor (invalid_reg) (is_valid_reg false))
108
109;; Match any register but the invalid register.
110(decl valid_reg (Reg) Reg)
111(extractor (valid_reg reg) (and (is_valid_reg true) reg))
112
113;; Mark this value as used, to ensure that it gets lowered.
114(decl mark_value_used (Value) Unit)
115(extern constructor mark_value_used mark_value_used)
116
117;; Put the given value into a register.
118;;
119;; Asserts that the value fits into a single register, and doesn't require
120;; multiple registers for its representation (like `i128` on x64 for example).
121;;
122;; As a side effect, this marks the value as used.
123(spec (put_in_reg arg)
124      (provide (= result (conv_to 64 arg))))
125(decl put_in_reg (Value) Reg)
126(extern constructor put_in_reg put_in_reg)
127
128;; Put the given value into one or more registers.
129;;
130;; As a side effect, this marks the value as used.
131(spec (put_in_regs arg) (provide (= (conv_to 64 arg) result)))
132(decl put_in_regs (Value) ValueRegs)
133(extern constructor put_in_regs put_in_regs)
134
135;; Put a slice of values into a vector of ValueRegs.
136(decl put_in_regs_vec (ValueSlice) ValueRegsVec)
137(extern constructor put_in_regs_vec put_in_regs_vec)
138
139;; If the given reg is a real register, cause the value in reg to be in a virtual
140;; reg, by copying it into a new virtual reg.
141(decl ensure_in_vreg (Reg Type) Reg)
142(extern constructor ensure_in_vreg ensure_in_vreg)
143
144;; Get the `n`th register inside a `ValueRegs`.
145(spec (value_regs_get arg i)
146    (provide (= arg result) (= (widthof i) 1)))
147(decl value_regs_get (ValueRegs usize) Reg)
148(extern constructor value_regs_get value_regs_get)
149
150;; Get the number of registers in a `ValueRegs`.
151(decl pure value_regs_len (ValueRegs) usize)
152(extern constructor value_regs_len value_regs_len)
153
154;; Put the value into one or more registers and return the first register.
155;;
156;; Unlike `put_in_reg`, this does not assert that the value fits in a single
157;; register. This is useful for things like a `i128` shift amount, where we mask
158;; the shift amount to the bit width of the value being shifted, and so the high
159;; half of the `i128` won't ever be used.
160;;
161;; As a side effect, this marks that value as used.
162(decl lo_reg (Value) Reg)
163(rule (lo_reg val)
164      (let ((regs ValueRegs (put_in_regs val)))
165        (value_regs_get regs 0)))
166
167;; Convert a `PReg` into a `Reg`.
168(decl preg_to_reg (PReg) Reg)
169(extern constructor preg_to_reg preg_to_reg)
170
171;; Convert a MultiReg with three registers into an InstOutput containing
172;; one ValueRegs containing the first two regs and one containing the third reg
173(decl multi_reg_to_pair_and_single (MultiReg) InstOutput)
174(rule (multi_reg_to_pair_and_single (MultiReg.Three a b c))
175      (output_pair (value_regs a b) c))
176
177;; Convert a MultiReg with two registers into an InstOutput containing one ValueRegs with both regs
178(decl multi_reg_to_pair (MultiReg) InstOutput)
179(rule (multi_reg_to_pair (MultiReg.Two a b))
180      (value_regs a b))
181
182;; Convert a MultiReg with one register into an InstOutput containing one ValueRegs with the register
183(decl multi_reg_to_single (MultiReg) InstOutput)
184(rule (multi_reg_to_single (MultiReg.One a))
185      (value_reg a))
186
187;; Add a range fact to a register, when compiling with
188;; proof-carrying-code enabled.
189(decl add_range_fact (Reg u16 u64 u64) Reg)
190(extern constructor add_range_fact add_range_fact)
191
192;;;; Common Mach Types ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
193
194(type MachLabel (primitive MachLabel))
195(type ValueLabel (primitive ValueLabel))
196(type UnwindInst (primitive UnwindInst))
197(type ExternalName (primitive ExternalName))
198(type BoxExternalName (primitive BoxExternalName))
199(type RelocDistance extern (enum (Near) (Far)))
200(type VecArgPair extern (enum))
201(type VecRetPair extern (enum))
202(type CallArgList (primitive CallArgList))
203(type CallRetList (primitive CallRetList))
204(type MachLabelSlice extern (enum))
205(type BoxVecMachLabel extern (enum))
206
207;; Extract a the target from a MachLabelSlice with exactly one target.
208(decl single_target (MachLabel) MachLabelSlice)
209(extern extractor single_target single_target)
210
211;; Extract a the targets from a MachLabelSlice with exactly two targets.
212(decl two_targets (MachLabel MachLabel) MachLabelSlice)
213(extern extractor two_targets two_targets)
214
215;; Extract the default target and jump table from a MachLabelSlice.
216(decl jump_table_targets (MachLabel BoxVecMachLabel) MachLabelSlice)
217(extern extractor jump_table_targets jump_table_targets)
218
219;; The size of the jump table.
220(decl jump_table_size (BoxVecMachLabel) u32)
221(extern constructor jump_table_size jump_table_size)
222
223;;;; Helper Clif Extractors ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
224
225;; Extractor to get a `ValueSlice` out of a `ValueList`.
226(decl value_list_slice (ValueSlice) ValueList)
227(extern extractor infallible value_list_slice value_list_slice)
228
229;; Extractor to test whether a `ValueSlice` is empty.
230(decl value_slice_empty () ValueSlice)
231(extern extractor value_slice_empty value_slice_empty)
232
233;; Extractor to split a `ValueSlice` into its first element plus a tail.
234(decl value_slice_unwrap (Value ValueSlice) ValueSlice)
235(extern extractor value_slice_unwrap value_slice_unwrap)
236
237;; Return the length of a `ValueSlice`.
238(decl value_slice_len (ValueSlice) usize)
239(extern constructor value_slice_len value_slice_len)
240
241;; Return any element of a `ValueSlice`.
242(decl value_slice_get (ValueSlice usize) Value)
243(extern constructor value_slice_get value_slice_get)
244
245;; Extractor to get the first element from a value list, along with its tail as
246;; a `ValueSlice`.
247(decl unwrap_head_value_list_1 (Value ValueSlice) ValueList)
248(extractor (unwrap_head_value_list_1 head tail)
249           (value_list_slice (value_slice_unwrap head tail)))
250
251;; Extractor to get the first two elements from a value list, along with its
252;; tail as a `ValueSlice`.
253(decl unwrap_head_value_list_2 (Value Value ValueSlice) ValueList)
254(extractor (unwrap_head_value_list_2 head1 head2 tail)
255           (value_list_slice (value_slice_unwrap head1 (value_slice_unwrap head2 tail))))
256
257;; Turn a `Writable<Reg>` into a `Reg` via `Writable::to_reg`.
258(decl pure writable_reg_to_reg (WritableReg) Reg)
259(extern constructor writable_reg_to_reg writable_reg_to_reg)
260
261;; Extract the result values for the given instruction.
262(decl inst_results (ValueSlice) Inst)
263(extern extractor infallible inst_results inst_results)
264
265;; Returns whether the given value is unused in this function and is a dead
266;; result.
267(decl pure value_is_unused (Value) bool)
268(extern constructor value_is_unused value_is_unused)
269
270;; Extract the first result value of the given instruction.
271(decl first_result (Value) Inst)
272(extern extractor first_result first_result)
273
274;; Extract the `InstructionData` for an `Inst`.
275(decl inst_data_value (InstructionData) Inst)
276(extern extractor infallible inst_data_value inst_data_value)
277
278;; Extract the type of the instruction's first result.
279(decl result_type (Type) Inst)
280(extractor (result_type ty)
281           (first_result (value_type ty)))
282
283;; Extract the type of the instruction's first result and pass along the
284;; instruction as well.
285(spec (has_type ty arg)
286      (provide (= result arg))
287      (require (= ty (widthof arg))))
288(decl has_type (Type Inst) Inst)
289(extractor (has_type ty inst)
290           (and (result_type ty)
291                inst))
292
293(decl u8_from_iconst (u8) Value)
294(extractor (u8_from_iconst x)
295           (u64_from_iconst (u8_from_u64 x)))
296
297(decl u16_from_iconst (u16) Value)
298(extractor (u16_from_iconst x)
299           (u64_from_iconst (u16_from_u64 x)))
300
301(decl u32_from_iconst (u32) Value)
302(extractor (u32_from_iconst x)
303           (u64_from_iconst (u32_from_u64 x)))
304
305;; Extract a constant `u64` from a value defined by an `iconst`.
306(spec (u64_from_iconst arg) (provide (= arg (zero_ext 64 result))))
307(decl u64_from_iconst (u64) Value)
308(extractor (u64_from_iconst x)
309           (def_inst (iconst (u64_from_imm64 x))))
310
311(decl i8_from_iconst (i8) Value)
312(extractor (i8_from_iconst x)
313           (i64_from_iconst (i8_from_i64 x)))
314
315(decl i16_from_iconst (i16) Value)
316(extractor (i16_from_iconst x)
317           (i64_from_iconst (i16_from_i64 x)))
318
319;; Extract a constant `i32` from a value defined by an `iconst`.
320;; The value is sign extended to 32 bits.
321(spec (i32_from_iconst arg)
322      (provide (= arg (extract 31 0 (sign_ext 64 result))))
323      (require (= result (sign_ext (widthof result) arg))))
324(decl i32_from_iconst (i32) Value)
325(extractor (i32_from_iconst x)
326           (i64_from_iconst (i32_from_i64 x)))
327
328;; Extract a constant `i64` from a value defined by an `iconst`.
329;; The value is sign extended to 64 bits.
330(decl i64_from_iconst (i64) Value)
331(extern extractor i64_from_iconst i64_from_iconst)
332
333;; Match any zero value for iconst, fconst32, fconst64, vconst and splat.
334(decl pure partial zero_value (Value) Value)
335(extern constructor zero_value zero_value)
336
337;; Match a sinkable instruction from a value operand.
338(decl pure partial is_sinkable_inst (Value) Inst)
339(extern constructor is_sinkable_inst is_sinkable_inst)
340
341;; Match a uextend or any other instruction, "seeing through" the uextend if
342;; present.
343(decl maybe_uextend (Value) Value)
344(extern extractor maybe_uextend maybe_uextend)
345
346;; Get an unsigned 8-bit immediate in a u8 from an Imm64, if possible.
347(spec (uimm8 arg)
348    (provide (= result (zero_ext 64 arg)))
349    (require (bvslt result #x0000000000000100)
350             (= (widthof arg) 8)))
351(decl uimm8 (u8) Imm64)
352(extern extractor uimm8 uimm8)
353
354(decl eq (Value Value) Value)
355(extractor (eq x y) (icmp (IntCC.Equal) x y))
356
357(decl ne (Value Value) Value)
358(extractor (ne x y) (icmp (IntCC.NotEqual) x y))
359
360(decl ult (Value Value) Value)
361(extractor (ult x y) (icmp (IntCC.UnsignedLessThan) x y))
362
363(decl ule (Value Value) Value)
364(extractor (ule x y) (icmp (IntCC.UnsignedLessThanOrEqual) x y))
365
366(decl ugt (Value Value) Value)
367(extractor (ugt x y) (icmp (IntCC.UnsignedGreaterThan) x y))
368
369(decl uge (Value Value) Value)
370(extractor (uge x y) (icmp (IntCC.UnsignedGreaterThanOrEqual) x y))
371
372(decl slt (Value Value) Value)
373(extractor (slt x y) (icmp (IntCC.SignedLessThan) x y))
374
375(decl sle (Value Value) Value)
376(extractor (sle x y) (icmp (IntCC.SignedLessThanOrEqual) x y))
377
378(decl sgt (Value Value) Value)
379(extractor (sgt x y) (icmp (IntCC.SignedGreaterThan) x y))
380
381(decl sge (Value Value) Value)
382(extractor (sge x y) (icmp (IntCC.SignedGreaterThanOrEqual) x y))
383
384;; Get the MachLabel for a particular CLIF block's indexed exception-handling successor.
385(decl block_exn_successor_label (Block u64) MachLabel)
386(extern constructor block_exn_successor_label block_exn_successor_label)
387
388;; Instruction creation helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
389
390;; Emit an instruction.
391;;
392;; This is low-level and side-effectful; it should only be used as an
393;; implementation detail by helpers that preserve the SSA facade themselves.
394
395(decl emit (MInst) Unit)
396(extern constructor emit emit)
397
398;; Sink an instruction.
399;;
400;; This is a side-effectful operation that notifies the context that the
401;; instruction has been sunk into another instruction, and no longer needs to
402;; be lowered.
403(decl sink_inst (Inst) Unit)
404(extern constructor sink_inst sink_inst)
405
406;; Constant pool emission.
407
408(type VCodeConstant (primitive VCodeConstant))
409
410;; Add a u64 little-endian constant to the in-memory constant pool and
411;; return a VCodeConstant index that refers to it. This is
412;; side-effecting but idempotent (constants are deduplicated).
413(decl emit_u64_le_const (u64) VCodeConstant)
414(extern constructor emit_u64_le_const emit_u64_le_const)
415
416;; Add a u64 big-endian constant to the in-memory constant pool and
417;; return a VCodeConstant index that refers to it. This is
418;; side-effecting but idempotent (constants are deduplicated).
419(decl emit_u64_be_const (u64) VCodeConstant)
420(extern constructor emit_u64_be_const emit_u64_be_const)
421
422;; Add a u128 little-endian constant to the in-memory constant pool and
423;; return a VCodeConstant index that refers to it. This is
424;; side-effecting but idempotent (constants are deduplicated).
425(decl emit_u128_le_const (u128) VCodeConstant)
426(extern constructor emit_u128_le_const emit_u128_le_const)
427
428;; Add a u128 big-endian constant to the in-memory constant pool and
429;; return a VCodeConstant index that refers to it. This is
430;; side-effecting but idempotent (constants are deduplicated).
431(decl emit_u128_be_const (u128) VCodeConstant)
432(extern constructor emit_u128_be_const emit_u128_be_const)
433
434;; Fetch the VCodeConstant associated with a Constant.
435(decl const_to_vconst (Constant) VCodeConstant)
436(extern constructor const_to_vconst const_to_vconst)
437
438;;;; Helpers for Side-Effectful Instructions Without Results ;;;;;;;;;;;;;;;;;;;
439
440(type SideEffectNoResult (enum
441                          (Inst (inst MInst))
442                          (Inst2 (inst1 MInst)
443                                 (inst2 MInst))
444                          (Inst3 (inst1 MInst)
445                                 (inst2 MInst)
446                                 (inst3 MInst))))
447
448(model SideEffectNoResult (type Unit))
449
450;; Emit given side-effectful instruction.
451(decl emit_side_effect (SideEffectNoResult) Unit)
452(rule (emit_side_effect (SideEffectNoResult.Inst inst))
453      (emit inst))
454(rule (emit_side_effect (SideEffectNoResult.Inst2 inst1 inst2))
455      (let ((_ Unit (emit inst1)))
456        (emit inst2)))
457(rule (emit_side_effect (SideEffectNoResult.Inst3 inst1 inst2 inst3))
458      (let ((_ Unit (emit inst1))
459            (_ Unit (emit inst2)))
460        (emit inst3)))
461
462;; Create an empty `InstOutput`, but do emit the given side-effectful
463;; instruction.
464(decl side_effect (SideEffectNoResult) InstOutput)
465(spec (side_effect v)
466    (provide (= result v)))
467(rule (side_effect inst)
468      (let ((_ Unit (emit_side_effect inst)))
469        (output_none)))
470
471(decl side_effect_concat (SideEffectNoResult SideEffectNoResult) SideEffectNoResult)
472(rule (side_effect_concat (SideEffectNoResult.Inst inst1) (SideEffectNoResult.Inst inst2))
473      (SideEffectNoResult.Inst2 inst1 inst2))
474(rule (side_effect_concat (SideEffectNoResult.Inst inst1) (SideEffectNoResult.Inst2 inst2 inst3))
475      (SideEffectNoResult.Inst3 inst1 inst2 inst3))
476(rule (side_effect_concat (SideEffectNoResult.Inst2 inst1 inst2) (SideEffectNoResult.Inst inst3))
477      (SideEffectNoResult.Inst3 inst1 inst2 inst3))
478
479;; In certain cases (e.g., RMW lowerings) it can be useful to emit an invalid
480;; register after a side-effectful instruction.
481(decl side_effect_as_invalid (SideEffectNoResult) InstOutput)
482(rule (side_effect_as_invalid inst)
483      (let ((_ InstOutput (side_effect inst)))
484        (invalid_reg)))
485
486;;;; Helpers for Working with Flags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
487
488;; Newtype wrapper around `MInst` for instructions that are used for their
489;; effect on flags.
490;;
491;; Variant determines how result is given when combined with a
492;; ConsumesFlags. See `with_flags` below for more.
493(type ProducesFlags (enum
494                     ;; For cases where the flags have been produced by another
495                     ;; instruction, and we have out-of-band reasons to know
496                     ;; that they won't be clobbered by the time we depend on
497                     ;; them.
498                     (AlreadyExistingFlags)
499                     (ProducesFlagsSideEffect (inst MInst))
500                     (ProducesFlagsTwiceSideEffect (inst1 MInst) (inst2 MInst))
501                     ;; Not directly combinable with a ConsumesFlags;
502                     ;; used in s390x and unwrapped directly by `trapif`.
503                     (ProducesFlagsReturnsReg (inst MInst) (result Reg))
504                     (ProducesFlagsReturnsResultWithConsumer (inst MInst) (result Reg))))
505
506;; Chain another producer to a `ProducesFlags`.
507(decl produces_flags_concat (ProducesFlags ProducesFlags) ProducesFlags)
508(rule (produces_flags_concat (ProducesFlags.ProducesFlagsSideEffect inst1) (ProducesFlags.ProducesFlagsSideEffect inst2))
509      (ProducesFlags.ProducesFlagsTwiceSideEffect inst1 inst2))
510
511;; Newtype wrapper around `MInst` for instructions that consume and produce flags
512(type ConsumesAndProducesFlags (enum
513                      (SideEffect (inst MInst))
514                      (ReturnsReg (inst MInst) (result Reg))))
515
516;; Newtype wrapper around `MInst` for instructions that consume flags.
517;;
518;; Variant determines how result is given when combined with a
519;; ProducesFlags. See `with_flags` below for more.
520(type ConsumesFlags (enum
521                     (ConsumesFlagsSideEffect (inst MInst))
522                     (ConsumesFlagsSideEffect2 (inst1 MInst) (inst2 MInst))
523                     (ConsumesFlagsReturnsResultWithProducer (inst MInst) (result Reg))
524                     (ConsumesFlagsReturnsReg (inst MInst) (result Reg))
525                     (ConsumesFlagsTwiceReturnsValueRegs (inst1 MInst)
526                                                         (inst2 MInst)
527                                                         (result ValueRegs))
528                     (ConsumesFlagsFourTimesReturnsValueRegs (inst1 MInst)
529                                                             (inst2 MInst)
530                                                             (inst3 MInst)
531                                                             (inst4 MInst)
532                                                             (result ValueRegs))))
533
534
535
536;; Get the produced register out of a ProducesFlags.
537(decl produces_flags_get_reg (ProducesFlags) Reg)
538(rule (produces_flags_get_reg (ProducesFlags.ProducesFlagsReturnsReg _ reg)) reg)
539(rule (produces_flags_get_reg (ProducesFlags.ProducesFlagsReturnsResultWithConsumer _ reg)) reg)
540
541;; Modify a ProducesFlags to use it only for its side-effect, ignoring
542;; its result.
543(decl produces_flags_ignore (ProducesFlags) ProducesFlags)
544(rule (produces_flags_ignore (ProducesFlags.ProducesFlagsReturnsReg inst _))
545      (ProducesFlags.ProducesFlagsSideEffect inst))
546(rule (produces_flags_ignore (ProducesFlags.ProducesFlagsReturnsResultWithConsumer inst _))
547      (ProducesFlags.ProducesFlagsSideEffect inst))
548
549;; Helper for combining two flags-consumer instructions that return a
550;; single Reg, giving a ConsumesFlags that returns both values in a
551;; ValueRegs.
552(decl consumes_flags_concat (ConsumesFlags ConsumesFlags) ConsumesFlags)
553(rule (consumes_flags_concat (ConsumesFlags.ConsumesFlagsReturnsReg inst1 reg1)
554                             (ConsumesFlags.ConsumesFlagsReturnsReg inst2 reg2))
555      (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs
556       inst1
557       inst2
558       (value_regs reg1 reg2)))
559(rule (consumes_flags_concat
560        (ConsumesFlags.ConsumesFlagsSideEffect inst1)
561        (ConsumesFlags.ConsumesFlagsSideEffect inst2))
562      (ConsumesFlags.ConsumesFlagsSideEffect2 inst1 inst2))
563
564;; Get the produced register out of a ConsumesFlags.
565(decl consumes_flags_get_reg (ConsumesFlags) Reg)
566(rule (consumes_flags_get_reg (ConsumesFlags.ConsumesFlagsReturnsReg _ reg)) reg)
567(decl consumes_flags_get_regs (ConsumesFlags) ValueRegs)
568(rule (consumes_flags_get_regs (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs _ _ regs)) regs)
569
570;; Combine flags-producing and -consuming instructions together, ensuring that
571;; they are emitted back-to-back and no other instructions can be emitted
572;; between them and potentially clobber the flags.
573;;
574;; Returns a `ValueRegs` according to the specific combination of ProducesFlags and ConsumesFlags modes:
575;; - SideEffect + ReturnsReg --> ValueReg with one Reg from consumer
576;; - SideEffect + ReturnsValueRegs --> ValueReg as given from consumer
577;; - ReturnsResultWithProducer + ReturnsResultWithConsumer --> ValueReg with low part from producer, high part from consumer
578;;
579;; See `with_flags_reg` below for a variant that extracts out just the lower Reg.
580(decl with_flags (ProducesFlags ConsumesFlags) ValueRegs)
581
582(rule (with_flags (ProducesFlags.ProducesFlagsReturnsResultWithConsumer producer_inst producer_result)
583                  (ConsumesFlags.ConsumesFlagsReturnsResultWithProducer consumer_inst consumer_result))
584      (let ((_x Unit (emit producer_inst))
585            (_y Unit (emit consumer_inst)))
586        (value_regs producer_result consumer_result)))
587
588;; A flag-producer that also produces a result, paired with a consumer that has
589;; no results.
590(rule (with_flags (ProducesFlags.ProducesFlagsReturnsResultWithConsumer producer_inst producer_result)
591                  (ConsumesFlags.ConsumesFlagsSideEffect consumer_inst))
592      (let ((_ Unit (emit producer_inst))
593            (_ Unit (emit consumer_inst)))
594        (value_reg producer_result)))
595
596(rule (with_flags (ProducesFlags.ProducesFlagsSideEffect producer_inst)
597                  (ConsumesFlags.ConsumesFlagsReturnsReg consumer_inst consumer_result))
598      (let ((_x Unit (emit producer_inst))
599            (_y Unit (emit consumer_inst)))
600        (value_reg consumer_result)))
601
602(rule (with_flags (ProducesFlags.ProducesFlagsSideEffect producer_inst)
603                  (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs consumer_inst_1
604                                                                    consumer_inst_2
605                                                                    consumer_result))
606      ;; We must emit these instructions in order as the creator of
607      ;; the ConsumesFlags may be relying on dataflow dependencies
608      ;; amongst them.
609      (let ((_x Unit (emit producer_inst))
610            (_y Unit (emit consumer_inst_1))
611            (_z Unit (emit consumer_inst_2)))
612        consumer_result))
613
614(rule (with_flags (ProducesFlags.ProducesFlagsSideEffect producer_inst)
615                  (ConsumesFlags.ConsumesFlagsFourTimesReturnsValueRegs consumer_inst_1
616                                                                        consumer_inst_2
617                                                                        consumer_inst_3
618                                                                        consumer_inst_4
619                                                                        consumer_result))
620      ;; We must emit these instructions in order as the creator of
621      ;; the ConsumesFlags may be relying on dataflow dependencies
622      ;; amongst them.
623      (let ((_x Unit (emit producer_inst))
624            (_y Unit (emit consumer_inst_1))
625            (_z Unit (emit consumer_inst_2))
626            (_w Unit (emit consumer_inst_3))
627            (_v Unit (emit consumer_inst_4)))
628        consumer_result))
629
630(rule (with_flags (ProducesFlags.ProducesFlagsTwiceSideEffect producer_inst1 producer_inst2)
631                  (ConsumesFlags.ConsumesFlagsReturnsReg consumer_inst consumer_result))
632      (let ((_ Unit (emit producer_inst1))
633            (_ Unit (emit producer_inst2))
634            (_ Unit (emit consumer_inst)))
635        (value_reg consumer_result)))
636
637(rule (with_flags (ProducesFlags.ProducesFlagsTwiceSideEffect producer_inst1 producer_inst2)
638                  (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs consumer_inst_1
639                                                                    consumer_inst_2
640                                                                    consumer_result))
641      ;; We must emit these instructions in order as the creator of
642      ;; the ConsumesFlags may be relying on dataflow dependencies
643      ;; amongst them.
644      (let ((_ Unit (emit producer_inst1))
645            (_ Unit (emit producer_inst2))
646            (_ Unit (emit consumer_inst_1))
647            (_ Unit (emit consumer_inst_2)))
648        consumer_result))
649
650(rule (with_flags (ProducesFlags.ProducesFlagsTwiceSideEffect producer_inst1 producer_inst2)
651                  (ConsumesFlags.ConsumesFlagsFourTimesReturnsValueRegs consumer_inst_1
652                                                                        consumer_inst_2
653                                                                        consumer_inst_3
654                                                                        consumer_inst_4
655                                                                        consumer_result))
656      ;; We must emit these instructions in order as the creator of
657      ;; the ConsumesFlags may be relying on dataflow dependencies
658      ;; amongst them.
659      (let ((_ Unit (emit producer_inst1))
660            (_ Unit (emit producer_inst2))
661            (_ Unit (emit consumer_inst_1))
662            (_ Unit (emit consumer_inst_2))
663            (_ Unit (emit consumer_inst_3))
664            (_ Unit (emit consumer_inst_4)))
665        consumer_result))
666
667(decl with_flags_reg (ProducesFlags ConsumesFlags) Reg)
668(rule (with_flags_reg p c)
669      (let ((v ValueRegs (with_flags p c)))
670        (value_regs_get v 0)))
671
672;; Indicate that the current state of the flags register from the instruction
673;; that produces this Value is relied on.
674(decl flags_to_producesflags (Value) ProducesFlags)
675(rule (flags_to_producesflags val)
676      (let ((_ Unit (mark_value_used val)))
677        (ProducesFlags.AlreadyExistingFlags)))
678
679;; Combine a flags-producing instruction and a flags-consuming instruction that
680;; produces no results.
681;;
682;; This function handles the following case only:
683;; - ProducesFlagsSideEffect + ConsumesFlagsSideEffect
684(decl with_flags_side_effect (ProducesFlags ConsumesFlags) SideEffectNoResult)
685
686(rule (with_flags_side_effect
687        (ProducesFlags.AlreadyExistingFlags)
688        (ConsumesFlags.ConsumesFlagsSideEffect c))
689      (SideEffectNoResult.Inst c))
690
691(rule (with_flags_side_effect
692        (ProducesFlags.AlreadyExistingFlags)
693        (ConsumesFlags.ConsumesFlagsSideEffect2 c1 c2))
694      (SideEffectNoResult.Inst2 c1 c2))
695
696(rule (with_flags_side_effect
697        (ProducesFlags.ProducesFlagsSideEffect p)
698        (ConsumesFlags.ConsumesFlagsSideEffect c))
699      (SideEffectNoResult.Inst2 p c))
700
701(rule (with_flags_side_effect
702        (ProducesFlags.ProducesFlagsSideEffect p)
703        (ConsumesFlags.ConsumesFlagsSideEffect2 c1 c2))
704      (SideEffectNoResult.Inst3 p c1 c2))
705
706(rule (with_flags_side_effect
707        (ProducesFlags.ProducesFlagsTwiceSideEffect p1 p2)
708        (ConsumesFlags.ConsumesFlagsSideEffect c))
709      (SideEffectNoResult.Inst3 p1 p2 c))
710
711;; Combine flag-producing and -consuming instruction that allows more than two results to be returned
712(decl with_flags_chained (ProducesFlags ConsumesAndProducesFlags ConsumesFlags) MultiReg)
713
714;; ProducesFlags.SideEffect + ConsumesAndProducesFlags.SideEffect with all possible ConsumeFlags options
715(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
716                          (ConsumesAndProducesFlags.SideEffect middle_inst)
717                          (ConsumesFlags.ConsumesFlagsSideEffect consume_inst))
718      (let ((_ Unit (emit prod_inst))
719            (_ Unit (emit middle_inst))
720            (_ Unit (emit consume_inst)))
721        (MultiReg.Empty)))
722
723(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
724                          (ConsumesAndProducesFlags.SideEffect middle_inst)
725                          (ConsumesFlags.ConsumesFlagsSideEffect2 consume_inst1 consume_inst2))
726      (let ((_ Unit (emit prod_inst))
727            (_ Unit (emit middle_inst))
728            (_ Unit (emit consume_inst1))
729            (_ Unit (emit consume_inst2)))
730        (MultiReg.Empty)))
731
732(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
733                          (ConsumesAndProducesFlags.SideEffect middle_inst)
734                          (ConsumesFlags.ConsumesFlagsReturnsReg consume_inst reg))
735      (let ((_ Unit (emit prod_inst))
736            (_ Unit (emit middle_inst))
737            (_ Unit (emit consume_inst)))
738        (MultiReg.One reg)))
739
740(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
741                          (ConsumesAndProducesFlags.SideEffect middle_inst)
742                          (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs consume_inst1 consume_inst2 consume_result))
743      (let ((_ Unit (emit prod_inst))
744            (_ Unit (emit middle_inst))
745            (_ Unit (emit consume_inst1))
746            (_ Unit (emit consume_inst2)))
747        (MultiReg.Two (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
748
749(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
750                          (ConsumesAndProducesFlags.SideEffect middle_inst)
751                          (ConsumesFlags.ConsumesFlagsFourTimesReturnsValueRegs consume_inst1 consume_inst2 consume_inst3 consume_inst4 consume_result))
752      (let ((_ Unit (emit prod_inst))
753            (_ Unit (emit middle_inst))
754            (_ Unit (emit consume_inst1))
755            (_ Unit (emit consume_inst2))
756            (_ Unit (emit consume_inst3))
757            (_ Unit (emit consume_inst4)))
758        (MultiReg.Two (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
759
760
761;; ProducesFlags.ReturnsReg + ConsumesAndProducesFlags.SideEffect with all possible ConsumeFlags options
762(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
763                          (ConsumesAndProducesFlags.SideEffect middle_inst)
764                          (ConsumesFlags.ConsumesFlagsSideEffect consume_inst))
765      (let ((_ Unit (emit prod_inst))
766            (_ Unit (emit middle_inst))
767            (_ Unit (emit consume_inst)))
768        (MultiReg.One prod_result)))
769
770(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
771                          (ConsumesAndProducesFlags.SideEffect middle_inst)
772                          (ConsumesFlags.ConsumesFlagsSideEffect2 consume_inst1 consume_inst2))
773      (let ((_ Unit (emit prod_inst))
774            (_ Unit (emit middle_inst))
775            (_ Unit (emit consume_inst1))
776            (_ Unit (emit consume_inst2)))
777        (MultiReg.One prod_result)))
778
779(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
780                          (ConsumesAndProducesFlags.SideEffect middle_inst)
781                          (ConsumesFlags.ConsumesFlagsReturnsReg consume_inst consume_result))
782      (let ((_ Unit (emit prod_inst))
783            (_ Unit (emit middle_inst))
784            (_ Unit (emit consume_inst)))
785        (MultiReg.Two prod_result consume_result)))
786
787(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
788                          (ConsumesAndProducesFlags.SideEffect middle_inst)
789                          (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs consume_inst1 consume_inst2 consume_result))
790      (let ((_ Unit (emit prod_inst))
791            (_ Unit (emit middle_inst))
792            (_ Unit (emit consume_inst1))
793            (_ Unit (emit consume_inst2)))
794        (MultiReg.Three prod_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
795
796(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
797                          (ConsumesAndProducesFlags.SideEffect middle_inst)
798                          (ConsumesFlags.ConsumesFlagsFourTimesReturnsValueRegs consume_inst1 consume_inst2 consume_inst3 consume_inst4 consume_result))
799      (let ((_ Unit (emit prod_inst))
800            (_ Unit (emit middle_inst))
801            (_ Unit (emit consume_inst1))
802            (_ Unit (emit consume_inst2))
803            (_ Unit (emit consume_inst3))
804            (_ Unit (emit consume_inst4)))
805        (MultiReg.Three prod_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
806
807
808;; ProducesFlags.SideEffect + ConsumesAndProducesFlags.ReturnsReg with all possible ConsumeFlags options
809(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
810                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
811                          (ConsumesFlags.ConsumesFlagsSideEffect consume_inst))
812      (let ((_ Unit (emit prod_inst))
813            (_ Unit (emit middle_inst))
814            (_ Unit (emit consume_inst)))
815        (MultiReg.One middle_result)))
816
817(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
818                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
819                          (ConsumesFlags.ConsumesFlagsSideEffect2 consume_inst1 consume_inst2))
820      (let ((_ Unit (emit prod_inst))
821            (_ Unit (emit middle_inst))
822            (_ Unit (emit consume_inst1))
823            (_ Unit (emit consume_inst2)))
824        (MultiReg.One middle_result)))
825
826(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
827                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
828                          (ConsumesFlags.ConsumesFlagsReturnsReg consume_inst consume_result))
829      (let ((_ Unit (emit prod_inst))
830            (_ Unit (emit middle_inst))
831            (_ Unit (emit consume_inst)))
832        (MultiReg.Two middle_result consume_result)))
833
834(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
835                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
836                          (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs consume_inst1 consume_inst2 consume_result))
837      (let ((_ Unit (emit prod_inst))
838            (_ Unit (emit middle_inst))
839            (_ Unit (emit consume_inst1))
840            (_ Unit (emit consume_inst2)))
841        (MultiReg.Three middle_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
842
843(rule (with_flags_chained (ProducesFlags.ProducesFlagsSideEffect prod_inst)
844                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
845                          (ConsumesFlags.ConsumesFlagsFourTimesReturnsValueRegs consume_inst1 consume_inst2 consume_inst3 consume_inst4 consume_result))
846      (let ((_ Unit (emit prod_inst))
847            (_ Unit (emit middle_inst))
848            (_ Unit (emit consume_inst1))
849            (_ Unit (emit consume_inst2))
850            (_ Unit (emit consume_inst3))
851            (_ Unit (emit consume_inst4)))
852        (MultiReg.Three middle_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
853
854
855;; ProducesFlags.ReturnsReg + ConsumesAndProducesFlags.ReturnsReg with all possible ConsumeFlags options
856(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
857                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
858                          (ConsumesFlags.ConsumesFlagsSideEffect consume_inst))
859      (let ((_ Unit (emit prod_inst))
860            (_ Unit (emit middle_inst))
861            (_ Unit (emit consume_inst)))
862        (MultiReg.Two prod_result middle_result)))
863
864(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
865                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
866                          (ConsumesFlags.ConsumesFlagsSideEffect2 consume_inst1 consume_inst2))
867      (let ((_ Unit (emit prod_inst))
868            (_ Unit (emit middle_inst))
869            (_ Unit (emit consume_inst1))
870            (_ Unit (emit consume_inst2)))
871        (MultiReg.Two prod_result middle_result)))
872
873(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
874                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
875                          (ConsumesFlags.ConsumesFlagsReturnsReg consume_inst consume_result))
876      (let ((_ Unit (emit prod_inst))
877            (_ Unit (emit middle_inst))
878            (_ Unit (emit consume_inst)))
879        (MultiReg.Three prod_result middle_result consume_result)))
880
881(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
882                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
883                          (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs consume_inst1 consume_inst2 consume_result))
884      (let ((_ Unit (emit prod_inst))
885            (_ Unit (emit middle_inst))
886            (_ Unit (emit consume_inst1))
887            (_ Unit (emit consume_inst2)))
888        (MultiReg.Four prod_result middle_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
889
890(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsReg prod_inst prod_result)
891                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
892                          (ConsumesFlags.ConsumesFlagsFourTimesReturnsValueRegs consume_inst1 consume_inst2 consume_inst3 consume_inst4 consume_result))
893      (let ((_ Unit (emit prod_inst))
894            (_ Unit (emit middle_inst))
895            (_ Unit (emit consume_inst1))
896            (_ Unit (emit consume_inst2))
897            (_ Unit (emit consume_inst3))
898            (_ Unit (emit consume_inst4)))
899        (MultiReg.Four prod_result middle_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
900
901;; ProducesFlags.ReturnsResultWithConsumer + ConsumesAndProducesFlags.ReturnsReg with all possible ConsumeFlags options
902(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsResultWithConsumer prod_inst prod_result)
903                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
904                          (ConsumesFlags.ConsumesFlagsSideEffect consume_inst))
905      (let ((_ Unit (emit prod_inst))
906            (_ Unit (emit middle_inst))
907            (_ Unit (emit consume_inst)))
908        (MultiReg.Two prod_result middle_result)))
909
910(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsResultWithConsumer prod_inst prod_result)
911                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
912                          (ConsumesFlags.ConsumesFlagsSideEffect2 consume_inst1 consume_inst2))
913      (let ((_ Unit (emit prod_inst))
914            (_ Unit (emit middle_inst))
915            (_ Unit (emit consume_inst1))
916            (_ Unit (emit consume_inst2)))
917        (MultiReg.Two prod_result middle_result)))
918
919(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsResultWithConsumer prod_inst prod_result)
920                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
921                          (ConsumesFlags.ConsumesFlagsReturnsReg consume_inst consume_result))
922      (let ((_ Unit (emit prod_inst))
923            (_ Unit (emit middle_inst))
924            (_ Unit (emit consume_inst)))
925        (MultiReg.Three prod_result middle_result consume_result)))
926
927(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsResultWithConsumer prod_inst prod_result)
928                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
929                          (ConsumesFlags.ConsumesFlagsReturnsResultWithProducer consume_inst consume_result))
930      (let ((_ Unit (emit prod_inst))
931            (_ Unit (emit middle_inst))
932            (_ Unit (emit consume_inst)))
933        (MultiReg.Three prod_result middle_result consume_result)))
934
935(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsResultWithConsumer prod_inst prod_result)
936                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
937                          (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs consume_inst1 consume_inst2 consume_result))
938      (let ((_ Unit (emit prod_inst))
939            (_ Unit (emit middle_inst))
940            (_ Unit (emit consume_inst1))
941            (_ Unit (emit consume_inst2)))
942        (MultiReg.Four prod_result middle_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
943
944(rule (with_flags_chained (ProducesFlags.ProducesFlagsReturnsResultWithConsumer prod_inst prod_result)
945                          (ConsumesAndProducesFlags.ReturnsReg middle_inst middle_result)
946                          (ConsumesFlags.ConsumesFlagsFourTimesReturnsValueRegs consume_inst1 consume_inst2 consume_inst3 consume_inst4 consume_result))
947      (let ((_ Unit (emit prod_inst))
948            (_ Unit (emit middle_inst))
949            (_ Unit (emit consume_inst1))
950            (_ Unit (emit consume_inst2))
951            (_ Unit (emit consume_inst3))
952            (_ Unit (emit consume_inst4)))
953        (MultiReg.Four prod_result middle_result (value_regs_get consume_result 0) (value_regs_get consume_result 1))))
954
955;;;; Helpers for accessing compilation flags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
956
957;; This definition should be kept up to date with the values defined in
958;; cranelift/codegen/meta/src/shared/settings.rs
959(type TlsModel extern (enum (None) (ElfGd) (Macho) (Coff)))
960
961(decl tls_model (TlsModel) Type)
962(extern extractor infallible tls_model tls_model)
963
964(decl pure partial tls_model_is_elf_gd () Unit)
965(extern constructor tls_model_is_elf_gd tls_model_is_elf_gd)
966
967(decl pure partial tls_model_is_macho () Unit)
968(extern constructor tls_model_is_macho tls_model_is_macho)
969
970(decl pure partial tls_model_is_coff () Unit)
971(extern constructor tls_model_is_coff tls_model_is_coff)
972
973(decl pure partial preserve_frame_pointers () Unit)
974(extern constructor preserve_frame_pointers preserve_frame_pointers)
975
976;; This definition should be kept up to date with the values defined in
977;; cranelift/codegen/meta/src/shared/settings.rs
978(type StackSwitchModel extern (enum (None) (Basic) (UpdateWindowsTib)))
979
980(decl pure partial stack_switch_model () StackSwitchModel)
981(extern constructor stack_switch_model stack_switch_model)
982
983;;;; Helpers for accessing instruction data ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
984
985(decl box_external_name (ExternalName) BoxExternalName)
986(extern constructor box_external_name box_external_name)
987
988;; Accessor for `FuncRef`.
989
990(decl func_ref_data (SigRef ExternalName RelocDistance bool) FuncRef)
991(extern extractor infallible func_ref_data func_ref_data)
992
993;; Accessor for `ExceptionTable`.
994(decl exception_sig (SigRef) ExceptionTable)
995(extern extractor infallible exception_sig exception_sig)
996
997;; Accessor for `GlobalValue`.
998
999(decl symbol_value_data (ExternalName RelocDistance i64) GlobalValue)
1000(extern extractor symbol_value_data symbol_value_data)
1001
1002;; Accessor for `Immediate` as a vector of u8 values.
1003
1004(decl vec_mask_from_immediate (VecMask) Immediate)
1005(extern extractor vec_mask_from_immediate vec_mask_from_immediate)
1006
1007;; Accessor for `Immediate` as u128.
1008
1009(decl u128_from_immediate (u128) Immediate)
1010(extern extractor u128_from_immediate u128_from_immediate)
1011
1012;; Extracts an `Immediate` as a `VCodeConstant`.
1013
1014(decl vconst_from_immediate (VCodeConstant) Immediate)
1015(extern extractor vconst_from_immediate vconst_from_immediate)
1016
1017;; Accessor for `Constant` as u128.
1018
1019(decl u128_from_constant (u128) Constant)
1020(extern extractor u128_from_constant u128_from_constant)
1021
1022;; Accessor for `Constant` as u64.
1023
1024(decl u64_from_constant (u64) Constant)
1025(extern extractor u64_from_constant u64_from_constant)
1026
1027;; Extracts lane indices, represented as u8's, if the immediate for a
1028;; `shuffle` instruction represents shuffling N-bit values. The u8 values
1029;; returned will be in the range of 0 to (256/N)-1, inclusive, and index the
1030;; N-bit chunks of two concatenated 128-bit vectors starting from the
1031;; least-significant bits.
1032(decl shuffle64_from_imm (u8 u8) Immediate)
1033(extern extractor shuffle64_from_imm shuffle64_from_imm)
1034(decl shuffle32_from_imm (u8 u8 u8 u8) Immediate)
1035(extern extractor shuffle32_from_imm shuffle32_from_imm)
1036(decl shuffle16_from_imm (u8 u8 u8 u8 u8 u8 u8 u8) Immediate)
1037(extern extractor shuffle16_from_imm shuffle16_from_imm)
1038
1039;;;; Helpers for generating returns ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1040
1041;; Extractor to check for the special case that a `WritableValueRegs`
1042;; contains only a single register.
1043(decl only_writable_reg (WritableReg) WritableValueRegs)
1044(extern extractor only_writable_reg only_writable_reg)
1045
1046;; Get the `n`th register inside a `WritableValueRegs`.
1047(decl writable_regs_get (WritableValueRegs usize) WritableReg)
1048(extern constructor writable_regs_get writable_regs_get)
1049
1050;;;; Helpers for generating calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1051
1052;; Type to hold information about a function call signature.
1053(type Sig (primitive Sig))
1054
1055;; Information how to pass one argument or return value.
1056(type ABIArg extern (enum))
1057
1058;; Information how to pass a single slot of one argument or return value.
1059(type ABIArgSlot extern
1060  (enum
1061    (Reg
1062      (reg RealReg)
1063      (ty Type)
1064      (extension ArgumentExtension))
1065    (Stack
1066      (offset i64)
1067      (ty Type)
1068      (extension ArgumentExtension))))
1069
1070;; Physical register that may hold an argument or return value.
1071(type RealReg (primitive RealReg))
1072
1073;; Instruction on whether and how to extend an argument value.
1074(model ArgumentExtension
1075  (enum
1076    (None)
1077    (Uext)
1078    (Sext)))
1079(type ArgumentExtension extern
1080  (enum
1081    (None)
1082    (Uext)
1083    (Sext)))
1084
1085;; Create a Sig from a SigRef.
1086(decl abi_sig (SigRef) Sig)
1087(extern constructor abi_sig abi_sig)
1088
1089;; Get the number of arguments expected.
1090(decl abi_num_args (Sig) usize)
1091(extern constructor abi_num_args abi_num_args)
1092
1093;; Get information specifying how to pass one argument.
1094(decl abi_get_arg (Sig usize) ABIArg)
1095(extern constructor abi_get_arg abi_get_arg)
1096
1097;; Get the number of return values expected.
1098(decl abi_num_rets (Sig) usize)
1099(extern constructor abi_num_rets abi_num_rets)
1100
1101;; Get information specifying how to pass one return value.
1102(decl abi_get_ret (Sig usize) ABIArg)
1103(extern constructor abi_get_ret abi_get_ret)
1104
1105;; Get information specifying how to pass the implicit pointer
1106;; to the return-value area on the stack, if required.
1107(decl abi_ret_arg (ABIArg) Sig)
1108(extern extractor abi_ret_arg abi_ret_arg)
1109
1110;; Succeeds if no implicit return-value area pointer is required.
1111(decl abi_no_ret_arg () Sig)
1112(extern extractor abi_no_ret_arg abi_no_ret_arg)
1113
1114;; Incoming return area pointer (must be present).
1115(decl abi_unwrap_ret_area_ptr () Reg)
1116(extern constructor abi_unwrap_ret_area_ptr abi_unwrap_ret_area_ptr)
1117
1118;; StackSlot addr
1119(decl abi_stackslot_addr (WritableReg StackSlot Offset32) MInst)
1120(extern constructor abi_stackslot_addr abi_stackslot_addr)
1121
1122;; StackSlot raw offset into slot region
1123(decl abi_stackslot_offset_into_slot_region (StackSlot Offset32 Offset32) i32)
1124(extern constructor abi_stackslot_offset_into_slot_region abi_stackslot_offset_into_slot_region)
1125
1126;; DynamicStackSlot addr
1127(decl abi_dynamic_stackslot_addr (WritableReg DynamicStackSlot) MInst)
1128(extern constructor abi_dynamic_stackslot_addr abi_dynamic_stackslot_addr)
1129
1130;; Extractor to detect the special case where an argument or
1131;; return value only requires a single slot to be passed.
1132(decl abi_arg_only_slot (ABIArgSlot) ABIArg)
1133(extern extractor abi_arg_only_slot abi_arg_only_slot)
1134
1135;; Extractor to detect the special case where a non-struct argument
1136;; is implicitly passed by reference using a hidden pointer.
1137(decl abi_arg_implicit_pointer (ABIArgSlot i64 Type) ABIArg)
1138(extern extractor abi_arg_implicit_pointer abi_arg_implicit_pointer)
1139
1140;; Convert a real register number into a virtual register.
1141(decl real_reg_to_reg (RealReg) Reg)
1142(extern constructor real_reg_to_reg real_reg_to_reg)
1143
1144;; Convert a real register number into a writable virtual register.
1145(decl real_reg_to_writable_reg (RealReg) WritableReg)
1146(extern constructor real_reg_to_writable_reg real_reg_to_writable_reg)
1147
1148;; Generate a move between two registers.
1149(decl gen_move (Type WritableReg Reg) MInst)
1150(extern constructor gen_move gen_move)
1151
1152;; Generate a return instruction
1153(decl lower_return (ValueSlice) InstOutput)
1154(rule (lower_return vals)
1155      (let ((_ Unit (gen_return vals)))
1156        (output_none)))
1157
1158(decl gen_return (ValueRegsVec) Unit)
1159(extern constructor gen_return gen_return)
1160
1161(decl gen_call_output (SigRef) ValueRegsVec)
1162(extern constructor gen_call_output gen_call_output)
1163
1164(decl gen_call_args (Sig ValueRegsVec) CallArgList)
1165(extern constructor gen_call_args gen_call_args)
1166
1167(decl gen_return_call_args (Sig ValueRegsVec) CallArgList)
1168(extern constructor gen_return_call_args gen_return_call_args)
1169
1170(decl gen_call_rets (Sig ValueRegsVec) CallRetList)
1171(extern constructor gen_call_rets gen_call_rets)
1172
1173(decl gen_try_call_rets (Sig) CallRetList)
1174(extern constructor gen_try_call_rets gen_try_call_rets)
1175
1176(decl gen_patchable_call_rets () CallRetList)
1177(extern constructor gen_patchable_call_rets gen_patchable_call_rets)
1178
1179(type OptionTryCallInfo (primitive OptionTryCallInfo))
1180(decl try_call_info (ExceptionTable MachLabelSlice) OptionTryCallInfo)
1181(extern constructor try_call_info try_call_info)
1182(decl try_call_none () OptionTryCallInfo)
1183(extern constructor try_call_none try_call_none)
1184
1185;; Helper for extracting an immediate that's not 0 and not -1 from an imm64.
1186 (spec (safe_divisor_from_imm64 t x)
1187       (provide (= (sign_ext 64 x) result))
1188       (require (not (= #x0000000000000000 result))
1189                (not (= #x1111111111111111 result))))
1190(decl pure partial safe_divisor_from_imm64 (Type Imm64) u64)
1191(extern constructor safe_divisor_from_imm64 safe_divisor_from_imm64)
1192
1193;;;; Automatic conversions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1194
1195(convert Inst Value def_inst)
1196(convert Reg ValueRegs value_reg)
1197(convert WritableReg WritableValueRegs writable_value_reg)
1198(convert Value Reg put_in_reg)
1199(convert Value ValueRegs put_in_regs)
1200(convert ValueSlice ValueRegsVec put_in_regs_vec)
1201(convert WritableReg Reg writable_reg_to_reg)
1202(convert ValueRegs InstOutput output)
1203(convert Reg InstOutput output_reg)
1204(convert Value InstOutput output_value)
1205(convert ValueRegsVec InstOutput output_vec)
1206(convert ExternalName BoxExternalName box_external_name)
1207(convert PReg Reg preg_to_reg)
1208