[ELF] Use MathExtras.h llvm::SignExtend64

[MaskRay]

Summary

To be consistent with other files where only SignExtend64 is used.

[ruiu]

LGTM

ELF/Target.h

 //===- Target.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_TARGET_H
 #define LLD_ELF_TARGET_H
 
 #include "InputSection.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/ELF.h"
+#include "llvm/Support/MathExtras.h"
 
 namespace lld {
 std::string toString(elf::RelType Type);
 
 namespace elf {
 class Defined;
 class InputFile;
 class Symbol;
if (ErrPlace.IS && ErrPlace.IS->Name.startswith(".debug"))
     Hint = "; consider recompiling with -fdebug-types-section to reduce size "
            "of debug sections";
 
   error(ErrPlace.Loc + "relocation " + lld::toString(Type) +
         " out of range: " + V.str() + " is not in [" + Twine(Min).str() + ", " +
         Twine(Max).str() + "]" + Hint);
 }
 
-// Sign-extend Nth bit all the way to MSB.
-inline int64_t signExtend(uint64_t V, int N) {
-  return int64_t(V << (64 - N)) >> (64 - N);
-}
-
 // Make sure that V can be represented as an N bit signed integer.
 inline void checkInt(uint8_t *Loc, int64_t V, int N, RelType Type) {
-  if (V != signExtend(V, N))
+  if (V != llvm::SignExtend64(V, N))
     reportRangeError(Loc, Type, Twine(V), llvm::minIntN(N), llvm::maxIntN(N));
 }
 
 // Make sure that V can be represented as an N bit unsigned integer.
 inline void checkUInt(uint8_t *Loc, uint64_t V, int N, RelType Type) {
   if ((V >> N) != 0)
     reportRangeError(Loc, Type, Twine(V), 0, llvm::maxUIntN(N));
 }
 
 // Make sure that V can be represented as an N bit signed or unsigned integer.
 inline void checkIntUInt(uint8_t *Loc, uint64_t V, int N, RelType Type) {
   // For the error message we should cast V to a signed integer so that error
   // messages show a small negative value rather than an extremely large one
-  if (V != (uint64_t)signExtend(V, N) && (V >> N) != 0)
+  if (V != (uint64_t)llvm::SignExtend64(V, N) && (V >> N) != 0)
     reportRangeError(Loc, Type, Twine((int64_t)V), llvm::minIntN(N),
                      llvm::maxIntN(N));
 }
 
 inline void checkAlignment(uint8_t *Loc, uint64_t V, int N, RelType Type) {
   if ((V & (N - 1)) != 0)
     error(getErrorLocation(Loc) + "improper alignment for relocation " +
           lld::toString(Type) + ": 0x" + llvm::utohexstr(V) +