void lm32_print_operand (FILE * file, rtx op, int letter) { enum rtx_code code; code = GET_CODE (op); if (code == SIGN_EXTEND) op = XEXP (op, 0), code = GET_CODE (op); else if (code == REG || code == SUBREG) { int regnum; if (code == REG) regnum = REGNO (op); else regnum = true_regnum (op); fprintf (file, "%s", reg_names[regnum]); } else if (code == HIGH) output_addr_const (file, XEXP (op, 0)); else if (code == MEM) output_address (XEXP (op, 0)); else if (letter == 'z' && GET_CODE (op) == CONST_INT && INTVAL (op) == 0) fprintf (file, "%s", reg_names[0]); else if (GET_CODE (op) == CONST_DOUBLE) { if ((CONST_DOUBLE_LOW (op) != 0) || (CONST_DOUBLE_HIGH (op) != 0)) output_operand_lossage ("only 0.0 can be loaded as an immediate"); else fprintf (file, "0"); } else if (code == EQ) fprintf (file, "e "); else if (code == NE) fprintf (file, "ne "); else if (code == GT) fprintf (file, "g "); else if (code == GTU) fprintf (file, "gu "); else if (code == LT) fprintf (file, "l "); else if (code == LTU) fprintf (file, "lu "); else if (code == GE) fprintf (file, "ge "); else if (code == GEU) fprintf (file, "geu"); else if (code == LE) fprintf (file, "le "); else if (code == LEU) fprintf (file, "leu"); else output_addr_const (file, op); }
void lm32_print_operand_address (FILE * file, rtx addr) { switch (GET_CODE (addr)) { case REG: fprintf (file, "(%s+0)", reg_names[REGNO (addr)]); break; case MEM: output_address (XEXP (addr, 0)); break; case PLUS: { rtx arg0 = XEXP (addr, 0); rtx arg1 = XEXP (addr, 1); if (GET_CODE (arg0) == REG && CONSTANT_P (arg1)) { if (GET_CODE (arg1) == CONST_INT) fprintf (file, "(%s+%ld)", reg_names[REGNO (arg0)], INTVAL (arg1)); else { fprintf (file, "(%s+", reg_names[REGNO (arg0)]); output_addr_const (file, arg1); fprintf (file, ")"); } } else if (CONSTANT_P (arg0) && CONSTANT_P (arg1)) output_addr_const (file, addr); else fatal_insn ("bad operand", addr); } break; case SYMBOL_REF: if (SYMBOL_REF_SMALL_P (addr)) { fprintf (file, "gp("); output_addr_const (file, addr); fprintf (file, ")"); } else fatal_insn ("can't use non gp relative absolute address", addr); break; default: fatal_insn ("invalid addressing mode", addr); break; } }
static void moxie_print_operand_address (FILE *file, machine_mode, rtx x) { switch (GET_CODE (x)) { case REG: fprintf (file, "(%s)", reg_names[REGNO (x)]); break; case PLUS: switch (GET_CODE (XEXP (x, 1))) { case CONST_INT: fprintf (file, "%ld(%s)", INTVAL(XEXP (x, 1)), reg_names[REGNO (XEXP (x, 0))]); break; case SYMBOL_REF: output_addr_const (file, XEXP (x, 1)); fprintf (file, "(%s)", reg_names[REGNO (XEXP (x, 0))]); break; case CONST: { rtx plus = XEXP (XEXP (x, 1), 0); if (GET_CODE (XEXP (plus, 0)) == SYMBOL_REF && CONST_INT_P (XEXP (plus, 1))) { output_addr_const(file, XEXP (plus, 0)); fprintf (file,"+%ld(%s)", INTVAL (XEXP (plus, 1)), reg_names[REGNO (XEXP (x, 0))]); } else abort(); } break; default: abort(); } break; default: output_addr_const (file, x); break; } }
void crx_print_operand_address (FILE * file, rtx addr) { enum crx_addrtype addrtype; struct crx_address address; int offset; addrtype = crx_decompose_address (addr, &address); if (address.disp) offset = INTVAL (address.disp); else offset = 0; switch (addrtype) { case CRX_REG_REL: fprintf (file, "%d(%s)", offset, reg_names[REGNO (address.base)]); return; case CRX_POST_INC: switch (GET_CODE (address.side_effect)) { case PLUS: break; case MINUS: offset = -offset; break; case POST_INC: offset = GET_MODE_SIZE (output_memory_reference_mode); break; case POST_DEC: offset = -GET_MODE_SIZE (output_memory_reference_mode); break; default: abort (); } fprintf (file, "%d(%s)+", offset, reg_names[REGNO (address.base)]); return; case CRX_SCALED_INDX: fprintf (file, "%d(%s, %s, %d)", offset, reg_names[REGNO (address.base)], reg_names[REGNO (address.index)], address.scale); return; case CRX_ABSOLUTE: output_addr_const (file, address.disp); return; default: abort (); } }
void fr30_print_operand_address (FILE *stream, rtx address) { switch (GET_CODE (address)) { case SYMBOL_REF: output_addr_const (stream, address); break; default: fprintf (stderr, "code = %x\n", GET_CODE (address)); debug_rtx (address); output_operand_lossage ("fr30_print_operand_address: unhandled address"); break; } }
void dw2_assemble_integer (int size, rtx x) { const char *op = integer_asm_op (size, FALSE); if (op) { fputs (op, asm_out_file); if (CONST_INT_P (x)) fprint_whex (asm_out_file, (unsigned HOST_WIDE_INT) INTVAL (x)); else output_addr_const (asm_out_file, x); } else assemble_integer (x, size, BITS_PER_UNIT, 1); }
void dw2_assemble_integer (int size, rtx x) { const char *op = integer_asm_op (size, FALSE); if (op) { fputs (op, asm_out_file); if (GET_CODE (x) == CONST_INT) fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, INTVAL (x)); else output_addr_const (asm_out_file, x); } else assemble_integer (x, size, BITS_PER_UNIT, 1); }
static void moxie_print_operand (FILE *file, rtx x, int code) { rtx operand = x; /* New code entries should just be added to the switch below. If handling is finished, just return. If handling was just a modification of the operand, the modified operand should be put in "operand", and then do a break to let default handling (zero-modifier) output the operand. */ switch (code) { case 0: /* No code, print as usual. */ break; default: LOSE_AND_RETURN ("invalid operand modifier letter", x); } /* Print an operand as without a modifier letter. */ switch (GET_CODE (operand)) { case REG: if (REGNO (operand) > MOXIE_R13) internal_error ("internal error: bad register: %d", REGNO (operand)); fprintf (file, "%s", reg_names[REGNO (operand)]); return; case MEM: output_address (GET_MODE (XEXP (operand, 0)), XEXP (operand, 0)); return; default: /* No need to handle all strange variants, let output_addr_const do it for us. */ if (CONSTANT_P (operand)) { output_addr_const (file, operand); return; } LOSE_AND_RETURN ("unexpected operand", x); } }
void fr30_print_operand (FILE *file, rtx x, int code) { rtx x0; switch (code) { case '#': /* Output a :D if this instruction is delayed. */ if (dbr_sequence_length () != 0) fputs (":D", file); return; case 'p': /* Compute the register name of the second register in a hi/lo register pair. */ if (GET_CODE (x) != REG) output_operand_lossage ("fr30_print_operand: unrecognized %%p code"); else fprintf (file, "r%d", REGNO (x) + 1); return; case 'b': /* Convert GCC's comparison operators into FR30 comparison codes. */ switch (GET_CODE (x)) { case EQ: fprintf (file, "eq"); break; case NE: fprintf (file, "ne"); break; case LT: fprintf (file, "lt"); break; case LE: fprintf (file, "le"); break; case GT: fprintf (file, "gt"); break; case GE: fprintf (file, "ge"); break; case LTU: fprintf (file, "c"); break; case LEU: fprintf (file, "ls"); break; case GTU: fprintf (file, "hi"); break; case GEU: fprintf (file, "nc"); break; default: output_operand_lossage ("fr30_print_operand: unrecognized %%b code"); break; } return; case 'B': /* Convert GCC's comparison operators into the complimentary FR30 comparison codes. */ switch (GET_CODE (x)) { case EQ: fprintf (file, "ne"); break; case NE: fprintf (file, "eq"); break; case LT: fprintf (file, "ge"); break; case LE: fprintf (file, "gt"); break; case GT: fprintf (file, "le"); break; case GE: fprintf (file, "lt"); break; case LTU: fprintf (file, "nc"); break; case LEU: fprintf (file, "hi"); break; case GTU: fprintf (file, "ls"); break; case GEU: fprintf (file, "c"); break; default: output_operand_lossage ("fr30_print_operand: unrecognized %%B code"); break; } return; case 'A': /* Print a signed byte value as an unsigned value. */ if (GET_CODE (x) != CONST_INT) output_operand_lossage ("fr30_print_operand: invalid operand to %%A code"); else { HOST_WIDE_INT val; val = INTVAL (x); val &= 0xff; fprintf (file, HOST_WIDE_INT_PRINT_DEC, val); } return; case 'x': if (GET_CODE (x) != CONST_INT || INTVAL (x) < 16 || INTVAL (x) > 32) output_operand_lossage ("fr30_print_operand: invalid %%x code"); else fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) - 16); return; case 'F': if (GET_CODE (x) != CONST_DOUBLE) output_operand_lossage ("fr30_print_operand: invalid %%F code"); else { char str[30]; real_to_decimal (str, CONST_DOUBLE_REAL_VALUE (x), sizeof (str), 0, 1); fputs (str, file); } return; case 0: /* Handled below. */ break; default: fprintf (stderr, "unknown code = %x\n", code); output_operand_lossage ("fr30_print_operand: unknown code"); return; } switch (GET_CODE (x)) { case REG: fputs (reg_names [REGNO (x)], file); break; case MEM: x0 = XEXP (x,0); switch (GET_CODE (x0)) { case REG: gcc_assert ((unsigned) REGNO (x0) < ARRAY_SIZE (reg_names)); fprintf (file, "@%s", reg_names [REGNO (x0)]); break; case PLUS: if (GET_CODE (XEXP (x0, 0)) != REG || REGNO (XEXP (x0, 0)) < FRAME_POINTER_REGNUM || REGNO (XEXP (x0, 0)) > STACK_POINTER_REGNUM || GET_CODE (XEXP (x0, 1)) != CONST_INT) { fprintf (stderr, "bad INDEXed address:"); debug_rtx (x); output_operand_lossage ("fr30_print_operand: unhandled MEM"); } else if (REGNO (XEXP (x0, 0)) == FRAME_POINTER_REGNUM) { HOST_WIDE_INT val = INTVAL (XEXP (x0, 1)); if (val < -(1 << 9) || val > ((1 << 9) - 4)) { fprintf (stderr, "frame INDEX out of range:"); debug_rtx (x); output_operand_lossage ("fr30_print_operand: unhandled MEM"); } fprintf (file, "@(r14, #" HOST_WIDE_INT_PRINT_DEC ")", val); } else { HOST_WIDE_INT val = INTVAL (XEXP (x0, 1)); if (val < 0 || val > ((1 << 6) - 4)) { fprintf (stderr, "stack INDEX out of range:"); debug_rtx (x); output_operand_lossage ("fr30_print_operand: unhandled MEM"); } fprintf (file, "@(r15, #" HOST_WIDE_INT_PRINT_DEC ")", val); } break; case SYMBOL_REF: output_address (x0); break; default: fprintf (stderr, "bad MEM code = %x\n", GET_CODE (x0)); debug_rtx (x); output_operand_lossage ("fr30_print_operand: unhandled MEM"); break; } break; case CONST_DOUBLE : /* We handle SFmode constants here as output_addr_const doesn't. */ if (GET_MODE (x) == SFmode) { REAL_VALUE_TYPE d; long l; REAL_VALUE_FROM_CONST_DOUBLE (d, x); REAL_VALUE_TO_TARGET_SINGLE (d, l); fprintf (file, "0x%08lx", l); break; } /* Fall through. Let output_addr_const deal with it. */ default: output_addr_const (file, x); break; } return; }
void crx_print_operand (FILE * file, rtx x, int code) { switch (code) { case 'p' : if (GET_CODE (x) == REG) { if (GET_MODE (x) == DImode || GET_MODE (x) == DFmode) { int regno = REGNO (x); if (regno + 1 >= SP_REGNUM) abort (); fprintf (file, "{%s, %s}", reg_names[regno], reg_names[regno + 1]); return; } else { if (REGNO (x) >= SP_REGNUM) abort (); fprintf (file, "%s", reg_names[REGNO (x)]); return; } } case 'd' : { const char *crx_cmp_str; switch (GET_CODE (x)) { /* MD: compare (reg, reg or imm) but CRX: cmp (reg or imm, reg) * -> swap all non symmetric ops */ case EQ : crx_cmp_str = "eq"; break; case NE : crx_cmp_str = "ne"; break; case GT : crx_cmp_str = "lt"; break; case GTU : crx_cmp_str = "lo"; break; case LT : crx_cmp_str = "gt"; break; case LTU : crx_cmp_str = "hi"; break; case GE : crx_cmp_str = "le"; break; case GEU : crx_cmp_str = "ls"; break; case LE : crx_cmp_str = "ge"; break; case LEU : crx_cmp_str = "hs"; break; default : abort (); } fprintf (file, "%s", crx_cmp_str); return; } case 'H': /* Print high part of a double precision value. */ switch (GET_CODE (x)) { case CONST_DOUBLE: if (GET_MODE (x) == SFmode) abort (); if (GET_MODE (x) == DFmode) { /* High part of a DF const. */ REAL_VALUE_TYPE r; long l[2]; REAL_VALUE_FROM_CONST_DOUBLE (r, x); REAL_VALUE_TO_TARGET_DOUBLE (r, l); fprintf (file, "$0x%lx", l[1]); return; } /* -- Fallthrough to handle DI consts -- */ case CONST_INT: { rtx high, low; split_double (x, &low, &high); putc ('$', file); output_addr_const (file, high); return; } case REG: if (REGNO (x) + 1 >= FIRST_PSEUDO_REGISTER) abort (); fprintf (file, "%s", reg_names[REGNO (x) + 1]); return; case MEM: /* Adjust memory address to high part. */ { rtx adj_mem = x; adj_mem = adjust_address (adj_mem, GET_MODE (adj_mem), 4); output_memory_reference_mode = GET_MODE (adj_mem); output_address (XEXP (adj_mem, 0)); return; } default: abort (); } case 'L': /* Print low part of a double precision value. */ switch (GET_CODE (x)) { case CONST_DOUBLE: if (GET_MODE (x) == SFmode) abort (); if (GET_MODE (x) == DFmode) { /* High part of a DF const. */ REAL_VALUE_TYPE r; long l[2]; REAL_VALUE_FROM_CONST_DOUBLE (r, x); REAL_VALUE_TO_TARGET_DOUBLE (r, l); fprintf (file, "$0x%lx", l[0]); return; } /* -- Fallthrough to handle DI consts -- */ case CONST_INT: { rtx high, low; split_double (x, &low, &high); putc ('$', file); output_addr_const (file, low); return; } case REG: fprintf (file, "%s", reg_names[REGNO (x)]); return; case MEM: output_memory_reference_mode = GET_MODE (x); output_address (XEXP (x, 0)); return; default: abort (); } case 0 : /* default */ switch (GET_CODE (x)) { case REG: fprintf (file, "%s", reg_names[REGNO (x)]); return; case MEM: output_memory_reference_mode = GET_MODE (x); output_address (XEXP (x, 0)); return; case CONST_DOUBLE: { REAL_VALUE_TYPE r; long l; /* Always use H and L for double precision - see above */ gcc_assert (GET_MODE (x) == SFmode); REAL_VALUE_FROM_CONST_DOUBLE (r, x); REAL_VALUE_TO_TARGET_SINGLE (r, l); fprintf (file, "$0x%lx", l); return; } default: putc ('$', file); output_addr_const (file, x); return; } default: output_operand_lossage ("invalid %%xn code"); } abort (); }
void lm32_print_operand (FILE *file, rtx op, int letter) { register enum rtx_code code; if (! op) { error ("PRINT_OPERAND null pointer"); abort (); } code = GET_CODE (op); if (code == SIGN_EXTEND) op = XEXP (op, 0), code = GET_CODE (op); else if (code == REG || code == SUBREG) { int regnum; if (code == REG) regnum = REGNO (op); else regnum = true_regnum (op); if ( (letter == 'H' && !WORDS_BIG_ENDIAN) || (letter == 'L' && WORDS_BIG_ENDIAN)) { abort(); regnum++; } fprintf (file, "%s", reg_names[regnum]); } else if (code == MEM) output_address (XEXP (op, 0)); else if (letter == 'z' && GET_CODE (op) == CONST_INT && INTVAL (op) == 0) fprintf (file, "%s", reg_names[0]); else if (GET_CODE (op) == CONST_DOUBLE) { if ((CONST_DOUBLE_LOW (op) != 0) || (CONST_DOUBLE_HIGH (op) != 0)) output_operand_lossage ("Only 0.0 can be loaded as an immediate"); else fprintf (file, "0"); } else if (code == EQ) fprintf (file, "e "); else if (code == NE) fprintf (file, "ne "); else if (code == GT) fprintf (file, "g "); else if (code == GTU) fprintf (file, "gu "); else if (code == LT) fprintf (file, "l "); else if (code == LTU) fprintf (file, "lu "); else if (code == GE) fprintf (file, "ge "); else if (code == GEU) fprintf (file, "geu"); else if (code == LE) fprintf (file, "le "); else if (code == LEU) fprintf (file, "leu"); else output_addr_const (file, op); }
void print_operand_address (FILE * file, rtx addr) { rtx reg1, breg, ireg; rtx offset; retry: switch (GET_CODE (addr)) { case MEM: fprintf (file, "*"); addr = XEXP (addr, 0); goto retry; case REG: fprintf (file, "(%s)", reg_names[REGNO (addr)]); break; case PRE_DEC: fprintf (file, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]); break; case POST_INC: fprintf (file, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]); break; case PLUS: /* There can be either two or three things added here. One must be a REG. One can be either a REG or a MULT of a REG and an appropriate constant, and the third can only be a constant or a MEM. We get these two or three things and put the constant or MEM in OFFSET, the MULT or REG in IREG, and the REG in BREG. If we have a register and can't tell yet if it is a base or index register, put it into REG1. */ reg1 = 0; ireg = 0; breg = 0; offset = 0; if (CONSTANT_ADDRESS_P (XEXP (addr, 0)) || GET_CODE (XEXP (addr, 0)) == MEM) { offset = XEXP (addr, 0); addr = XEXP (addr, 1); } else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)) || GET_CODE (XEXP (addr, 1)) == MEM) { offset = XEXP (addr, 1); addr = XEXP (addr, 0); } else if (GET_CODE (XEXP (addr, 1)) == MULT) { ireg = XEXP (addr, 1); addr = XEXP (addr, 0); } else if (GET_CODE (XEXP (addr, 0)) == MULT) { ireg = XEXP (addr, 0); addr = XEXP (addr, 1); } else if (GET_CODE (XEXP (addr, 1)) == REG) { reg1 = XEXP (addr, 1); addr = XEXP (addr, 0); } else if (GET_CODE (XEXP (addr, 0)) == REG) { reg1 = XEXP (addr, 0); addr = XEXP (addr, 1); } else gcc_unreachable (); if (GET_CODE (addr) == REG) { if (reg1) ireg = addr; else reg1 = addr; } else if (GET_CODE (addr) == MULT) ireg = addr; else { gcc_assert (GET_CODE (addr) == PLUS); if (CONSTANT_ADDRESS_P (XEXP (addr, 0)) || GET_CODE (XEXP (addr, 0)) == MEM) { if (offset) { if (GET_CODE (offset) == CONST_INT) offset = plus_constant (XEXP (addr, 0), INTVAL (offset)); else { gcc_assert (GET_CODE (XEXP (addr, 0)) == CONST_INT); offset = plus_constant (offset, INTVAL (XEXP (addr, 0))); } } offset = XEXP (addr, 0); } else if (GET_CODE (XEXP (addr, 0)) == REG) { if (reg1) ireg = reg1, breg = XEXP (addr, 0), reg1 = 0; else reg1 = XEXP (addr, 0); } else { gcc_assert (GET_CODE (XEXP (addr, 0)) == MULT); gcc_assert (!ireg); ireg = XEXP (addr, 0); } if (CONSTANT_ADDRESS_P (XEXP (addr, 1)) || GET_CODE (XEXP (addr, 1)) == MEM) { if (offset) { if (GET_CODE (offset) == CONST_INT) offset = plus_constant (XEXP (addr, 1), INTVAL (offset)); else { gcc_assert (GET_CODE (XEXP (addr, 1)) == CONST_INT); offset = plus_constant (offset, INTVAL (XEXP (addr, 1))); } } offset = XEXP (addr, 1); } else if (GET_CODE (XEXP (addr, 1)) == REG) { if (reg1) ireg = reg1, breg = XEXP (addr, 1), reg1 = 0; else reg1 = XEXP (addr, 1); } else { gcc_assert (GET_CODE (XEXP (addr, 1)) == MULT); gcc_assert (!ireg); ireg = XEXP (addr, 1); } } /* If REG1 is nonzero, figure out if it is a base or index register. */ if (reg1) { if (breg != 0 || (offset && GET_CODE (offset) == MEM)) { gcc_assert (!ireg); ireg = reg1; } else breg = reg1; } if (offset != 0) output_address (offset); if (breg != 0) fprintf (file, "(%s)", reg_names[REGNO (breg)]); if (ireg != 0) { if (GET_CODE (ireg) == MULT) ireg = XEXP (ireg, 0); gcc_assert (GET_CODE (ireg) == REG); fprintf (file, "[%s]", reg_names[REGNO (ireg)]); } break; default: output_addr_const (file, addr); } }