templatize operand constructors

src/a64/assembler-a64.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 552 matching lines @@
 // -----------------------------------------------------------------------------
 // Operands.
 const int kSmiShift = kSmiTagSize + kSmiShiftSize;
 const uint64_t kSmiShiftMask = (1UL << kSmiShift) - 1;
 
 // Represents an operand in a machine instruction.
 class Operand {
   // TODO(all): If necessary, study more in details which methods
   // TODO(all): should be inlined or not.
  public:
-  // #<immediate>
-  // where <immediate> is int64_t.
-  // GCC complains about ambiguous aliasing if we don't explicitly declare the
-  // variants.
-  // The simple literal-value wrappers are allowed to be implicit constructors
-  // because Operand is a wrapper class that doesn't normally perform any type
-  // conversion.
-  inline Operand(int64_t immediate,
-      RelocInfo::Mode rmode = RelocInfo::NONE64);    // NOLINT(runtime/explicit)
-  inline Operand(uint64_t immediate,
-      RelocInfo::Mode rmode = RelocInfo::NONE64);    // NOLINT(runtime/explicit)
-  inline Operand(int32_t immediate,
-      RelocInfo::Mode rmode = RelocInfo::NONE32);    // NOLINT(runtime/explicit)
-  inline Operand(uint32_t immediate,
-      RelocInfo::Mode rmode = RelocInfo::NONE32);    // NOLINT(runtime/explicit)
-
-
   // rm, {<shift> {#<shift_amount>}}
   // where <shift> is one of {LSL, LSR, ASR, ROR}.
   //       <shift_amount> is uint6_t.
   // This is allowed to be an implicit constructor because Operand is
   // a wrapper class that doesn't normally perform any type conversion.
   inline Operand(Register reg,
                  Shift shift = LSL,
                  unsigned shift_amount = 0);  // NOLINT(runtime/explicit)
 
   // rm, <extend> {#<shift_amount>}
   // where <extend> is one of {UXTB, UXTH, UXTW, UXTX, SXTB, SXTH, SXTW, SXTX}.
   //       <shift_amount> is uint2_t.
   inline Operand(Register reg,
                  Extend extend,
                  unsigned shift_amount = 0);
 
-  inline explicit Operand(Smi* value);
-  explicit Operand(const ExternalReference& f);
-  explicit Operand(Handle<Object> handle);
+  template<typename T>
+  inline explicit Operand(Handle<T> handle);
+
+  // Implicit constructor for all int types, ExternalReference, and Smi.
+  template<typename T>
+  inline Operand(T t);  // NOLINT(runtime/explicit)
+
+  // Implicit constructor for int types.
+  template<typename int_t>
+  inline Operand(int_t t, RelocInfo::Mode rmode);
 
   inline bool IsImmediate() const;
   inline bool IsShiftedRegister() const;
   inline bool IsExtendedRegister() const;
   inline bool IsZero() const;
 
   // This returns an LSL shift (<= 4) operand as an equivalent extend operand,
   // which helps in the encoding of instructions that use the stack pointer.
   inline Operand ToExtendedRegister() const;
 
   inline int64_t immediate() const;
   inline Register reg() const;
   inline Shift shift() const;
   inline Extend extend() const;
   inline unsigned shift_amount() const;
 
   // Relocation information.
   RelocInfo::Mode rmode() const { return rmode_; }
   void set_rmode(RelocInfo::Mode rmode) { rmode_ = rmode; }
   bool NeedsRelocation() const;
 
   // Helpers
   inline static Operand UntagSmi(Register smi);
   inline static Operand UntagSmiAndScale(Register smi, int scale);
 
  private:
+  void initialize_handle(Handle<Object> value);
   int64_t immediate_;
   Register reg_;
   Shift shift_;
   Extend extend_;
   unsigned shift_amount_;
   RelocInfo::Mode rmode_;
 };
 
 
 // MemOperand represents a memory operand in a load or store instruction.
@@ skipping 1398 matching lines @@
 class EnsureSpace BASE_EMBEDDED {
  public:
   explicit EnsureSpace(Assembler* assembler) {
     assembler->CheckBuffer();
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_A64_ASSEMBLER_A64_H_