| blob | 6a1d4dc04e8049fdff0a5377789fea5331dc556c |
2 /*--------------------------------------------------------------------*/
3 /*--- begin guest_generic_bb_to_IR.c ---*/
4 /*--------------------------------------------------------------------*/
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
10 Copyright (C) 2004-2017 OpenWorks LLP
11 info@open-works.net
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation; either version 2 of the
16 License, or (at your option) any later version.
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, see <http://www.gnu.org/licenses/>.
26 The GNU General Public License is contained in the file COPYING.
28 Neither the names of the U.S. Department of Energy nor the
29 University of California nor the names of its contributors may be
30 used to endorse or promote products derived from this software
31 without prior written permission.
32 */
43 /*--------------------------------------------------------------*/
44 /*--- Forwards for fns called by self-checking translations ---*/
45 /*--------------------------------------------------------------*/
47 /* Forwards .. */
49 HWord n_w32s );
64 HWord n_w64s );
79 /*--------------------------------------------------------------*/
80 /*--- Creation of self-check IR ---*/
81 /*--------------------------------------------------------------*/
98 const Addr guest_IP_sbstart
99 )
100 {
101 /* The scheme is to compute a rather crude checksum of the code
102 we're making a translation of, and add to the IR a call to a
103 helper routine which recomputes the checksum every time the
104 translation is run, and requests a retranslation if it doesn't
105 match. This is obviously very expensive and considerable
106 efforts are made to speed it up:
108 * the checksum is computed from all the naturally aligned
109 host-sized words that overlap the translated code. That means
110 it could depend on up to 7 bytes before and 7 bytes after
111 which aren't part of the translated area, and so if those
112 change then we'll unnecessarily have to discard and
113 retranslate. This seems like a pretty remote possibility and
114 it seems as if the benefit of not having to deal with the ends
115 of the range at byte precision far outweigh any possible extra
116 translations needed.
118 * there's a generic routine and 12 specialised cases, which
119 handle the cases of 1 through 12-word lengths respectively.
120 They seem to cover about 90% of the cases that occur in
121 practice.
123 We ask the caller, via needs_self_check, which of the 3 vge
124 extents needs a check, and only generate check code for those
125 that do.
126 */
127 {
128 Addr base2check;
129 UInt len2check;
130 HWord expectedhW;
141 UInt extents_needing_check
150 /* Caller shouldn't claim that nonexistent extents need a
151 check. */
154 /* Guest addresses as IRConsts. Used in self-checks to specify the
155 restart-after-discard point. */
156 IRConst* guest_IP_sbstart_IRConst
167 /* Do we need to generate a check for this extent? */
171 /* Tell the caller */
174 /* the extent we're generating a check for */
178 /* stay sane */
181 /* Skip the check if the translation involved zero bytes */
196 /* vex_printf("%lx %lx %ld\n", first_hW, last_hW, hWs_to_check); */
200 genericg_compute_checksum_8al;
204 genericg_compute_checksum_4al;
206 }
240 }
272 }
275 }
278 /* If we got a specialised version, check it produces the same
279 result as the generic version! */
285 }
287 /* Set CMSTART and CMLEN. These will describe to the despatcher
288 the area of guest code to invalidate should we exit with a
289 self-check failure. */
293 IRConst* base2check_IRConst
296 IRConst* len2check_IRConst
320 /* Generate the entry point descriptors */
329 }
336 }
337 }
339 /* Generate the call to the relevant function, and the comparison of
340 the result against the expected value. */
348 )
349 );
357 )
358 );
359 }
366 exitguard_tmp,
370 host_word_type==Ity_I64
376 Ijk_InvalICache,
377 /* Where we must restart if there's a failure: at the
378 first extent, regardless of which extent the failure
379 actually happened in. */
380 guest_IP_sbstart_IRConst,
381 offB_GUEST_IP
382 );
401 }
402 }
403 }
406 /*--------------------------------------------------------------*/
407 /*--- To do with guarding (conditionalisation) of IRStmts ---*/
408 /*--------------------------------------------------------------*/
410 // Is it possible to guard |e|? Meaning, is it safe (exception-free) to compute
411 // |e| and ignore the result? Since |e| is by definition otherwise
412 // side-effect-free, we don't have to ask about any other effects caused by
413 // first computing |e| and then ignoring the result.
415 {
434 }
435 }
437 // Is it possible to guard |st|? Meaning, is it possible to replace |st| by
438 // some other sequence of IRStmts which have the same effect on the architected
439 // state when the guard is true, but when it is false, have no effect on the
440 // architected state and are guaranteed not to cause any exceptions?
441 //
442 // Note that this isn't as aggressive as it could be: it sometimes returns False
443 // in cases where |st| is actually guardable. This routine must coordinate
444 // closely with add_guarded_stmt_to_end_of below, in the sense that that routine
445 // must be able to handle any |st| for which this routine returns True.
447 {
449 // These are easily guarded.
454 // These are definitely not guardable, or at least it's way too much
455 // hassle to do so.
460 // These could be guarded, with some effort, if really needed, but
461 // currently aren't guardable.
466 // This is probably guardable, but it depends on the RHS of the
467 // assignment.
473 }
474 }
476 // Are all stmts (but not the end dst value) in |bb| guardable, per
477 // stmt_is_guardable?
479 {
482 i--;
484 i--;
488 }
490 }
492 // Guard |st| with |guard| and add it to |bb|. This must be able to handle any
493 // |st| for which stmt_is_guardable returns True.
496 {
504 // Put(offs, e) ==> Put(offs, ITE(guard, e, Get(offs, sizeof(e))))
505 // Which when flattened out is:
506 // t1 = Get(offs, sizeof(e))
507 // t2 = ITE(guard, e, t2)
508 // Put(offs, t2)
519 }
521 // Exit(xguard, dst, jk, offsIP)
522 // ==> t1 = And1(xguard, guard)
523 // Exit(t1, dst, jk, offsIP)
531 }
535 }
536 }
539 /*--------------------------------------------------------------*/
540 /*--- Analysis of block ends ---*/
541 /*--------------------------------------------------------------*/
543 typedef
547 Be_Cond // Conditional branch to known destinations, unassisted
548 }
549 BlockEndTag;
551 typedef
553 BlockEndTag tag;
558 Long delta;
561 IRTemp condSX;
562 Long deltaSX;
563 Long deltaFT;
566 }
567 BlockEnd;
570 {
586 }
587 }
589 // Return True if |be| definitely does not jump to |delta|. In case of
590 // doubt, returns False.
592 {
602 }
603 }
606 {
616 }
617 }
625 {
630 // Extract the destination guest address.
633 // Check we're allowed to chase into it.
638 // Either |delta_as_Addr| is a 64-bit value, in which case copy it directly
639 // to |delta|, or it's a 32 bit value, in which case sign extend it.
642 }
645 {
651 }
653 /* Scan |stmts|, starting at |scan_start| and working backwards, to detect the
654 case where there are no IRStmt_Exits before we find the IMark. In other
655 words, it scans backwards through some prefix of an instruction's IR to see
656 if there is an exit there.
658 It also checks for explicit PUTs to the PC, via Ist_Put, Ist_PutI or
659 Ist_Dirty. I suspect this is ridiculous overkill, but is here for safety. */
664 )
665 {
674 // We're back at the start of the insn. Stop searching.
676 }
680 }
687 }
688 }
697 }
698 }
714 }
715 }
716 }
717 }
720 }
721 }
722 i--;
723 }
724 // We expect IR for all instructions to start with an IMark.
727 }
734 Int offB_GUEST_IP,
735 Int szB_GUEST_IP,
736 Bool debug_print )
737 {
740 // -- Conditional branch to known destination
741 /* In short, detect the following end form:
742 ------ IMark(0x4002009, 2, 0) ------
743 // Zero or more non-exit statements
744 if (t14) { PUT(184) = 0x4002040:I64; exit-Boring }
745 PUT(184) = 0x400200B:I64; exit-Boring
746 Checks:
747 - Both transfers are 'boring'
748 - Both dsts are constants
749 - The cond is non-constant (an IRExpr_Tmp)
750 - There are no other exits in this instruction
751 - The client allows chasing into both destinations
752 */
768 Bool ok_SX
772 Bool ok_FT
782 }
783 }
784 }
786 // -- Unconditional branch/call to known destination
787 /* Four checks:
788 - The transfer is 'boring' or 'call', so that no assistance is needed
789 - The dst is a constant (known at jit time)
790 - There are no other exits in this instruction. In other words, the
791 transfer is unconditional.
792 - The client allows chasing into the destination.
793 */
799 // We've got the right pattern. Check whether we can chase into the
800 // destination, and if so convert that to a delta value.
803 // This call also checks the type of the dst addr, and that the client
804 // allows chasing into it.
812 }
813 }
814 }
816 // Not identified as anything of interest to us.
819 out:
824 }
825 }
828 /*--------------------------------------------------------------*/
829 /*--- Disassembly of basic (not super) blocks ---*/
830 /*--------------------------------------------------------------*/
832 /* Disassemble instructions, starting at |&guest_code[delta_IN]|, into |irbb|,
833 and terminate the block properly. At most |n_instrs_allowed_IN| may be
834 disassembled, and this function may choose to disassemble fewer.
836 Also do minimal simplifications on the resulting block, so as to convert the
837 end of the block into something that |analyse_block_end| can reliably
838 recognise.
840 |irbb| will both be modified, and replaced by a new, simplified version,
841 which is returned.
842 */
861 const Int offB_GUEST_IP
862 )
863 {
864 /* This is the max instrs we allow in the block. It starts off at
865 |n_instrs_allowed_IN| but we may choose to reduce it in the case where the
866 instruction disassembler returns an 'is verbose' hint. This is so as to
867 ensure that the JIT doesn't run out of space. See bug 375839 for a
868 motivating example. */
870 /* Process instructions. */
882 /* This is the IP of the instruction we're just about to deal
883 with. */
886 /* This is the irbb statement array index of the first stmt in
887 this insn. That will always be the instruction-mark
888 descriptor. */
891 /* Add an instruction-mark statement. We won't know until after
892 disassembling the instruction how long it instruction is, so
893 just put in a zero length and we'll fix it up later.
895 On ARM, the least significant bit of the instr address
896 distinguishes ARM vs Thumb instructions. All instructions
897 actually start on at least 2-aligned addresses. So we need
898 to ignore the bottom bit of the insn address when forming the
899 IMark's address field, but put that bottom bit in the delta
900 field, so that comparisons against guest_R15T for Thumb can
901 be done correctly. By inspecting the delta field,
902 instruction processors can determine whether the instruction
903 was originally Thumb or ARM. For more details of this
904 convention, see comments on definition of guest_R15T in
905 libvex_guest_arm.h. */
907 /* Thumb insn => mask out the T bit, but put it in delta */
912 )
913 );
915 /* All other targets: store IP as-is, and set delta to zero. */
920 )
921 );
922 }
927 /* Finally, actually disassemble an instruction. */
929 DisResult dres
934 /* stay sane ... */
936 /* ... disassembled insn length is sane ... */
939 /* If the disassembly function passed us a hint, take note of it. */
941 /* Do nothing */
944 /* The current insn is known to be verbose. Lower the max insns limit
945 if necessary so as to avoid running the JIT out of space in the
946 event that we've encountered the start of a long sequence of them.
947 This is expected to be a very rare event. In any case the remaining
948 limit (in the default setting, 30 insns) is still so high that most
949 blocks will terminate anyway before then. So this is very unlikely
950 to give a perf hit in practice. See bug 375839 for the motivating
951 example. */
954 // Halve the number of allowed insns, but only above 2
957 //vassert(*n_instrs <= n_instrs_allowed);
958 }
959 }
960 }
962 /* Fill in the insn-mark length field. */
970 /* Print the resulting IR, if needed. */
976 }
977 }
979 /* Individual insn disassembly may not mess with irbb->next.
980 This function is the only place where it can be set. */
985 /* Individual insn disassembly must finish the IR for each
986 instruction with an assignment to the guest PC. */
988 /* it follows that irbb->stmts_used must be > 0 */
993 /* Really we should also check that the type of the Put'd data
994 == guest_word_type, but that's a bit expensive. */
995 }
997 /* Update the extents entry that we are constructing. */
998 /* If vex_control.guest_max_insns is required to be < 100 and
999 each insn is at max 20 bytes long, this limit of 5000 then
1000 seems reasonable since the max possible extent length will be
1001 100 * 20 == 2000. */
1006 /* Advance delta (inconspicuous but very important :-) */
1014 /* We have to stop. See comment above re irbb field
1015 settings here. */
1017 /* irbb->jumpkind must already by Ijk_Boring */
1020 }
1024 /* See comment above re irbb field settings here. */
1032 }
1038 /* irbb->next must now be set, since we've finished the block.
1039 Print it if necessary.*/
1049 }
1051 /* And clean it up. */
1055 }
1058 }
1061 /*--------------------------------------------------------------*/
1062 /*--- Disassembly of traces: helper functions ---*/
1063 /*--------------------------------------------------------------*/
1065 // Swap the side exit and fall through exit for |bb|. Update |be| so as to be
1066 // consistent.
1068 {
1077 // We need to insert a new stmt, just before the exit, that computes 'Not1'
1078 // of the guard condition. Replace |bb->stmts[bb->stmts_used - 1]| by the
1079 // new stmt, and then place |exit| immediately after it.
1088 // Swap the actual destination constants.
1092 }
1094 // And update |be|.
1099 }
1100 }
1107 {
1118 // Adjust *instrs_avail so that, when it becomes zero, we haven't used
1119 // more than 50% of vex_control.guest_max_instrs.
1124 }
1126 }
1128 // Subtract bb_instrs_used from *instrs_avail, clamping at 0 if necessary.
1133 }
1136 }
1138 // Add the extent [base, +len) to |vge|. Asserts if |vge| is already full.
1139 // As an optimisation only, tries to also merge the new extent with the
1140 // previous one, if possible.
1142 {
1150 // Try to merge with the previous extent
1157 //vex_printf("MERGE\n");
1158 }
1159 }
1162 /*--------------------------------------------------------------*/
1163 /*--- Disassembly of traces: main function ---*/
1164 /*--------------------------------------------------------------*/
1166 /* Disassemble a complete basic block, starting at guest_IP_start,
1167 returning a new IRSB. The disassembler may chase across basic
1168 block boundaries if it wishes and if chase_into_ok allows it.
1169 The precise guest address ranges from which code has been taken
1170 are written into vge. guest_IP_sbstart is taken to be the IP in
1171 the guest's address space corresponding to the instruction at
1172 &guest_code[0].
1174 dis_instr_fn is the arch-specific fn to disassemble on function; it
1175 is this that does the real work.
1177 needs_self_check is a callback used to ask the caller which of the
1178 extents, if any, a self check is required for. The returned value
1179 is a bitmask with a 1 in position i indicating that the i'th extent
1180 needs a check. Since there can be at most 3 extents, the returned
1181 values must be between 0 and 7.
1183 The number of extents which did get a self check (0 to 3) is put in
1184 n_sc_extents. The caller already knows this because it told us
1185 which extents to add checks for, via the needs_self_check callback,
1186 but we ship the number back out here for the caller's convenience.
1188 preamble_function is a callback which allows the caller to add
1189 its own IR preamble (following the self-check, if any). May be
1190 NULL. If non-NULL, the IRSB under construction is handed to
1191 this function, which presumably adds IR statements to it. The
1192 callback may optionally complete the block and direct bb_to_IR
1193 not to disassemble any instructions into it; this is indicated
1194 by the callback returning True.
1196 offB_CMADDR and offB_CMLEN are the offsets of guest_CMADDR and
1197 guest_CMLEN. Since this routine has to work for any guest state,
1198 without knowing what it is, those offsets have to passed in.
1200 callback_opaque is a caller-supplied pointer to data which the
1201 callbacks may want to see. Vex has no idea what it is.
1202 (In fact it's a VgInstrumentClosure.)
1203 */
1205 /* Regarding IP updating. dis_instr_fn (that does the guest specific
1206 work of disassembling an individual instruction) must finish the
1207 resulting IR with "PUT(guest_IP) = ". Hence in all cases it must
1208 state the next instruction address.
1210 If the block is to be ended at that point, then this routine
1211 (bb_to_IR) will set up the next/jumpkind/offsIP fields so as to
1212 make a transfer (of the right kind) to "GET(guest_IP)". Hence if
1213 dis_instr_fn generates incorrect IP updates we will see it
1214 immediately (due to jumping to the wrong next guest address).
1216 However it is also necessary to set this up so it can be optimised
1217 nicely. The IRSB exit is defined to update the guest IP, so that
1218 chaining works -- since the chain_me stubs expect the chain-to
1219 address to be in the guest state. Hence what the IRSB next fields
1220 will contain initially is (implicitly)
1222 PUT(guest_IP) [implicitly] = GET(guest_IP) [explicit expr on ::next]
1224 which looks pretty strange at first. Eg so unconditional branch
1225 to some address 0x123456 looks like this:
1227 PUT(guest_IP) = 0x123456; // dis_instr_fn generates this
1228 // the exit
1229 PUT(guest_IP) [implicitly] = GET(guest_IP); exit-Boring
1231 after redundant-GET and -PUT removal by iropt, we get what we want:
1233 // the exit
1234 PUT(guest_IP) [implicitly] = 0x123456; exit-Boring
1236 This makes the IRSB-end case the same as the side-exit case: update
1237 IP, then transfer. There is no redundancy of representation for
1238 the destination, and we use the destination specified by
1239 dis_instr_fn, so any errors it makes show up sooner.
1240 */
1266 /*IN*/ Int szB_GUEST_IP
1267 )
1268 {
1271 /* check sanity .. */
1284 }
1286 /* Initialise all return-by-ref state. */
1293 /* And a new IR superblock to dump the result into. */
1296 /* Leave 21 spaces in which to put the check statements for a self
1297 checking translation (up to 3 extents, and 7 stmts required for
1298 each). We won't know until later the extents and checksums of
1299 the areas, if any, that need to be checked. */
1305 /* If the caller supplied a function to add its own preamble, use
1306 it now. */
1310 /* The callback has completed the IR block without any guest
1311 insns being disassembled into it, so just return it at
1312 this point, even if a self-check was requested - as there
1313 is nothing to self-check. The 21 self-check no-ops will
1314 still be in place, but they are harmless. */
1319 }
1320 }
1322 /* Running state:
1323 irsb the SB we are incrementally constructing
1324 vge associated extents for irsb
1325 instrs_used instrs incorporated in irsb so far
1326 instrs_avail number of instrs we have space for
1327 verbose_mode did we see an 'is verbose' hint at some point?
1328 */
1333 /* Disassemble the initial block until we have to stop. */
1334 {
1346 );
1349 // Update instrs_used, extents, budget.
1354 }
1356 /* Now, see if we can extend the initial block. */
1361 // Reasons to give up immediately:
1362 // User or tool asked us not to chase
1366 // Out of extent slots
1371 // Almost out of available instructions
1376 // Try for an extend. What kind we do depends on how the current trace
1377 // ends.
1378 /* Regarding the use of |sigill_diag| in the extension logic below. This
1379 is a Bool which controls whether or not the individual insn
1380 disassemblers print an error message in the case where they don't
1381 recognise an instruction. Generally speaking this is set to True, but
1382 VEX's client can set it to False if it wants.
1384 Now that we are speculatively chasing both arms of a conditional
1385 branch, this can lead to the following problem: one of those arms
1386 contains an undecodable instruction. That insn is not reached at run
1387 time, because the branch itself tests some CPU hwcaps info (or
1388 whatever) and execution goes down the other path. However, it has the
1389 bad side effect that the speculative disassembly will nevertheless
1390 produce an error message when |sigill_diag| is True.
1392 To avoid this, in calls to |disassemble_basic_block_till_stop| for
1393 speculative code, we pass False instead of |sigill_diag|. Note that
1394 any (unconditional-chase) call to |disassemble_basic_block_till_stop|
1395 that happens after a conditional chase that results in recovery of an
1396 &&-idiom, is still really non-speculative, because the &&-idiom
1397 translation can only happen when both paths lead to the same
1398 continuation point. The result is that we know that the initial BB,
1399 and BBs recovered via chasing an unconditional branch, are sure to be
1400 executed, even if that unconditional branch follows a conditional
1401 branch which got folded into an &&-idiom. So we don't need to change
1402 the |sigill_diag| value used for them. It's only for the
1403 conditional-branch SX and FT disassembly that it must be set to
1404 |False|.
1405 */
1406 BlockEnd irsb_be;
1411 // Try for an extend based on an unconditional branch or call to a known
1412 // destination.
1419 }
1424 IRSB* bb
1432 );
1435 /* Now we have to append 'bb' to 'irsb'. */
1438 // Update instrs_used, extents, budget.
1446 // Try for an extend based on a conditional branch, specifically in the
1447 // hope of identifying and recovering, an "A && B" condition spread across
1448 // two basic blocks.
1456 }
1461 }
1466 IRSB* sx_bb
1475 );
1477 BlockEnd sx_be;
1484 }
1489 IRSB* ft_bb
1498 );
1500 BlockEnd ft_be;
1505 /* In order for the transformation to be remotely valid, we need:
1506 - At least one of the sx_bb or ft_bb to be have a Be_Cond end.
1507 - sx_bb and ft_bb definitely don't form a loop.
1508 */
1515 }
1517 // Check for other mutancy:
1518 // irsb ft == sx, or the same for ft itself or sx itself
1526 }
1527 }
1529 /* Now let's see if any of our four cases actually holds (viz, is this
1530 really an && idiom? */
1540 }
1547 }
1549 /* We should only have identified at most one of the four idioms. */
1557 }
1558 }
1559 }
1563 // "Normalise" the data so as to ensure we only have one of the four
1564 // idioms to transform.
1567 # define SWAP(_ty, _aa, _bb) \
1568 do { _ty _tmp = _aa; _aa = _bb; _bb = _tmp; } while (0)
1575 # undef SWAP
1576 }
1579 }
1592 }
1593 // Finally, check the sx block actually is guardable.
1597 }
1598 }
1603 }
1604 // Finally really actually do the transformation.
1605 // 0. remove the last Exit on irsb.
1606 // 1. Add irsb->tyenv->types_used to all the tmps in sx_bb,
1607 // by calling deltaIRStmt on all stmts.
1608 // 2. Guard all stmts in sx_bb on irsb_be.Be.Cond.condSX,
1609 // **including** the last stmt (which must be an Exit). It's
1610 // here that the And1 is generated.
1611 // 3. Copy all guarded stmts to the end of irsb.
1616 // Append sx_bb's tyenv to irsb's
1619 }
1625 }
1631 }
1633 // Update instrs_used, extents, budget.
1639 }
1643 // We don't know any other way to extend the block. Give up.
1646 }
1650 /* We're almost done. The only thing that might need attending to is that
1651 a self-checking preamble may need to be created. If so it gets placed
1652 in the 21 slots reserved above. */
1657 );
1661 }
1664 /*--------------------------------------------------------------*/
1665 /*--- Functions called by self-checking transations ---*/
1666 /*--------------------------------------------------------------*/
1668 /* All of these are CLEAN HELPERs */
1669 /* All of these are CALLED FROM GENERATED CODE */
1671 /* Compute a checksum of host memory at [addr .. addr+len-1], as fast
1672 as possible. All _4al versions assume that the supplied address is
1673 4 aligned. All length values are in 4-byte chunks. These fns
1674 arecalled once for every use of a self-checking translation, so
1675 they needs to be as fast as possible. */
1677 /* --- 32-bit versions, used only on 32-bit hosts --- */
1682 }
1686 {
1689 /* unrolled */
1691 UInt w;
1699 }
1701 UInt w;
1706 }
1708 }
1710 /* Specialised versions of the above function */
1714 {
1717 UInt w;
1721 }
1725 {
1728 UInt w;
1734 }
1738 {
1741 UInt w;
1749 }
1753 {
1756 UInt w;
1763 }
1767 {
1770 UInt w;
1779 }
1783 {
1786 UInt w;
1797 }
1801 {
1804 UInt w;
1817 }
1821 {
1824 UInt w;
1836 }
1840 {
1843 UInt w;
1857 }
1861 {
1864 UInt w;
1880 }
1884 {
1887 UInt w;
1905 }
1909 {
1912 UInt w;
1929 }
1932 /* --- 64-bit versions, used only on 64-bit hosts --- */
1937 }
1941 {
1944 /* unrolled */
1946 ULong w;
1954 }
1956 ULong w;
1961 }
1963 }
1965 /* Specialised versions of the above function */
1969 {
1972 ULong w;
1976 }
1980 {
1983 ULong w;
1989 }
1993 {
1996 ULong w;
2004 }
2008 {
2011 ULong w;
2018 }
2022 {
2025 ULong w;
2034 }
2038 {
2041 ULong w;
2052 }
2056 {
2059 ULong w;
2072 }
2076 {
2079 ULong w;
2091 }
2095 {
2098 ULong w;
2112 }
2116 {
2119 ULong w;
2135 }
2139 {
2142 ULong w;
2160 }
2164 {
2167 ULong w;
2184 }
2186 /*--------------------------------------------------------------------*/
2187 /*--- end guest_generic_bb_to_IR.c ---*/
2188 /*--------------------------------------------------------------------*/