gdb/gdb/s390-tdep.c

10    This program is free software; you can redistribute it and/or modify
208 /* Pseudo registers - PC and condition code.  */
463    by SECT_NAME and SECT_SIZE.  */
512       xr r1, r3      # exclusive-or r1 and r3, place result in r1
521    simulate, you stop.  Now you examine the state of the registers and
528      something too complex for us to track, and we don't know the
536    quick-and-simple pattern patching to recognize a few fixed prologue
541    understand and maintain.  In the approach used here:
548      instructions, and know that you haven't broken anything that
568        been too complex and we don't want to bother.  The bottom of
618 /* If one of *A and *B is a constant, and the other isn't, swap the
636 /* Set SUM to the sum of A and B.  SUM, A, and B may point to the same
645   /* We can handle adding constants to registers, and other constants.  */
670   /* Rather than thinking of all the cases we can and can't handle,
677 /* Subtract B from A, and put the result in DIFF.
679    This isn't quite the same as negating B and adding it to A, since
722 /* Set AND to the logical and of A and B.  */
724 pv_logical_and (struct prologue_value *and,
730   /* We can 'and' two constants.  */
734       and->kind = pv_constant;
735       and->k = a->k & b->k;
738   /* We can 'and' anything with the constant zero.  */
742       and->kind = pv_constant;
743       and->k = 0;
746   /* We can 'and' anything with ~0.  */
749     *and = *a;
751   /* We can 'and' a register with itself.  */
756     *and = *a;
760     pv_set_to_unknown (and);
764 /* Return non-zero iff A and B are identical expressions.
767    result of such a comparison would have to be a pv_boolean, and
769    pv_maybe.  Same for comparing, say, { pv_register, R1, 0 } and {
814    an element of an array.  The array starts at ARRAY_ADDR, and has
817    element in the array, and return pv_definite_yes.  If it definitely
833   /* Note that, since ->k is a CORE_ADDR, and CORE_ADDR is unsigned,
868    op1_* and op2_* enums.  */
937 /* The functions below are for recognizing and decoding S/390
941    instruction's fields, and returns a non-zero value; otherwise, it
947    instructions.  And displacements appear before base and extension
1093    Here, X2 and B2 are registers, and D2 is a signed 20-bit
1119 /* The number of GPR and FPR spill slots in an S/390 stack frame.  We
1120    track general-purpose registers r2 -- r15, and floating-point
1121    registers f0, f2, f4, and f6.  */
1139      general-purpose registers r2 through r15, and floating-point
1152    return pv_definite_yes and set *STACK to point to the slot.  If
1156    DATA describes our current state (registers and stack slots).  */
1169   /* Construct the addresses of the spill arrays and the back chain.  */
1174   /* We have to check for GPR and FPR references using two separate
1175      calls to pv_is_array_ref, since the GPR and FPR spill slots are
1236      are save areas private to compiler, and never directly exposed to
1253      executed it creating the current frame, and the time when
1284    and stack slots.  Return the address of the instruction after
1340       /* The values of SP, FP, and back chain before this instruction,
1605       /* NR r1, r2 --- logical and */
1610       /* NGR r1, r2 >--- logical and (64-bit version) */
1627       /* BASR r1, 0 --- branch and save
1633       /* BRAS r1, i2 --- branch relative and save */
1703   /* In frameless functions, there's not frame to destroy and thus
1708      return register %r14 and the stack pointer %r15, followed
1716      preceeding pc and check whether it is an LM-type instruction
1820 	     call, and we have stopped in the prologue *before* the
1867   /* Once we know the frame register and the frame size, we can unwind
1868      the current value of the frame register from the next frame, and
1915      we should have found spill slots for SP and PC.
1926      and the top of the register save area as frame_base.  */
1960          to be at least %r14 and %r15.  This will allow us to continue
1969          and the top of the register save area as frame_base.  */
2040 /* Code stubs and their stack frames.  For things like PLTs and NULL
2041    function calls (where there is no true frame and the return address
2069   /* Retrieve stack pointer and determine our frame base.  */
2159   /* Old-style RT frame and all non-RT frames:
2361    integers are: integers, enums, ranges, characters, and booleans.  */
2376    pointers are: pointers and references.  */
2398    ... and so on.
2420    structs and unions.
2422    As an odd quirk, not mentioned in the ABI, GCC passes float and
2441    But as an odd quirk, not mentioned in the ABI, GCC passes float and
2468   /* FIXME: All complex and vector types are also returned by reference.  */
2558    padding, etc. whereever they belong, and return the new stack
2646 	    /* The GNU/Linux for S/390 ABI uses FPRs 0 and 2 to pass arguments,
2647 	       the GNU/Linux for zSeries ABI uses 0, 2, 4, and 6.  */
2694 		   in it, then don't go back and use it again later.  */
2708      and the back chain pointer.  */
2730    returned by push_dummy_call, and the PC match the dummy frame's
2746   /* Both the 32- and 64-bit ABI's say that the stack pointer should