331     switch (rtype) {

   331     switch (rtype) {

   332     case relocInfo::external_word_type:

   332     case relocInfo::external_word_type:

   333       return external_word_Relocation::spec(addr);

   333       return external_word_Relocation::spec(addr);

   334     case relocInfo::internal_word_type:

   334     case relocInfo::internal_word_type:

   335       return internal_word_Relocation::spec(addr);

   335       return internal_word_Relocation::spec(addr);

   337     case relocInfo::opt_virtual_call_type:

   336     case relocInfo::opt_virtual_call_type:

   338       return opt_virtual_call_Relocation::spec();

   337       return opt_virtual_call_Relocation::spec();

   339     case relocInfo::static_call_type:

   338     case relocInfo::static_call_type:

   340       return static_call_Relocation::spec();

   339       return static_call_Relocation::spec();

   341     case relocInfo::runtime_call_type:

   340     case relocInfo::runtime_call_type:

   342       return runtime_call_Relocation::spec();

   341       return runtime_call_Relocation::spec();

   344     case relocInfo::none:

   342     case relocInfo::none:

   345       return RelocationHolder();

   343       return RelocationHolder();

   346     default:

   344     default:

   347       ShouldNotReachHere();

   345       ShouldNotReachHere();

   348       return RelocationHolder();

   346       return RelocationHolder();

   394 

   392 

   395   AddressLiteral(intptr_t addr, relocInfo::relocType rtype = relocInfo::none)

   393   AddressLiteral(intptr_t addr, relocInfo::relocType rtype = relocInfo::none)

   396     : _address((address) addr),

   394     : _address((address) addr),

   397       _rspec(rspec_from_rtype(rtype, (address) addr)) {}

   395       _rspec(rspec_from_rtype(rtype, (address) addr)) {}

   398 

   396 

   400   // 32-bit complains about a multiple declaration for int*.

   397   // 32-bit complains about a multiple declaration for int*.

   401   AddressLiteral(intptr_t* addr, relocInfo::relocType rtype = relocInfo::none)

   398   AddressLiteral(intptr_t* addr, relocInfo::relocType rtype = relocInfo::none)

   402     : _address((address) addr),

   399     : _address((address) addr),

   403       _rspec(rspec_from_rtype(rtype, (address) addr)) {}

   400       _rspec(rspec_from_rtype(rtype, (address) addr)) {}

   405 

   401 

   406   AddressLiteral(Metadata* addr, relocInfo::relocType rtype = relocInfo::none)

   402   AddressLiteral(Metadata* addr, relocInfo::relocType rtype = relocInfo::none)

   407     : _address((address) addr),

   403     : _address((address) addr),

   408       _rspec(rspec_from_rtype(rtype, (address) addr)) {}

   404       _rspec(rspec_from_rtype(rtype, (address) addr)) {}

   409 

   405 

   462  private:

   458  private:

   463   int _number;

   459   int _number;

   464   bool _is_in;

   460   bool _is_in;

   465 

   461 

   466  public:

   462  public:

   468   enum {

   463   enum {

   469     n_register_parameters = 6,          // only 6 registers may contain integer parameters

   464     n_register_parameters = 6,          // only 6 registers may contain integer parameters

   470     n_float_register_parameters = 16    // Can have up to 16 floating registers

   465     n_float_register_parameters = 16    // Can have up to 16 floating registers

   471   };

   466   };

   477 

   467 

   478   // creation

   468   // creation

   479   Argument(int number, bool is_in) : _number(number), _is_in(is_in) {}

   469   Argument(int number, bool is_in) : _number(number), _is_in(is_in) {}

   480 

   470 

   481   int  number() const  { return _number;  }

   471   int  number() const  { return _number;  }

   487   Argument as_out()    const  { return Argument(number(), false); }

   477   Argument as_out()    const  { return Argument(number(), false); }

   488 

   478 

   489   // locating register-based arguments:

   479   // locating register-based arguments:

   490   bool is_register() const { return _number < n_register_parameters; }

   480   bool is_register() const { return _number < n_register_parameters; }

   491 

   481 

   493   // locating Floating Point register-based arguments:

   482   // locating Floating Point register-based arguments:

   494   bool is_float_register() const { return _number < n_float_register_parameters; }

   483   bool is_float_register() const { return _number < n_float_register_parameters; }

   495 

   484 

   496   FloatRegister as_float_register() const {

   485   FloatRegister as_float_register() const {

   497     assert(is_float_register(), "must be a register argument");

   486     assert(is_float_register(), "must be a register argument");

   499   }

   488   }

   500   FloatRegister as_double_register() const {

   489   FloatRegister as_double_register() const {

   501     assert(is_float_register(), "must be a register argument");

   490     assert(is_float_register(), "must be a register argument");

   502     return as_FloatRegister(( number() *2 ));

   491     return as_FloatRegister(( number() *2 ));

   503   }

   492   }

   505 

   493 

   506   Register as_register() const {

   494   Register as_register() const {

   507     assert(is_register(), "must be a register argument");

   495     assert(is_register(), "must be a register argument");

   508     return is_in() ? as_iRegister(number()) : as_oRegister(number());

   496     return is_in() ? as_iRegister(number()) : as_oRegister(number());

   509   }

   497   }

  1215               Register Rout_high, Register Rout_low, Register Rtemp );

  1203               Register Rout_high, Register Rout_low, Register Rtemp );

  1216 

  1204 

  1217   void lushr( Register Rin_high,  Register Rin_low,  Register Rcount,

  1205   void lushr( Register Rin_high,  Register Rin_low,  Register Rcount,

  1218               Register Rout_high, Register Rout_low, Register Rtemp );

  1206               Register Rout_high, Register Rout_low, Register Rtemp );

  1219 

  1207 

  1221   void lcmp( Register Ra, Register Rb, Register Rresult);

  1208   void lcmp( Register Ra, Register Rb, Register Rresult);

  1223 

  1209 

  1224   // Load and store values by size and signed-ness

  1210   // Load and store values by size and signed-ness

  1225   void load_sized_value( Address src, Register dst, size_t size_in_bytes, bool is_signed);

  1211   void load_sized_value( Address src, Register dst, size_t size_in_bytes, bool is_signed);

  1226   void store_sized_value(Register src, Address dst, size_t size_in_bytes);

  1212   void store_sized_value(Register src, Address dst, size_t size_in_bytes);

  1227 

  1213