| blob | 1d3f5f6a8239b484afd9ce3fbb8c2e8b711a8ff3 |
1 ;;;; scheduling assembler
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
6 ;;;; This software is derived from the CMU CL system, which was
7 ;;;; written at Carnegie Mellon University and released into the
8 ;;;; public domain. The software is in the public domain and is
9 ;;;; provided with absolutely no warranty. See the COPYING and CREDITS
10 ;;;; files for more information.
13 \f
14 ;;;; assembly control parameters
23 \f
24 ;;;; the SEGMENT structure
26 ;;; This structure holds the state of the assembler.
28 ;; the type of this segment (for debugging output and stuff)
30 ;; Ordinarily this is a vector where instructions are written. If
31 ;; the segment is made invalid (e.g. by APPEND-SEGMENT) then the
32 ;; vector can be replaced by NIL. This used to be an adjustable
33 ;; array, but we now do the array size management manually for
34 ;; performance reasons (as of 2006-05-13 hairy array operations
35 ;; are rather slow compared to simple ones).
38 ;; whether or not to run the scheduler. Note: if the instruction
39 ;; definitions were not compiled with the scheduler turned on, this
40 ;; has no effect.
42 ;; If a function, then this is funcalled for each inst emitted with
43 ;; the segment, the VOP, the name of the inst (as a string), and the
44 ;; inst arguments.
46 ;; what position does this correspond to? Initially, positions and
47 ;; indexes are the same, but after we start collapsing choosers,
48 ;; positions can change while indexes stay the same.
51 ;; a list of all the annotations that have been output to this segment
53 ;; a pointer to the last cons cell in the annotations list. This is
54 ;; so we can quickly add things to the end of the annotations list.
56 ;; the number of bits of alignment at the last time we synchronized
58 ;; the position the last time we synchronized
60 ;; The posn and index everything ends at. This is not maintained
61 ;; while the data is being generated, but is filled in after.
62 ;; Basically, we copy CURRENT-POSN and CURRENT-INDEX so that we can
63 ;; trash them while processing choosers and back-patches.
66 ;; *** State used by the scheduler during instruction queueing.
67 ;;
68 ;; a list of postits. These are accumulated between instructions.
70 ;; ``Number'' for last instruction queued. Used only to supply insts
71 ;; with unique sset-element-number's.
73 ;; SIMPLE-VECTORs mapping locations to the instruction that reads them and
74 ;; instructions that write them
79 ;; The number of additional cycles before the next control transfer,
80 ;; or NIL if a control transfer hasn't been queued. When a delayed
81 ;; branch is queued, this slot is set to the delay count.
83 ;; *** These two slots are used both by the queuing noise and the
84 ;; scheduling noise.
85 ;;
86 ;; All the instructions that are pending and don't have any
87 ;; unresolved dependents. We don't list branches here even if they
88 ;; would otherwise qualify. They are listed above.
90 ;; list of queued branches. We handle these specially, because they
91 ;; have to be emitted at a specific place (e.g. one slot before the
92 ;; end of the block).
94 ;; *** state used by the scheduler during instruction scheduling
95 ;;
96 ;; the instructions who would have had a read dependent removed if
97 ;; it were not for a delay slot. This is a list of lists. Each
98 ;; element in the top level list corresponds to yet another cycle of
99 ;; delay. Each element in the second level lists is a dotted pair,
100 ;; holding the dependency instruction and the dependent to remove.
102 ;; The emittable insts again, except this time as a list sorted by depth.
104 ;; Whether or not to collect dynamic statistics. This is just the same as
105 ;; *COLLECT-DYNAMIC-STATISTICS* but is faster to reference.
106 #!+sb-dyncount
109 type)
118 ;; FIXME: It would be lovely to enforce this, but first FILL-IN will
119 ;; need to be convinced to stop rolling SEGMENT-CURRENT-INDEX
120 ;; backwards.
121 ;;
122 ;; Enforce an observed regularity which makes it easier to think
123 ;; about what's going on in the (legacy) code: The segment never
124 ;; shrinks. -- WHN the reverse engineer
130 ;; Make sure the array is big enough.
134 ;; When we have to increase the size of the array, we want to
135 ;; roughly double the vector length: that way growing the array
136 ;; to size N conses only O(N) bytes in total. But just doubling
137 ;; the length would leave a zero-length vector unchanged. Hence,
138 ;; take the MAX with 1..
144 ;; Now that the array has the intended next free byte, we can point to it.
147 ;;; Various functions (like BACK-PATCH-FUN or CHOOSER-WORST-CASE-FUN)
148 ;;; aren't cleanly parameterized, but instead use
149 ;;; SEGMENT-CURRENT-INDEX and/or SEGMENT-CURRENT-POSN as global
150 ;;; variables. So code which calls such functions needs to modify
151 ;;; SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN. This is left over
152 ;;; from the old new-assem.lisp C-style code, and so all the
153 ;;; destruction happens to be done after other uses of these slots are
154 ;;; done and things basically work. However, (1) it's fundamentally
155 ;;; nasty, and (2) at least one thing doesn't work right: OpenMCL
156 ;;; properly points out that SUBSEQ's indices aren't supposed to
157 ;;; exceed its logical LENGTH, i.e. its FILL-POINTER, i.e.
158 ;;; SEGMENT-CURRENT-INDEX.
159 ;;;
160 ;;; As a quick fix involving minimal modification of legacy code,
161 ;;; we do such sets of SEGMENT-CURRENT-INDEX and SEGMENT-CURRENT-POSN
162 ;;; using this macro, which restores 'em afterwards.
163 ;;;
164 ;;; FIXME: It'd probably be better to cleanly parameterize things like
165 ;;; BACK-PATCH-FUN so we can avoid this nastiness altogether.
179 \f
180 ;;;; structures/types used by the scheduler
182 (!def-boolean-attribute instruction
183 ;; This attribute is set if the scheduler can freely flush this
184 ;; instruction if it thinks it is not needed. Examples are NOP and
185 ;; instructions that have no side effect not described by the
186 ;; writes.
187 flushable
188 ;; This attribute is set when an instruction can cause a control
189 ;; transfer. For test instructions, the delay is used to determine
190 ;; how many instructions follow the branch.
191 branch
192 ;; This attribute indicates that this ``instruction'' can be
193 ;; variable length, and therefore had better never be used in a
194 ;; branch delay slot.
195 variable-length)
202 ;; The function to envoke to actually emit this instruction. Gets called
203 ;; with the segment as its one argument.
205 ;; The attributes of this instruction.
207 ;; Number of instructions or cycles of delay before additional
208 ;; instructions can read our writes.
210 ;; the maximum number of instructions in the longest dependency
211 ;; chain from this instruction to one of the independent
212 ;; instructions. This is used as a heuristic at to which
213 ;; instructions should be scheduled first.
215 ;; Note: When trying remember which of the next four is which, note
216 ;; that the ``read'' or ``write'' always refers to the dependent
217 ;; (second) instruction.
218 ;;
219 ;; instructions whose writes this instruction tries to read
221 ;; instructions whose writes or reads are overwritten by this instruction
223 ;; instructions which write what we read or write
225 ;; instructions which read what we write
231 #!+sb-show-assem
235 stream)
243 name)
248 #!+sb-show-assem
252 \f
253 ;;;; the scheduler itself
257 "Execute BODY (as a PROGN) without scheduling any of the instructions
258 generated inside it. This is not protected by UNWIND-PROTECT, so
259 DO NOT use THROW or RETURN-FROM to escape from it."
260 ;; FIXME: Why not just use UNWIND-PROTECT? Or is there some other
261 ;; reason why we shouldn't use THROW or RETURN-FROM?
269 ,@body
284 "~&~S reads ~S[~W for ~W]~%"
285 inst read loc-num size)
287 ;; Iterate over all the locations for this TN.
294 ;; The inst that wrote the value we want to read must have
295 ;; completed.
300 ;; And it must have been completed *after* all other
301 ;; writes to that location. Actually, that isn't quite
302 ;; true. Each of the earlier writes could be done
303 ;; either before this last write, or after the read, but
304 ;; we have no way of representing that.
310 ;; And we don't need to remember about earlier writes any
311 ;; more. Shortening the writers list means that we won't
312 ;; bother generating as many explicit arcs in the graph.
322 "~&~S writes ~S[~W for ~W]~%"
323 inst write loc-num size)
325 ;; Iterate over all the locations for this TN.
330 ;; All previous reads of this location must have completed.
337 ;; All previous writes to the location must have completed.
342 ;; And we can forget about remembering them, because
343 ;; depending on us is as good as depending on them.
348 ;;; This routine is called by due to uses of the INST macro when the
349 ;;; scheduler is turned on. The change to the dependency graph has
350 ;;; already been computed, so we just have to check to see whether the
351 ;;; basic block is terminated.
355 " reads ~S~% writes ~S~%"
371 variable-length))))
388 ;;; Emit all the pending instructions, and reset any state. This is
389 ;;; called whenever we hit a label (i.e. an entry point of some kind)
390 ;;; and when the user turns the scheduler off (otherwise, the queued
391 ;;; instructions would sit there until the scheduler was turned back
392 ;;; on, and emitted in the wrong place).
396 ;; Quick blow-out if nothing to do.
405 ;; Note that any values live at the end of the block have to be
406 ;; computed last.
420 ;; If the value is live at the end of the block, we can't flush it.
422 nil)))))
424 ;; Grovel through the entire graph in the forward direction finding
425 ;; all the leaf instructions.
440 flushable))
442 "flushing ~S~%"
443 inst)
462 "queued branches: ~S~%"
465 "initially emittable: ~S~%"
468 "initially delayed: ~S~%"
471 ;; Accumulate the results in reverse order. Well, actually, this
472 ;; list will be in forward order, because we are generating the
473 ;; reverse order in reverse.
476 ;; Schedule all the branches in their exact locations.
481 ;; Each time through this loop we need to emit another
482 ;; instruction. First, we check to see whether there is
483 ;; any instruction that must be emitted before (i.e. must
484 ;; come after) the branch inst. If so, emit it. Otherwise,
485 ;; just pick one of the emittable insts. If there is
486 ;; nothing to do, then emit a nop. ### Note: despite the
487 ;; fact that this is a loop, it really won't work for
488 ;; repetitions other than zero and one. For example, if
489 ;; the branch has two dependents and one of them dpends on
490 ;; the other, then the stuff that grabs a dependent could
491 ;; easily grab the wrong one. But I don't feel like fixing
492 ;; this because it doesn't matter for any of the
493 ;; architectures we are using or plan on using.
496 ;; If do-sset-elements enters the body, then there is a
497 ;; dependent. Emit it.
499 ;; Remove it from the emittable insts.
504 ;; And if it was delayed, removed it from the delayed
505 ;; list. This can happen if there is a load in a
506 ;; branch delay slot.
519 ;; And return it.
528 "filling branch delay slot with ~S~%"
529 fill)
538 ;; Keep scheduling stuff until we run out.
546 ;; Now call the emitters, but turn the scheduler off for the duration.
554 ;; Clear out any residue left over.
562 ;; That's all, folks.
565 ;;; a utility for maintaining the segment-delayed list. We cdr down
566 ;;; list n times (extending it if necessary) and then push thing on
567 ;;; into the car of that cons cell.
574 list)))
576 ;;; Find the next instruction to schedule and return it after updating
577 ;;; any dependency information. If we can't do anything useful right
578 ;;; now, but there is more work to be done, return :NOP to indicate
579 ;;; that a nop must be emitted. If we are all done, return NIL.
587 variable-length))
588 ;; We've got us a live one here. Go for it.
590 ;; Delete it from the list of insts.
595 ;; Note that this inst has been emitted.
597 ;; And return.
599 ;; Are we wanting to flush this instruction?
601 ;; Nope, it's still a go. So return it.
602 inst
603 ;; Yes, so pick a new one. We have to start
604 ;; over, because note-resolved-dependencies
605 ;; might have changed the emittable-insts-queue.
607 ;; Nothing to do, so make something up.
609 ;; No emittable instructions, but we have more work to do. Emit
610 ;; a NOP to fill in a delay slot.
614 ;; All done.
615 nil)))
617 ;;; This function is called whenever an instruction has been
618 ;;; scheduled, and we want to know what possibilities that opens up.
619 ;;; So look at all the instructions that this one depends on, and
620 ;;; remove this instruction from their dependents list. If we were the
621 ;;; last dependent, then that dependency can be emitted now.
626 ;; These are the instructions who have to be completed before our
627 ;; write fires. Doesn't matter how far before, just before.
634 ;; These are the instructions who write values we read. If there
635 ;; is no delay, then just remove us from the dependent list.
636 ;; Otherwise, record the fact that in n cycles, we should be
637 ;; removed.
650 ;;; Process the next entry in segment-delayed. This is called whenever
651 ;;; anyone emits an instruction.
665 ;;; Note that inst is emittable by sticking it in the
666 ;;; SEGMENT-EMITTABLE-INSTS-QUEUE list. We keep the emittable-insts
667 ;;; sorted with the largest ``depths'' first. Except that if INST is a
668 ;;; branch, don't bother. It will be handled correctly by the branch
669 ;;; emitting code in SCHEDULE-PENDING-INSTRUCTIONS.
682 \f
683 ;;;; structure used during output emission
685 ;;; a constraint on how the output stream must be aligned
691 ;; the minimum number of low-order bits that must be zero
693 ;; the amount of filler we are assuming this alignment op will take
695 ;; the byte used as filling or :LONG-NOP, indicating to call EMIT-LONG-NOP
696 ;; to emit a filling pattern
700 ;;; a reference to someplace that needs to be back-patched when
701 ;;; we actually know what label positions, etc. are
705 ;; the area affected by this back-patch
707 ;; the function to use to generate the real data
710 ;;; This is similar to a BACK-PATCH, but also an indication that the
711 ;;; amount of stuff output depends on label positions, etc.
712 ;;; BACK-PATCHes can't change their mind about how much stuff to emit,
713 ;;; but CHOOSERs can.
715 (:constructor make-chooser
718 ;; the worst case size for this chooser. There is this much space
719 ;; allocated in the output buffer.
721 ;; the worst case alignment this chooser is guaranteed to preserve
723 ;; the function to call to determine if we can use a shorter
724 ;; sequence. It returns NIL if nothing shorter can be used, or emits
725 ;; that sequence and returns T.
727 ;; the function to call to generate the worst case sequence. This is
728 ;; used when nothing else can be condensed.
731 ;;; This is used internally when we figure out a chooser or alignment
732 ;;; doesn't really need as much space as we initially gave it.
736 ;; the number of bytes of filler here
738 \f
739 ;;;; output functions
741 ;;; interface: Emit the supplied BYTE to SEGMENT, growing SEGMENT if
742 ;;; necessary.
753 ;;; interface: Output AMOUNT bytes to SEGMENT, either copies of
754 ;;; PATTERN (if that is an integer), or by calling EMIT-LONG-NOP
755 ;;; (if PATTERN is :LONG-NOP).
763 ;; EMIT-LONG-NOP does not exist for most backends.
764 ;; Better to get an ECASE error than undefined-function.
765 #!+x86-64
770 ;;; This is used to handle the common parts of annotation emission. We
771 ;;; just assign the POSN and INDEX of NOTE and tack it on to the end
772 ;;; of SEGMENT's annotations list.
788 ;;; Note that the instruction stream has to be back-patched when label
789 ;;; positions are finally known. SIZE bytes are reserved in SEGMENT,
790 ;;; and function will be called with two arguments: the segment and
791 ;;; the position. The function should look at the position and the
792 ;;; position of any labels it wants to and emit the correct sequence.
793 ;;; (And it better be the same size as SIZE). SIZE can be zero, which
794 ;;; is useful if you just want to find out where things ended up.
799 ;;; Note that the instruction stream here depends on the actual
800 ;;; positions of various labels, so can't be output until label
801 ;;; positions are known. Space is made in SEGMENT for at least SIZE
802 ;;; bytes. When all output has been generated, the MAYBE-SHRINK
803 ;;; functions for all choosers are called with three arguments: the
804 ;;; segment, the position, and a magic value. The MAYBE-SHRINK
805 ;;; decides if it can use a shorter sequence, and if so, emits that
806 ;;; sequence to the segment and returns T. If it can't do better than
807 ;;; the worst case, it should return NIL (without emitting anything).
808 ;;; When calling LABEL-POSITION, it should pass it the position and
809 ;;; the magic-value it was passed so that LABEL-POSITION can return
810 ;;; the correct result. If the chooser never decides to use a shorter
811 ;;; sequence, the WORST-CASE-FUN will be called, just like a
812 ;;; BACK-PATCH. (See EMIT-BACK-PATCH.)
821 ;;; This is called in EMIT-CHOOSER and COMPRESS-SEGMENT in order to
822 ;;; recompute the current alignment information in light of this
823 ;;; chooser. If the alignment guaranteed by the chooser is less than
824 ;;; the segment's current alignment, we have to adjust the segment's
825 ;;; notion of the current alignment.
826 ;;;
827 ;;; The hard part is recomputing the sync posn, because it's not just
828 ;;; the chooser's posn. Consider a chooser that emits either one or
829 ;;; three words. It preserves 8-byte (3 bit) alignments, because the
830 ;;; difference between the two choices is 8 bytes.
836 ;; The chooser might change the alignment of the output. So we
837 ;; have to figure out what the worst case alignment could be.
846 ;;; This is used internally whenever a chooser or alignment decides it
847 ;;; doesn't need as much space as it originally thought.
848 ;;; This function used to extend an existing filler instead of creating
849 ;;; a new one when the previous segment annotation was a filler. Now
850 ;;; this is only done if the previous filler is immediately adjacent
851 ;;; to the new one in the segment, too. To see why this restriction is
852 ;;; necessary, consider a jump followed by an alignment made of
853 ;;; multi-byte NOPs when both are shrunk: The shortened alignment is
854 ;;; reemitted at its original _start_ position but the joined filler
855 ;;; would extend over this position and instead leave a subsequence of
856 ;;; the segment up to the alignment's original _end_ position visible.
871 ;;; EMIT-LABEL (the interface) basically just expands into this,
872 ;;; supplying the SEGMENT and VOP.
885 ;;; Called by the EMIT-ALIGNMENT macro to emit an alignment note. We check to
886 ;;; see if we can guarantee the alignment restriction by just outputting a
887 ;;; fixed number of bytes. If so, we do so. Otherwise, we create and emit an
888 ;;; alignment note.
899 ;; We need more bits of alignment. Emit an alignment note.
900 ;; The ALIGNMENT many least significant bits of (- OFFSET)
901 ;; give the amount of bytes to skip to get back in sync with
902 ;; ALIGNMENT, and one-bits to the left of that up to position
903 ;; BITS provide the remaining amount.
913 ;; The last alignment was more restrictive than this one.
914 ;; So we can just figure out how much noise to emit
915 ;; assuming the last alignment was met.
919 ;; But we emit an alignment with size=0 so we can verify
920 ;; that everything works.
924 ;;; This is used to find how ``aligned'' different offsets are.
925 ;;; Returns the number of low-order 0 bits, up to MAX-ALIGNMENT.
931 ;;; Emit a postit. The function will be called as a back-patch with
932 ;;; the position the following instruction is finally emitted. Postits
933 ;;; do not interfere at all with scheduling.
937 \f
938 ;;;; output compression/position assignment stuff
940 ;;; Grovel though all the annotations looking for choosers. When we
941 ;;; find a chooser, invoke the maybe-shrink function. If it returns T,
942 ;;; it output some other byte sequence.
960 posn)
964 ;; It emitted some replacement.
970 note new-size old-size))
975 preserves ~W bits of alignment."
985 ;; The chooser passed on shrinking. Make sure it didn't
986 ;; emit anything.
990 note
993 ;; Act like we just emitted this chooser.
997 ;; Adjust the alignment accordingly.
999 ;; And keep this chooser for next time around.
1003 ;; Re-emit the alignment, letting it collapse if we know
1004 ;; anything more about the alignment guarantees of the
1005 ;; segment.
1017 and is ~W now."
1018 note old-size size))
1034 ;;; We have run all the choosers we can, so now we have to figure out
1035 ;;; exactly how much space each alignment note needs.
1058 posn)
1060 ;; We need to re-emit the alignment because a shorter
1061 ;; multi-byte NOP pattern is most of the time not a
1062 ;; prefix of a longer one.
1077 ;;; Grovel over segment, filling in any backpatches. If any choosers
1078 ;;; are left over, we need to emit their worst case variant.
1094 note new-size old-size)))
1109 ;;; Replace the SEGMENT-BUFFER of SEGMENT with a vector that contains
1110 ;;; only the valid content of the original buffer, that is, the parts
1111 ;;; not covered by fillers. Set FINAL-INDEX of SEGMENT to the length
1112 ;;; of the new vector and return this length.
1135 \f
1136 ;;;; interface to the rest of the compiler
1138 ;;; This holds the current segment while assembling. Use ASSEMBLE to
1139 ;;; change it.
1140 ;;;
1141 ;;; The double asterisks in the name are intended to suggest that this
1142 ;;; isn't just any old special variable, it's an extra-special
1143 ;;; variable, because sometimes MACROLET is used to bind it. So be
1144 ;;; careful out there..
1145 ;;;
1146 ;;; (This used to be called **CURRENT-SEGMENT** in SBCL until 0.7.3,
1147 ;;; and just *CURRENT-SEGMENT* in CMU CL. In both cases, the rebinding
1148 ;;; now done with MACROLET was done with SYMBOL-MACROLET instead. The
1149 ;;; rename-with-double-asterisks was because the SYMBOL-MACROLET made
1150 ;;; it an extra-special variable. The change over to
1151 ;;; %%CURRENT-SEGMENT%% was because ANSI forbids the use of
1152 ;;; SYMBOL-MACROLET on special variable names, and CLISP correctly
1153 ;;; complains about this when being used as a bootstrap host.)
1157 ;;; Just like %%CURRENT-SEGMENT%%, except this holds the current vop.
1158 ;;; This is used only to keep track of which vops emit which insts.
1159 ;;;
1160 ;;; The double asterisks in the name are intended to suggest that this
1161 ;;; isn't just any old special variable, it's an extra-special
1162 ;;; variable, because sometimes MACROLET is used to bind it. So be
1163 ;;; careful out there..
1167 ;;; We also MACROLET %%CURRENT-SEGMENT%% to a local holding the
1168 ;;; segment so uses of %%CURRENT-SEGMENT%% inside the body don't have
1169 ;;; to keep dereferencing the symbol. Given that ASSEMBLE is the only
1170 ;;; interface to **CURRENT-SEGMENT**, we don't have to worry about the
1171 ;;; special value becoming out of sync with the lexical value. Unless
1172 ;;; some bozo closes over it, but nobody does anything like that...
1175 "Execute BODY (as a progn) with SEGMENT as the current segment."
1189 inherited-labels))
1193 visible-labels)
1206 new-labels))
1208 ;; Must be done so that contribs and user code doing
1209 ;; low-level stuff don't need to worry about this.
1213 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1214 ;; can't deal with this declaration, so disable it on host.
1215 ;; Ditto for later ENABLE-PACKAGE-LOCKS %%C-S%% declaration.
1216 #-sb-xc-host
1223 form))
1224 body)))))))
1232 "Emit the specified instruction to the current segment."
1245 ;;; Note: The need to capture MACROLET bindings of %%CURRENT-SEGMENT%%
1246 ;;; and %%CURRENT-VOP%% prevents this from being an ordinary function.
1248 "Emit LABEL at this location in the current segment."
1251 ;;; Note: The need to capture MACROLET bindings of
1252 ;;; %%CURRENT-SEGMENT%% prevents this from being an ordinary function.
1256 ;;; Note: The need to capture SYMBOL-MACROLET bindings of
1257 ;;; **CURRENT-SEGMENT* and (%%CURRENT-VOP%%) prevents this from being an
1258 ;;; ordinary function.
1260 "Emit an alignment restriction to the current segment."
1264 "Return the current position for LABEL. Chooser maybe-shrink functions
1265 should supply IF-AFTER and DELTA in order to ensure correct results."
1269 posn)))
1272 "Append OTHER-SEGMENT to the end of SEGMENT. Don't use OTHER-SEGMENT
1273 for anything after this."
1300 ;; This SEGMENT-LAST-ANNOTATION code is confusing. Is it really
1301 ;; worth enough in efficiency to justify it? -- WHN 19990322
1311 "Do any final processing of SEGMENT and return the total number of bytes
1312 covered by this segment."
1328 ;;; Return the contents of SEGMENT as a vector. We assume SEGMENT has
1329 ;;; been finalized so that we can simply return its buffer.
1335 ;;; Write the code accumulated in SEGMENT to STREAM, and return the
1336 ;;; number of bytes written. We assume that SEGMENT has been finalized.
1343 \f
1344 ;;;; interface to the instruction set definition
1346 ;;; Define a function named NAME that merges its arguments into a
1347 ;;; single integer and then emits the bytes of that integer in the
1348 ;;; correct order based on the endianness of the target-backend.
1357 total-bits assembly-unit-bits))
1358 quo))
1368 extends past the end."
1369 byte-spec-expr))
1378 assembly-unit-bits)))
1381 expr
1387 offset)
1393 offset)
1401 offset))
1405 assembly-unit-bits)))
1408 assembly-unit-bits
1409 len)
1412 offset))
1425 forms)))
1433 ;;; Return a list of forms involving VALUES that will pass the arguments from
1434 ;;; LAMBA-LIST by way of MULTIPLE-VALUE-CALL. Secondary value is the augmented
1435 ;;; lambda-list which has a supplied-p var for every &OPTIONAL and &KEY arg.
1447 new-spec)))
1453 optional))
1462 var
1465 keys))))
1491 (:emitter
1495 (:declare
1497 (:attributes
1499 (:cost
1501 (:dependencies
1503 (:delay
1507 (:pinned
1509 (:vop-var
1513 (:printer
1520 operands))
1531 emitter)
1534 emitter)
1536 #!+sb-dyncount
1546 emitter)
1563 #',flet-name
1582 ;; Must be done so that contribs and user code doing
1583 ;; low-level stuff don't need to worry about this.
1589 ;; KLUDGE: Some host lisps (CMUCL 18e Sparc at least)
1590 ;; can't deal with this declaration, so disable it on host
1591 ;; Ditto for earlier ENABLE-PACKAGE-LOCKS %%C-S%% %%C-V%%
1592 ;; declaration.
1593 #-sb-xc-host