contrib/gcc/reload1.c

4346 mark_reload_reg_in_use (unsigned int regno, int opnum, enum reload_type type,
4361 	  SET_HARD_REG_BIT (reload_reg_used_in_input_addr[opnum], i);
4365 	  SET_HARD_REG_BIT (reload_reg_used_in_inpaddr_addr[opnum], i);
4369 	  SET_HARD_REG_BIT (reload_reg_used_in_output_addr[opnum], i);
4373 	  SET_HARD_REG_BIT (reload_reg_used_in_outaddr_addr[opnum], i);
4389 	  SET_HARD_REG_BIT (reload_reg_used_in_input[opnum], i);
4393 	  SET_HARD_REG_BIT (reload_reg_used_in_output[opnum], i);
4408 clear_reload_reg_in_use (unsigned int regno, int opnum,
4429       used_in_set = &reload_reg_used_in_input_addr[opnum];
4434       used_in_set = &reload_reg_used_in_inpaddr_addr[opnum];
4438       used_in_set = &reload_reg_used_in_output_addr[opnum];
4443       used_in_set = &reload_reg_used_in_outaddr_addr[opnum];
4461       used_in_set = &reload_reg_used_in_input[opnum];
4465       used_in_set = &reload_reg_used_in_output[opnum];
4489 	      && (check_any || rld[i].opnum == opnum)
4517 reload_reg_free_p (unsigned int regno, int opnum, enum reload_type type)
4561       for (i = opnum + 1; i < reload_n_operands; i++)
4571       if (TEST_HARD_REG_BIT (reload_reg_used_in_input_addr[opnum], regno)
4572 	  || TEST_HARD_REG_BIT (reload_reg_used_in_inpaddr_addr[opnum], regno))
4575       for (i = 0; i < opnum; i++)
4585       if (TEST_HARD_REG_BIT (reload_reg_used_in_inpaddr_addr[opnum], regno))
4588       for (i = 0; i < opnum; i++)
4599       if (TEST_HARD_REG_BIT (reload_reg_used_in_output_addr[opnum], regno))
4602       for (i = 0; i <= opnum; i++)
4614       if (TEST_HARD_REG_BIT (reload_reg_used_in_outaddr_addr[opnum], regno))
4617       for (i = 0; i <= opnum; i++)
4650       for (i = opnum; i < reload_n_operands; i++)
4683 reload_reg_reaches_end_p (unsigned int regno, int opnum, enum reload_type type)
4724       for (i = opnum; i < reload_n_operands; i++)
4728       for (i = opnum + 1; i < reload_n_operands; i++)
4752       for (i = opnum + 1; i < reload_n_operands; i++)
4786       opnum = reload_n_operands;
4797       for (i = 0; i < opnum; i++)
4820   int r1_opnum = rld[r1].opnum;
4821   int r2_opnum = rld[r2].opnum;
4908 reload_reg_free_for_value_p (int start_regno, int regno, int opnum,
4957 	 multiply opnum by at least three.  We round that up to four because
4960       time1 = opnum * 4 + 2;
4963       time1 = opnum * 4 + 3;
4968       time1 = copy ? opnum * 4 + 4 : MAX_RECOG_OPERANDS * 4 + 3;
4971       /* opnum * 4 + 4
4981       time1 = MAX_RECOG_OPERANDS * 4 + 4 + opnum;
4984       time1 = MAX_RECOG_OPERANDS * 4 + 5 + opnum;
5031 		  if (type == RELOAD_FOR_INPUT && opnum == rld[i].opnum
5036 		  time2 = rld[i].opnum * 4 + 2;
5039 		  if (type == RELOAD_FOR_INPUT && opnum == rld[i].opnum
5043 		  time2 = rld[i].opnum * 4 + 3;
5046 		  time2 = rld[i].opnum * 4 + 4;
5049 		  /* rld[i].opnum * 4 + 4 <= (MAX_RECOG_OPERAND - 1) * 4 + 4
5078 		  time2 = MAX_RECOG_OPERANDS * 4 + 4 + rld[i].opnum;
5081 		  time2 = MAX_RECOG_OPERANDS * 4 + 5 + rld[i].opnum;
5147 free_for_value_p (int regno, enum machine_mode mode, int opnum,
5153     if (! reload_reg_free_for_value_p (regno, regno + nregs, opnum, type,
5254 	    mark_reload_reg_in_use (spill_regs[i], rld[r].opnum,
5326 	  if ((reload_reg_free_p (regnum, rld[r].opnum,
5332 		   && free_for_value_p (regnum, rld[r].mode, rld[r].opnum,
5367 			&& reload_reg_free_p (regno, rld[r].opnum,
5445       mark_reload_reg_in_use (REGNO (rld[i].reg_rtx), rld[i].opnum,
5675 		      && free_for_value_p (i, rld[r].mode, rld[r].opnum,
5717 						      rld[r].opnum,
5754 						      rld[r].opnum,
5845 					      rld[r].opnum, rld[r].when_needed,
5940 			  mark_reload_reg_in_use (regno, rld[r].opnum,
6065 				  rld[r].opnum, rld[r].when_needed, rld[r].in,
6112 	  clear_reload_reg_in_use (regno, rld[j].opnum,
6168     clear_reload_reg_in_use (regno, rld[r].opnum, rld[r].when_needed,
6221 	      && rld[j].opnum > max_input_address_opnum)
6222 	    max_input_address_opnum = rld[j].opnum;
6235 		       || rld[i].opnum > rld[j].opnum)
6239 	      if (min_conflicting_input_opnum > rld[j].opnum)
6240 		min_conflicting_input_opnum = rld[j].opnum;
6489       where = &input_reload_insns[rl->opnum];
6492       where = &input_address_reload_insns[rl->opnum];
6495       where = &inpaddr_address_reload_insns[rl->opnum];
6498       where = &output_address_reload_insns[rl->opnum];
6501       where = &outaddr_address_reload_insns[rl->opnum];
6559 	   && free_for_value_p (REGNO (reloadreg), rl->mode, rl->opnum,
6798 			      rl->opnum,
6801 			      rl->opnum,
6806 			    rl->opnum,
6835       gen_reload (reloadreg, real_oldequiv, rl->opnum,
6868     push_to_sequence (output_reload_insns[rl->opnum]);
6954 			      rl->opnum, rl->when_needed);
6966 			      rl->opnum, rl->when_needed);
6972 				  rl->opnum, rl->when_needed);
6994 	gen_reload (old, reloadreg, rl->opnum,
7065       emit_insn (other_output_reload_insns[rl->opnum]);
7066       other_output_reload_insns[rl->opnum] = get_insns ();
7069     output_reload_insns[rl->opnum] = get_insns ();
7369 	      if (reload_reg_reaches_end_p (i + k, rld[r].opnum,
7518 					      rld[r].opnum,
7663 gen_reload (rtx out, rtx in, int opnum, enum reload_type type)
7784       gen_reload (out, op0, opnum, type);
7805       gen_reload (out, op1, opnum, type);
7821       rtx loc = get_secondary_mem (in, GET_MODE (out), opnum, type);
7829       gen_reload (loc, in, opnum, type);
7830       gen_reload (out, loc, opnum, type);
7858       gen_reload (out_moded, op1, opnum, type);