Revert "[DebugInfo] Introduce DW_OP_LLVM_convert"

This reverts commit 1cf4b593a7ebd666fc6775f3bd38196e8e65fafe.

Build bots found failing tests not detected locally.

Failing Tests (3):
  LLVM :: DebugInfo/Generic/convert-debugloc.ll
  LLVM :: DebugInfo/Generic/convert-inlined.ll
  LLVM :: DebugInfo/Generic/convert-linked.ll

llvm-svn: 356444

37 files changed, 85 insertions, 671 deletions

diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index a43b0ee3c45..fcea8a482a7 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -4682,10 +4682,6 @@ The current supported opcode vocabulary is limited:
   here, respectively) of the variable fragment from the working expression. Note
   that contrary to DW_OP_bit_piece, the offset is describing the location
   within the described source variable.
-- ``DW_OP_LLVM_convert, 16, DW_ATE_signed`` specifies a bit size and encoding
-  (``16`` and ``DW_ATE_signed`` here, respectively) to which the top of the
-  expression stack is to be converted. Maps into a ``DW_OP_convert`` operation
-  that references a base type constructed from the supplied values.
 - ``DW_OP_swap`` swaps top two stack entries.
 - ``DW_OP_xderef`` provides extended dereference mechanism. The entry at the top
   of the stack is treated as an address. The second stack entry is treated as an
diff --git a/llvm/include/llvm/BinaryFormat/Dwarf.h b/llvm/include/llvm/BinaryFormat/Dwarf.h
index 9455cffab27..3757c75f6ba 100644
--- a/llvm/include/llvm/BinaryFormat/Dwarf.h
+++ b/llvm/include/llvm/BinaryFormat/Dwarf.h
@@ -129,8 +129,7 @@ enum LocationAtom {
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_OP_lo_user = 0xe0,
   DW_OP_hi_user = 0xff,
-  DW_OP_LLVM_fragment = 0x1000, ///< Only used in LLVM metadata.
-  DW_OP_LLVM_convert  = 0x1001  ///< Only used in LLVM metadata.
+  DW_OP_LLVM_fragment = 0x1000 ///< Only used in LLVM metadata.
 };
 
 enum TypeKind : uint8_t {
diff --git a/llvm/include/llvm/CodeGen/AsmPrinter.h b/llvm/include/llvm/CodeGen/AsmPrinter.h
index 5d33c4b0fd3..fb12bb26b3e 100644
--- a/llvm/include/llvm/CodeGen/AsmPrinter.h
+++ b/llvm/include/llvm/CodeGen/AsmPrinter.h
@@ -510,7 +510,7 @@ public:
   void EmitSLEB128(int64_t Value, const char *Desc = nullptr) const;
 
   /// Emit the specified unsigned leb128 value.
-  void EmitULEB128(uint64_t Value, const char *Desc = nullptr, unsigned PadTo = 0) const;
+  void EmitULEB128(uint64_t Value, const char *Desc = nullptr) const;
 
   /// Emit a .byte 42 directive that corresponds to an encoding.  If verbose
   /// assembly output is enabled, we output comments describing the encoding.
diff --git a/llvm/include/llvm/CodeGen/DIE.h b/llvm/include/llvm/CodeGen/DIE.h
index 684f9e40ca5..30271d53a3b 100644
--- a/llvm/include/llvm/CodeGen/DIE.h
+++ b/llvm/include/llvm/CodeGen/DIE.h
@@ -38,7 +38,6 @@ namespace llvm {
 class AsmPrinter;
 class DIE;
 class DIEUnit;
-class DwarfCompileUnit;
 class MCExpr;
 class MCSection;
 class MCSymbol;
@@ -231,25 +230,6 @@ public:
 };
 
 //===--------------------------------------------------------------------===//
-/// A BaseTypeRef DIE.
-class DIEBaseTypeRef {
-  const DwarfCompileUnit *CU;
-  const uint64_t Index;
-  static constexpr unsigned ULEB128PadSize = 4;
-
-public:
-  explicit DIEBaseTypeRef(const DwarfCompileUnit *TheCU, uint64_t Idx)
-    : CU(TheCU), Index(Idx) {}
-
-  /// EmitValue - Emit base type reference.
-  void EmitValue(const AsmPrinter *AP, dwarf::Form Form) const;
-  /// SizeOf - Determine size of the base type reference in bytes.
-  unsigned SizeOf(const AsmPrinter *AP, dwarf::Form Form) const;
-
-  void print(raw_ostream &O) const;
-};
-
-//===--------------------------------------------------------------------===//
 /// A simple label difference DIE.
 ///
 class DIEDelta {
@@ -369,7 +349,7 @@ private:
   /// should be stored by reference instead of by value.
   using ValTy = AlignedCharArrayUnion<DIEInteger, DIEString, DIEExpr, DIELabel,
                                       DIEDelta *, DIEEntry, DIEBlock *,
-                                      DIELoc *, DIELocList, DIEBaseTypeRef *>;
+                                      DIELoc *, DIELocList>;
 
   static_assert(sizeof(ValTy) <= sizeof(uint64_t) ||
                     sizeof(ValTy) <= sizeof(void *),
@@ -521,18 +501,6 @@ struct IntrusiveBackListBase {
     }
     Last = &N;
   }
-
-  void push_front(Node &N) {
-    assert(N.Next.getPointer() == &N && "Expected unlinked node");
-    assert(N.Next.getInt() == true && "Expected unlinked node");
-
-    if (Last) {
-      N.Next.setPointerAndInt(Last->Next.getPointer(), false);
-      Last->Next.setPointerAndInt(&N, true);
-    } else {
-      Last = &N;
-    }
-  }
 };
 
 template <class T> class IntrusiveBackList : IntrusiveBackListBase {
@@ -540,15 +508,8 @@ public:
   using IntrusiveBackListBase::empty;
 
   void push_back(T &N) { IntrusiveBackListBase::push_back(N); }
-  void push_front(T &N) { IntrusiveBackListBase::push_front(N); }
   T &back() { return *static_cast<T *>(Last); }
   const T &back() const { return *static_cast<T *>(Last); }
-  T &front() {
-    return *static_cast<T *>(Last ? Last->Next.getPointer() : nullptr);
-  }
-  const T &front() const {
-    return *static_cast<T *>(Last ? Last->Next.getPointer() : nullptr);
-  }
 
   class const_iterator;
   class iterator
@@ -811,13 +772,6 @@ public:
     return Children.back();
   }
 
-  DIE &addChildFront(DIE *Child) {
-    assert(!Child->getParent() && "Child should be orphaned");
-    Child->Owner = this;
-    Children.push_front(*Child);
-    return Children.front();
-  }
-
   /// Find a value in the DIE with the attribute given.
   ///
   /// Returns a default-constructed DIEValue (where \a DIEValue::getType()
diff --git a/llvm/include/llvm/CodeGen/DIEValue.def b/llvm/include/llvm/CodeGen/DIEValue.def
index 92afeb3868b..c6c4c9a477c 100644
--- a/llvm/include/llvm/CodeGen/DIEValue.def
+++ b/llvm/include/llvm/CodeGen/DIEValue.def
@@ -34,7 +34,6 @@ HANDLE_DIEVALUE_SMALL(Integer)
 HANDLE_DIEVALUE_SMALL(String)
 HANDLE_DIEVALUE_SMALL(Expr)
 HANDLE_DIEVALUE_SMALL(Label)
-HANDLE_DIEVALUE_LARGE(BaseTypeRef)
 HANDLE_DIEVALUE_LARGE(Delta)
 HANDLE_DIEVALUE_SMALL(Entry)
 HANDLE_DIEVALUE_LARGE(Block)
diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
index cced6048e81..54ceb450a8d 100644
--- a/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
+++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
@@ -86,7 +86,7 @@ public:
     SmallVector<Entry, 2> Entries;
     void dump(raw_ostream &OS, uint64_t BaseAddr, bool IsLittleEndian,
               unsigned AddressSize, const MCRegisterInfo *RegInfo,
-              DWARFUnit *U, unsigned Indent) const;
+              unsigned Indent) const;
   };
 
 private:
diff --git a/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h b/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h
index 21b138676bd..00ade7a3edd 100644
--- a/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h
+++ b/llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h
@@ -79,13 +79,11 @@ public:
     bool Error;
     uint32_t EndOffset;
     uint64_t Operands[2];
-    uint32_t OperandEndOffsets[2];
 
   public:
     Description &getDescription() { return Desc; }
     uint8_t getCode() { return Opcode; }
     uint64_t getRawOperand(unsigned Idx) { return Operands[Idx]; }
-    uint32_t getOperandEndOffset(unsigned Idx) { return OperandEndOffsets[Idx]; }
     uint32_t getEndOffset() { return EndOffset; }
     bool extract(DataExtractor Data, uint16_t Version, uint8_t AddressSize,
                  uint32_t Offset);
diff --git a/llvm/include/llvm/MC/MCStreamer.h b/llvm/include/llvm/MC/MCStreamer.h
index f363d544474..dc2386fca85 100644
--- a/llvm/include/llvm/MC/MCStreamer.h
+++ b/llvm/include/llvm/MC/MCStreamer.h
@@ -634,7 +634,7 @@ public:
 
   /// Special case of EmitULEB128Value that avoids the client having to
   /// pass in a MCExpr for constant integers.
-  void EmitULEB128IntValue(uint64_t Value, unsigned PadTo = 0);
+  void EmitULEB128IntValue(uint64_t Value);
 
   /// Special case of EmitSLEB128Value that avoids the client having to
   /// pass in a MCExpr for constant integers.
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index 71315f3c0fb..5a875fee07b 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -4838,15 +4838,6 @@ bool LLParser::ParseDIExpression(MDNode *&Result, bool IsDistinct) {
         return TokError(Twine("invalid DWARF op '") + Lex.getStrVal() + "'");
       }
 
-      if (Lex.getKind() == lltok::DwarfAttEncoding) {
-        if (unsigned Op = dwarf::getAttributeEncoding(Lex.getStrVal())) {
-          Lex.Lex();
-          Elements.push_back(Op);
-          continue;
-        }
-        return TokError(Twine("invalid DWARF attribute encoding '") + Lex.getStrVal() + "'");
-      }
-
       if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
         return TokError("expected unsigned integer");
 
diff --git a/llvm/lib/BinaryFormat/Dwarf.cpp b/llvm/lib/BinaryFormat/Dwarf.cpp
index b6d4d5b0730..73f04a3ed28 100644
--- a/llvm/lib/BinaryFormat/Dwarf.cpp
+++ b/llvm/lib/BinaryFormat/Dwarf.cpp
@@ -143,8 +143,6 @@ StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
   case DW_OP_##NAME:                                                           \
     return "DW_OP_" #NAME;
 #include "llvm/BinaryFormat/Dwarf.def"
-  case DW_OP_LLVM_convert:
-    return "DW_OP_LLVM_convert";
   case DW_OP_LLVM_fragment:
     return "DW_OP_LLVM_fragment";
   }
@@ -155,7 +153,6 @@ unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
   .Case("DW_OP_" #NAME, DW_OP_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
-      .Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
       .Default(0);
 }
diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
index 6fdf1451a63..7a62b6bfc6a 100644
--- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp
@@ -42,11 +42,11 @@ void AsmPrinter::EmitSLEB128(int64_t Value, const char *Desc) const {
   OutStreamer->EmitSLEB128IntValue(Value);
 }
 
-void AsmPrinter::EmitULEB128(uint64_t Value, const char *Desc, unsigned PadTo) const {
+void AsmPrinter::EmitULEB128(uint64_t Value, const char *Desc) const {
   if (isVerbose() && Desc)
     OutStreamer->AddComment(Desc);
 
-  OutStreamer->EmitULEB128IntValue(Value, PadTo);
+  OutStreamer->EmitULEB128IntValue(Value);
 }
 
 /// Emit something like ".uleb128 Hi-Lo".
diff --git a/llvm/lib/CodeGen/AsmPrinter/ByteStreamer.h b/llvm/lib/CodeGen/AsmPrinter/ByteStreamer.h
index db2ff458eb2..7a2902d6807 100644
--- a/llvm/lib/CodeGen/AsmPrinter/ByteStreamer.h
+++ b/llvm/lib/CodeGen/AsmPrinter/ByteStreamer.h
@@ -31,7 +31,7 @@ class ByteStreamer {
   // For now we're just handling the calls we need for dwarf emission/hashing.
   virtual void EmitInt8(uint8_t Byte, const Twine &Comment = "") = 0;
   virtual void EmitSLEB128(uint64_t DWord, const Twine &Comment = "") = 0;
-  virtual void EmitULEB128(uint64_t DWord, const Twine &Comment = "", unsigned PadTo = 0) = 0;
+  virtual void EmitULEB128(uint64_t DWord, const Twine &Comment = "") = 0;
 };
 
 class APByteStreamer final : public ByteStreamer {
@@ -48,7 +48,7 @@ public:
     AP.OutStreamer->AddComment(Comment);
     AP.EmitSLEB128(DWord);
   }
-  void EmitULEB128(uint64_t DWord, const Twine &Comment, unsigned PadTo) override {
+  void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
     AP.OutStreamer->AddComment(Comment);
     AP.EmitULEB128(DWord);
   }
@@ -65,7 +65,7 @@ class HashingByteStreamer final : public ByteStreamer {
   void EmitSLEB128(uint64_t DWord, const Twine &Comment) override {
     Hash.addSLEB128(DWord);
   }
-  void EmitULEB128(uint64_t DWord, const Twine &Comment, unsigned PadTo) override {
+  void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
     Hash.addULEB128(DWord);
   }
 };
@@ -102,9 +102,9 @@ public:
 
     }
   }
-  void EmitULEB128(uint64_t DWord, const Twine &Comment, unsigned PadTo) override {
+  void EmitULEB128(uint64_t DWord, const Twine &Comment) override {
     raw_svector_ostream OSE(Buffer);
-    unsigned Length = encodeULEB128(DWord, OSE, PadTo);
+    unsigned Length = encodeULEB128(DWord, OSE);
     if (GenerateComments) {
       Comments.push_back(Comment.str());
       // Add some empty comments to keep the Buffer and Comments vectors aligned
diff --git a/llvm/lib/CodeGen/AsmPrinter/DIE.cpp b/llvm/lib/CodeGen/AsmPrinter/DIE.cpp
index f4134da48ca..dfc4156243d 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DIE.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DIE.cpp
@@ -506,23 +506,6 @@ LLVM_DUMP_METHOD
 void DIELabel::print(raw_ostream &O) const { O << "Lbl: " << Label->getName(); }
 
 //===----------------------------------------------------------------------===//
-// DIEBaseTypeRef Implementation
-//===----------------------------------------------------------------------===//
-
-void DIEBaseTypeRef::EmitValue(const AsmPrinter *AP, dwarf::Form Form) const {
-  uint64_t Offset = CU->ExprRefedBaseTypes[Index].Die->getOffset();
-  assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
-  AP->EmitULEB128(Offset, nullptr, ULEB128PadSize);
-}
-
-unsigned DIEBaseTypeRef::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
-  return ULEB128PadSize;
-}
-
-LLVM_DUMP_METHOD
-void DIEBaseTypeRef::print(raw_ostream &O) const { O << "BaseTypeRef: " << Index; }
-
-//===----------------------------------------------------------------------===//
 // DIEDelta Implementation
 //===----------------------------------------------------------------------===//
 
diff --git a/llvm/lib/CodeGen/AsmPrinter/DIEHash.cpp b/llvm/lib/CodeGen/AsmPrinter/DIEHash.cpp
index bfac8850a2a..75d9430c351 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DIEHash.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DIEHash.cpp
@@ -225,7 +225,7 @@ void DIEHash::hashLocList(const DIELocList &LocList) {
   DwarfDebug &DD = *AP->getDwarfDebug();
   const DebugLocStream &Locs = DD.getDebugLocs();
   for (const auto &Entry : Locs.getEntries(Locs.getList(LocList.getValue())))
-    DD.emitDebugLocEntry(Streamer, Entry, nullptr);
+    DD.emitDebugLocEntry(Streamer, Entry);
 }
 
 // Hash an individual attribute \param Attr based on the type of attribute and
@@ -309,7 +309,6 @@ void DIEHash::hashAttribute(const DIEValue &Value, dwarf::Tag Tag) {
     // FIXME: It's uncertain whether or not we should handle this at the moment.
   case DIEValue::isExpr:
   case DIEValue::isLabel:
-  case DIEValue::isBaseTypeRef:
   case DIEValue::isDelta:
     llvm_unreachable("Add support for additional value types.");
   }
diff --git a/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h b/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h
index 256a41be237..40360ba4d34 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DebugLocEntry.h
@@ -148,10 +148,8 @@ public:
   }
 
   /// Lower this entry into a DWARF expression.
-  void finalize(const AsmPrinter &AP,
-                DebugLocStream::ListBuilder &List,
-                const DIBasicType *BT,
-                DwarfCompileUnit &TheCU);
+  void finalize(const AsmPrinter &AP, DebugLocStream::ListBuilder &List,
+                const DIBasicType *BT);
 };
 
 /// Compare two Values for equality.
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
index 2a7d143d2f4..0a30ede2d2d 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
@@ -17,7 +17,6 @@
 #include "DwarfUnit.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
@@ -1186,26 +1185,3 @@ void DwarfCompileUnit::addAddrTableBase() {
                                          : dwarf::DW_AT_GNU_addr_base,
                   Label, TLOF.getDwarfAddrSection()->getBeginSymbol());
 }
-
-void DwarfCompileUnit::addBaseTypeRef(DIEValueList &Die, int64_t Idx) {
-  Die.addValue(DIEValueAllocator, (dwarf::Attribute)0, dwarf::DW_FORM_udata,
-               new (DIEValueAllocator) DIEBaseTypeRef(this, Idx));
-}
-
-void DwarfCompileUnit::createBaseTypeDIEs() {
-  // Insert the base_type DIEs directly after the CU so that their offsets will
-  // fit in the fixed size ULEB128 used inside the location expressions.
-  // Maintain order by iterating backwards and inserting to the front of CU
-  // child list.
-  for (auto &Btr : reverse(ExprRefedBaseTypes)) {
-    DIE &Die = getUnitDie().addChildFront(
-      DIE::get(DIEValueAllocator, dwarf::DW_TAG_base_type));
-    Twine T(dwarf::AttributeEncodingString(Btr.Encoding) + "_" + Twine(Btr.BitSize));
-    SmallString<32> Str;
-    addString(Die, dwarf::DW_AT_name, T.toStringRef(Str));
-    addUInt(Die, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1, Btr.Encoding);
-    addUInt(Die, dwarf::DW_AT_byte_size, None, Btr.BitSize / 8);
-
-    Btr.Die = &Die;
-  }
-}
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
index d9addb52376..c5ec49503c6 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h
@@ -124,16 +124,6 @@ public:
     const DIExpression *Expr;
   };
 
-  struct BaseTypeRef {
-    BaseTypeRef(unsigned BitSize, dwarf::TypeKind Encoding) :
-      BitSize(BitSize), Encoding(Encoding) {}
-    unsigned BitSize;
-    dwarf::TypeKind Encoding;
-    DIE *Die = nullptr;
-  };
-
-  std::vector<BaseTypeRef> ExprRefedBaseTypes;
-
   /// Get or create global variable DIE.
   DIE *
   getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,
@@ -209,8 +199,6 @@ public:
                               SmallVectorImpl<DIE *> &Children,
                               bool *HasNonScopeChildren = nullptr);
 
-  void createBaseTypeDIEs();
-
   /// Construct a DIE for this subprogram scope.
   DIE &constructSubprogramScopeDIE(const DISubprogram *Sub,
                                    LexicalScope *Scope);
@@ -325,8 +313,6 @@ public:
   void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
 
   bool hasDwarfPubSections() const;
-
-  void addBaseTypeRef(DIEValueList &Die, int64_t Idx);
 };
 
 } // end namespace llvm
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
index 3e60f15a22d..1106b859859 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp
@@ -41,8 +41,6 @@
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
-#include "llvm/DebugInfo/DWARF/DWARFExpression.h"
-#include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DebugLoc.h"
@@ -163,7 +161,6 @@ static const char *const DWARFGroupName = "dwarf";
 static const char *const DWARFGroupDescription = "DWARF Emission";
 static const char *const DbgTimerName = "writer";
 static const char *const DbgTimerDescription = "DWARF Debug Writer";
-static constexpr unsigned ULEB128PadSize = 4;
 
 void DebugLocDwarfExpression::emitOp(uint8_t Op, const char *Comment) {
   BS.EmitInt8(
@@ -179,11 +176,6 @@ void DebugLocDwarfExpression::emitUnsigned(uint64_t Value) {
   BS.EmitULEB128(Value, Twine(Value));
 }
 
-void DebugLocDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
-  assert(Idx < (1ULL << (ULEB128PadSize * 7)) && "Idx wont fit");
-  BS.EmitULEB128(Idx, Twine(Idx), ULEB128PadSize);
-}
-
 bool DebugLocDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                               unsigned MachineReg) {
   // This information is not available while emitting .debug_loc entries.
@@ -948,11 +940,6 @@ void DwarfDebug::endModule() {
   assert(CurFn == nullptr);
   assert(CurMI == nullptr);
 
-  for (const auto &P : CUMap) {
-    auto &CU = *P.second;
-    CU.createBaseTypeDIEs();
-  }
-
   // If we aren't actually generating debug info (check beginModule -
   // conditionalized on !DisableDebugInfoPrinting and the presence of the
   // llvm.dbg.cu metadata node)
@@ -1382,7 +1369,7 @@ void DwarfDebug::collectEntityInfo(DwarfCompileUnit &TheCU,
 
     // Finalize the entry by lowering it into a DWARF bytestream.
     for (auto &Entry : Entries)
-      Entry.finalize(*Asm, List, BT, TheCU);
+      Entry.finalize(*Asm, List, BT);
   }
 
   // For each InlinedEntity collected from DBG_LABEL instructions, convert to
@@ -1924,55 +1911,13 @@ void DwarfDebug::emitDebugStr() {
                      StringOffsetsSection, /* UseRelativeOffsets = */ true);
 }
 
-void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer, const
-                                   DebugLocStream::Entry &Entry,
-                                   const DwarfCompileUnit *CU) {
+void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
+                                   const DebugLocStream::Entry &Entry) {
   auto &&Comments = DebugLocs.getComments(Entry);
   auto Comment = Comments.begin();
   auto End = Comments.end();
-
-  // The expressions are inserted into a byte stream rather early (see
-  // DwarfExpression::addExpression) so for those ops (e.g. DW_OP_convert) that
-  // need to reference a base_type DIE the offset of that DIE is not yet known.
-  // To deal with this we instead insert a placeholder early and then extract
-  // it here and replace it with the real reference.
-  unsigned PtrSize = Asm->MAI->getCodePointerSize();
-  DWARFDataExtractor Data(StringRef(DebugLocs.getBytes(Entry).data(),
-                                    DebugLocs.getBytes(Entry).size()),
-                          Asm->getDataLayout().isLittleEndian(), PtrSize);
-  DWARFExpression Expr(Data, getDwarfVersion(), PtrSize);
-
-  using Encoding = DWARFExpression::Operation::Encoding;
-  uint32_t Offset = 0;
-  for (auto &Op : Expr) {
-    assert(Op.getCode() != dwarf::DW_OP_const_type &&
-           "3 operand ops not yet supported");
-    Streamer.EmitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
-    Offset++;
-    for (unsigned I = 0; I < 2; ++I) {
-      if (Op.getDescription().Op[I] == Encoding::SizeNA)
-        continue;
-      if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
-          if (CU) {
-            uint64_t Offset = CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die->getOffset();
-            assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
-            Asm->EmitULEB128(Offset, nullptr, ULEB128PadSize);
-          } else {
-            // Emit a reference to the 'generic type'.
-            Asm->EmitULEB128(0, nullptr, ULEB128PadSize);
-          }
-          // Make sure comments stay aligned.
-          for (unsigned J = 0; J < ULEB128PadSize; ++J)
-            if (Comment != End)
-              Comment++;
-      } else {
-        for (uint32_t J = Offset; J < Op.getOperandEndOffset(I); ++J)
-          Streamer.EmitInt8(Data.getData()[J], Comment != End ? *(Comment++) : "");
-      }
-      Offset = Op.getOperandEndOffset(I);
-    }
-    assert(Offset == Op.getEndOffset());
-  }
+  for (uint8_t Byte : DebugLocs.getBytes(Entry))
+    Streamer.EmitInt8(Byte, Comment != End ? *(Comment++) : "");
 }
 
 static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
@@ -2006,12 +1951,11 @@ static void emitDebugLocValue(const AsmPrinter &AP, const DIBasicType *BT,
 
 void DebugLocEntry::finalize(const AsmPrinter &AP,
                              DebugLocStream::ListBuilder &List,
-                             const DIBasicType *BT,
-                             DwarfCompileUnit &TheCU) {
+                             const DIBasicType *BT) {
   assert(Begin != End && "unexpected location list entry with empty range");
   DebugLocStream::EntryBuilder Entry(List, Begin, End);
   BufferByteStreamer Streamer = Entry.getStreamer();
-  DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer, TheCU);
+  DebugLocDwarfExpression DwarfExpr(AP.getDwarfVersion(), Streamer);
   const DebugLocEntry::Value &Value = Values[0];
   if (Value.isFragment()) {
     // Emit all fragments that belong to the same variable and range.
@@ -2031,8 +1975,7 @@ void DebugLocEntry::finalize(const AsmPrinter &AP,
   DwarfExpr.finalize();
 }
 
-void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
-                                           const DwarfCompileUnit *CU) {
+void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry) {
   // Emit the size.
   Asm->OutStreamer->AddComment("Loc expr size");
   if (getDwarfVersion() >= 5)
@@ -2041,7 +1984,7 @@ void DwarfDebug::emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
     Asm->emitInt16(DebugLocs.getBytes(Entry).size());
   // Emit the entry.
   APByteStreamer Streamer(*Asm);
-  emitDebugLocEntry(Streamer, Entry, CU);
+  emitDebugLocEntry(Streamer, Entry);
 }
 
 // Emit the common part of the DWARF 5 range/locations list tables header.
@@ -2141,7 +2084,7 @@ void DwarfDebug::emitDebugLoc() {
           Asm->EmitLabelDifference(Entry.EndSym, Base, Size);
         }
 
-        emitDebugLocEntryLocation(Entry, CU);
+        emitDebugLocEntryLocation(Entry);
         continue;
       }
 
@@ -2162,7 +2105,7 @@ void DwarfDebug::emitDebugLoc() {
         Asm->OutStreamer->EmitSymbolValue(Entry.EndSym, Size);
       }
 
-      emitDebugLocEntryLocation(Entry, CU);
+      emitDebugLocEntryLocation(Entry);
     }
 
     if (IsLocLists) {
@@ -2198,7 +2141,7 @@ void DwarfDebug::emitDebugLocDWO() {
       Asm->EmitULEB128(idx);
       Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
 
-      emitDebugLocEntryLocation(Entry, List.CU);
+      emitDebugLocEntryLocation(Entry);
     }
     Asm->emitInt8(dwarf::DW_LLE_end_of_list);
   }
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h
index ec5040f6c10..f0d50a47640 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h
@@ -682,12 +682,10 @@ public:
   /// Emit an entry for the debug loc section. This can be used to
   /// handle an entry that's going to be emitted into the debug loc section.
   void emitDebugLocEntry(ByteStreamer &Streamer,
-                         const DebugLocStream::Entry &Entry,
-                         const DwarfCompileUnit *CU);
+                         const DebugLocStream::Entry &Entry);
 
   /// Emit the location for a debug loc entry, including the size header.
-  void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry,
-                                 const DwarfCompileUnit *CU);
+  void emitDebugLocEntryLocation(const DebugLocStream::Entry &Entry);
 
   /// Find the MDNode for the given reference.
   template <typename T> T *resolve(TypedDINodeRef<T> Ref) const {
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp
index 41fa45f2507..558d33ac0e6 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp
@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "DwarfExpression.h"
-#include "DwarfCompileUnit.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/SmallBitVector.h"
 #include "llvm/BinaryFormat/Dwarf.h"
@@ -319,8 +318,6 @@ void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor,
   if (SubRegisterSizeInBits && N && (N->getOp() != dwarf::DW_OP_LLVM_fragment))
     maskSubRegister();
 
-  Optional<DIExpression::ExprOperand> PrevConvertOp = None;
-
   while (ExprCursor) {
     auto Op = ExprCursor.take();
     switch (Op->getOp()) {
@@ -387,42 +384,6 @@ void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor,
       assert(LocationKind != Register);
       emitConstu(Op->getArg(0));
       break;
-    case dwarf::DW_OP_LLVM_convert: {
-      unsigned BitSize = Op->getArg(0);
-      dwarf::TypeKind Encoding = static_cast<dwarf::TypeKind>(Op->getArg(1));
-      if (DwarfVersion >= 5) {
-        emitOp(dwarf::DW_OP_convert);
-        // Reuse the base_type if we already have one in this CU otherwise we
-        // create a new one.
-        unsigned I = 0, E = CU.ExprRefedBaseTypes.size();
-        for (; I != E; ++I)
-          if (CU.ExprRefedBaseTypes[I].BitSize == BitSize &&
-              CU.ExprRefedBaseTypes[I].Encoding == Encoding)
-            break;
-
-        if (I == E)
-          CU.ExprRefedBaseTypes.emplace_back(BitSize, Encoding);
-
-        // If targeting a location-list; simply emit the index into the raw
-        // byte stream as ULEB128, DwarfDebug::emitDebugLocEntry has been
-        // fitted with means to extract it later.
-        // If targeting a inlined DW_AT_location; insert a DIEBaseTypeRef
-        // (containing the index and a resolve mechanism during emit) into the
-        // DIE value list.
-        emitBaseTypeRef(I);
-      } else {
-        if (PrevConvertOp && PrevConvertOp->getArg(0) < BitSize) {
-          if (Encoding == dwarf::DW_ATE_signed)
-            emitLegacySExt(PrevConvertOp->getArg(0));
-          else if (Encoding == dwarf::DW_ATE_unsigned)
-            emitLegacyZExt(PrevConvertOp->getArg(0));
-          PrevConvertOp = None;
-        } else {
-          PrevConvertOp = Op;
-        }
-      }
-      break;
-    }
     case dwarf::DW_OP_stack_value:
       LocationKind = Implicit;
       break;
@@ -475,25 +436,3 @@ void DwarfExpression::addFragmentOffset(const DIExpression *Expr) {
     addOpPiece(FragmentOffset - OffsetInBits);
   OffsetInBits = FragmentOffset;
 }
-
-void DwarfExpression::emitLegacySExt(unsigned FromBits) {
-  // (((X >> (FromBits - 1)) * (~0)) << FromBits) | X
-  emitOp(dwarf::DW_OP_dup);
-  emitOp(dwarf::DW_OP_constu);
-  emitUnsigned(FromBits - 1);
-  emitOp(dwarf::DW_OP_shr);
-  emitOp(dwarf::DW_OP_lit0);
-  emitOp(dwarf::DW_OP_not);
-  emitOp(dwarf::DW_OP_mul);
-  emitOp(dwarf::DW_OP_constu);
-  emitUnsigned(FromBits);
-  emitOp(dwarf::DW_OP_shl);
-  emitOp(dwarf::DW_OP_or);
-}
-
-void DwarfExpression::emitLegacyZExt(unsigned FromBits) {
-  // (X & (1 << FromBits - 1))
-  emitOp(dwarf::DW_OP_constu);
-  emitUnsigned((1ULL << FromBits) - 1);
-  emitOp(dwarf::DW_OP_and);
-}
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h b/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h
index 18bedf0b902..1f7b89fe5fc 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.h
@@ -27,7 +27,7 @@ namespace llvm {
 class AsmPrinter;
 class APInt;
 class ByteStreamer;
-class DwarfCompileUnit;
+class DwarfUnit;
 class DIELoc;
 class TargetRegisterInfo;
 
@@ -104,8 +104,6 @@ protected:
     const char *Comment;
   };
 
-  DwarfCompileUnit &CU;
-
   /// The register location, if any.
   SmallVector<Register, 2> DwarfRegs;
 
@@ -139,8 +137,6 @@ protected:
   /// Emit a raw unsigned value.
   virtual void emitUnsigned(uint64_t Value) = 0;
 
-  virtual void emitBaseTypeRef(uint64_t Idx) = 0;
-
   /// Emit a normalized unsigned constant.
   void emitConstu(uint64_t Value);
 
@@ -203,8 +199,7 @@ protected:
   ~DwarfExpression() = default;
 
 public:
-  DwarfExpression(unsigned DwarfVersion, DwarfCompileUnit &CU)
-    : CU(CU), DwarfVersion(DwarfVersion) {}
+  DwarfExpression(unsigned DwarfVersion) : DwarfVersion(DwarfVersion) {}
 
   /// This needs to be called last to commit any pending changes.
   void finalize();
@@ -252,9 +247,6 @@ public:
   /// If applicable, emit an empty DW_OP_piece / DW_OP_bit_piece to advance to
   /// the fragment described by \c Expr.
   void addFragmentOffset(const DIExpression *Expr);
-
-  void emitLegacySExt(unsigned FromBits);
-  void emitLegacyZExt(unsigned FromBits);
 };
 
 /// DwarfExpression implementation for .debug_loc entries.
@@ -264,28 +256,27 @@ class DebugLocDwarfExpression final : public DwarfExpression {
   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
   void emitSigned(int64_t Value) override;
   void emitUnsigned(uint64_t Value) override;
-  void emitBaseTypeRef(uint64_t Idx) override;
   bool isFrameRegister(const TargetRegisterInfo &TRI,
                        unsigned MachineReg) override;
 
 public:
-  DebugLocDwarfExpression(unsigned DwarfVersion, ByteStreamer &BS, DwarfCompileUnit &CU)
-      : DwarfExpression(DwarfVersion, CU), BS(BS) {}
+  DebugLocDwarfExpression(unsigned DwarfVersion, ByteStreamer &BS)
+      : DwarfExpression(DwarfVersion), BS(BS) {}
 };
 
 /// DwarfExpression implementation for singular DW_AT_location.
 class DIEDwarfExpression final : public DwarfExpression {
 const AsmPrinter &AP;
+  DwarfUnit &DU;
   DIELoc &DIE;
 
   void emitOp(uint8_t Op, const char *Comment = nullptr) override;
   void emitSigned(int64_t Value) override;
   void emitUnsigned(uint64_t Value) override;
-  void emitBaseTypeRef(uint64_t Idx) override;
   bool isFrameRegister(const TargetRegisterInfo &TRI,
                        unsigned MachineReg) override;
 public:
-  DIEDwarfExpression(const AsmPrinter &AP, DwarfCompileUnit &CU, DIELoc &DIE);
+  DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU, DIELoc &DIE);
 
   DIELoc *finalize() {
     DwarfExpression::finalize();
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h b/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h
index e550c6385b0..b3026a35b85 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfFile.h
@@ -147,7 +147,7 @@ public:
   void emitUnits(bool UseOffsets);
 
   /// Emit the given unit to its section.
-  void emitUnit(DwarfUnit *TheU, bool UseOffsets);
+  void emitUnit(DwarfUnit *U, bool UseOffsets);
 
   /// Emit a set of abbreviations to the specific section.
   void emitAbbrevs(MCSection *);
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
index 6e547469c24..b19dc4b2506 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
@@ -46,26 +46,21 @@ using namespace llvm;
 
 #define DEBUG_TYPE "dwarfdebug"
 
-DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP,
-                                       DwarfCompileUnit &CU,
+DIEDwarfExpression::DIEDwarfExpression(const AsmPrinter &AP, DwarfUnit &DU,
                                        DIELoc &DIE)
-    : DwarfExpression(AP.getDwarfVersion(), CU), AP(AP),
+    : DwarfExpression(AP.getDwarfVersion()), AP(AP), DU(DU),
       DIE(DIE) {}
 
 void DIEDwarfExpression::emitOp(uint8_t Op, const char* Comment) {
-  CU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
+  DU.addUInt(DIE, dwarf::DW_FORM_data1, Op);
 }
 
 void DIEDwarfExpression::emitSigned(int64_t Value) {
-  CU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
+  DU.addSInt(DIE, dwarf::DW_FORM_sdata, Value);
 }
 
 void DIEDwarfExpression::emitUnsigned(uint64_t Value) {
-  CU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
-}
-
-void DIEDwarfExpression::emitBaseTypeRef(uint64_t Idx) {
-  CU.addBaseTypeRef(DIE, Idx);
+  DU.addUInt(DIE, dwarf::DW_FORM_udata, Value);
 }
 
 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
diff --git a/llvm/lib/CodeGen/AsmPrinter/LLVMBuild.txt b/llvm/lib/CodeGen/AsmPrinter/LLVMBuild.txt
index 56449269681..88d7c13ce03 100644
--- a/llvm/lib/CodeGen/AsmPrinter/LLVMBuild.txt
+++ b/llvm/lib/CodeGen/AsmPrinter/LLVMBuild.txt
@@ -18,4 +18,4 @@
 type = Library
 name = AsmPrinter
 parent = Libraries
-required_libraries = Analysis BinaryFormat CodeGen Core DebugInfoCodeView DebugInfoDWARF DebugInfoMSF MC MCParser Support Target
+required_libraries = Analysis BinaryFormat CodeGen Core DebugInfoCodeView DebugInfoMSF MC MCParser Support Target
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
index 6bac12f765d..366b4df6657 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
@@ -225,7 +225,6 @@ void DWARFDebugLoclists::LocationList::dump(raw_ostream &OS, uint64_t BaseAddr,
                                             bool IsLittleEndian,
                                             unsigned AddressSize,
                                             const MCRegisterInfo *MRI,
-                                            DWARFUnit *U,
                                             unsigned Indent) const {
   for (const Entry &E : Entries) {
     switch (E.Kind) {
@@ -255,7 +254,7 @@ void DWARFDebugLoclists::LocationList::dump(raw_ostream &OS, uint64_t BaseAddr,
       llvm_unreachable("unreachable locations list kind");
     }
 
-    dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI, U);
+    dumpExpression(OS, E.Loc, IsLittleEndian, AddressSize, MRI, nullptr);
   }
 }
 
@@ -264,7 +263,7 @@ void DWARFDebugLoclists::dump(raw_ostream &OS, uint64_t BaseAddr,
                               Optional<uint64_t> Offset) const {
   auto DumpLocationList = [&](const LocationList &L) {
     OS << format("0x%8.8x: ", L.Offset);
-    L.dump(OS, BaseAddr, IsLittleEndian, AddressSize, MRI, nullptr, /*Indent=*/12);
+    L.dump(OS, BaseAddr, IsLittleEndian, AddressSize, MRI, /*Indent=*/12);
     OS << "\n\n";
   };
 
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp
index 4a837cd3526..4cd69bc8017 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFDie.cpp
@@ -130,7 +130,7 @@ static void dumpLocation(raw_ostream &OS, DWARFFormValue &FormValue,
 
       if (LL)
         LL->dump(OS, BaseAddr, Ctx.isLittleEndian(), Obj.getAddressSize(), MRI,
-                 U, Indent);
+                 Indent);
       else
         OS << "error extracting location list.";
     }
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
index 133b85a0969..24400ff89c6 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
@@ -188,8 +188,6 @@ bool DWARFExpression::Operation::extract(DataExtractor Data, uint16_t Version,
     default:
       llvm_unreachable("Unknown DWARFExpression Op size");
     }
-
-    OperandEndOffsets[Operand] = Offset;
   }
 
   EndOffset = Offset;
diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
index 07dea403d56..af3db5186a2 100644
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -2123,13 +2123,8 @@ static void writeDIExpression(raw_ostream &Out, const DIExpression *N,
       assert(!OpStr.empty() && "Expected valid opcode");
 
       Out << FS << OpStr;
-      if (I->getOp() == dwarf::DW_OP_LLVM_convert) {
-        Out << FS << I->getArg(0);
-        Out << FS << dwarf::AttributeEncodingString(I->getArg(1));
-      } else {
-        for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
-          Out << FS << I->getArg(A);
-      }
+      for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
+        Out << FS << I->getArg(A);
     }
   } else {
     for (const auto &I : N->getElements())
diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp
index 0ae408af041..f772276613c 100644
--- a/llvm/lib/IR/DebugInfoMetadata.cpp
+++ b/llvm/lib/IR/DebugInfoMetadata.cpp
@@ -813,7 +813,6 @@ DIExpression *DIExpression::getImpl(LLVMContext &Context,
 
 unsigned DIExpression::ExprOperand::getSize() const {
   switch (getOp()) {
-  case dwarf::DW_OP_LLVM_convert:
   case dwarf::DW_OP_LLVM_fragment:
     return 3;
   case dwarf::DW_OP_constu:
@@ -858,7 +857,6 @@ bool DIExpression::isValid() const {
         return false;
       break;
     }
-    case dwarf::DW_OP_LLVM_convert:
     case dwarf::DW_OP_constu:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:
diff --git a/llvm/lib/MC/MCStreamer.cpp b/llvm/lib/MC/MCStreamer.cpp
index 2d615f2bfd1..554cce1214a 100644
--- a/llvm/lib/MC/MCStreamer.cpp
+++ b/llvm/lib/MC/MCStreamer.cpp
@@ -135,10 +135,10 @@ void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
 
 /// EmitULEB128IntValue - Special case of EmitULEB128Value that avoids the
 /// client having to pass in a MCExpr for constant integers.
-void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned PadTo) {
+void MCStreamer::EmitULEB128IntValue(uint64_t Value) {
   SmallString<128> Tmp;
   raw_svector_ostream OSE(Tmp);
-  encodeULEB128(Value, OSE, PadTo);
+  encodeULEB128(Value, OSE);
   EmitBytes(OSE.str());
 }
 
diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp
index 9271e1dda5a..d14384fe576 100644
--- a/llvm/lib/Transforms/Utils/Local.cpp
+++ b/llvm/lib/Transforms/Utils/Local.cpp
@@ -1861,10 +1861,21 @@ bool llvm::replaceAllDbgUsesWith(Instruction &From, Value &To,
         return None;
 
       bool Signed = *Signedness == DIBasicType::Signedness::Signed;
-      dwarf::TypeKind TK = Signed ? dwarf::DW_ATE_signed : dwarf::DW_ATE_unsigned;
-      SmallVector<uint64_t, 8> Ops({dwarf::DW_OP_LLVM_convert, ToBits, TK,
-                                   dwarf::DW_OP_LLVM_convert, FromBits, TK});
-      return DIExpression::appendToStack(DII.getExpression(), Ops);
+
+      if (!Signed) {
+        // In the unsigned case, assume that a debugger will initialize the
+        // high bits to 0 and do a no-op conversion.
+        return Identity(DII);
+      } else {
+        // In the signed case, the high bits are given by sign extension, i.e:
+        //   (To >> (ToBits - 1)) * ((2 ^ FromBits) - 1)
+        // Calculate the high bits and OR them together with the low bits.
+        SmallVector<uint64_t, 8> Ops({dwarf::DW_OP_dup, dwarf::DW_OP_constu,
+                                      (ToBits - 1), dwarf::DW_OP_shr,
+                                      dwarf::DW_OP_lit0, dwarf::DW_OP_not,
+                                      dwarf::DW_OP_mul, dwarf::DW_OP_or});
+        return DIExpression::appendToStack(DII.getExpression(), Ops);
+      }
     };
     return rewriteDebugUsers(From, To, DomPoint, DT, SignOrZeroExt);
   }
diff --git a/llvm/test/Assembler/diexpression.ll b/llvm/test/Assembler/diexpression.ll
index b633ba6a435..b6d2cc2dc57 100644
--- a/llvm/test/Assembler/diexpression.ll
+++ b/llvm/test/Assembler/diexpression.ll
@@ -8,10 +8,9 @@
 ; CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 3, 7),
 ; CHECK-SAME: !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 3, DW_OP_LLVM_fragment, 3, 7),
 ; CHECK-SAME: !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef),
-; CHECK-SAME: !DIExpression(DW_OP_plus_uconst, 3)
-; CHECK-SAME: !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_signed)}
+; CHECK-SAME: !DIExpression(DW_OP_plus_uconst, 3)}
 
-!named = !{!0, !1, !2, !3, !4, !5, !6, !7}
+!named = !{!0, !1, !2, !3, !4, !5, !6}
 
 !0 = !DIExpression()
 !1 = !DIExpression(DW_OP_deref)
@@ -20,4 +19,3 @@
 !4 = !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 3, DW_OP_LLVM_fragment, 3, 7)
 !5 = !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef)
 !6 = !DIExpression(DW_OP_plus_uconst, 3)
-!7 = !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_signed)
diff --git a/llvm/test/DebugInfo/Generic/convert-debugloc.ll b/llvm/test/DebugInfo/Generic/convert-debugloc.ll
deleted file mode 100644
index 76b333c9b75..00000000000
--- a/llvm/test/DebugInfo/Generic/convert-debugloc.ll
+++ /dev/null
@@ -1,164 +0,0 @@
-; RUN: llc -dwarf-version=5 -filetype=obj -O0 < %s | llvm-dwarfdump - | FileCheck %s --match-full-lines --check-prefix=DW5-CHECK
-; RUN: llc -dwarf-version=4 -filetype=obj -O0 < %s | llvm-dwarfdump - | FileCheck %s --match-full-lines --check-prefix=DW4-CHECK
-
-; DW5-CHECK: .debug_info contents:
-; DW5-CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000005c version = 0x0005 unit_type = DW_UT_compile abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000060)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000000c: DW_TAG_compile_unit
-; DW5-CHECK-NEXT:               DW_AT_producer	("clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)")
-; DW5-CHECK-NEXT:               DW_AT_language	(DW_LANG_C99)
-; DW5-CHECK-NEXT:               DW_AT_name	("dbg.c")
-; DW5-CHECK-NEXT:               DW_AT_str_offsets_base	(0x00000008)
-; DW5-CHECK-NEXT:               DW_AT_stmt_list	(0x00000000)
-; DW5-CHECK-NEXT:               DW_AT_comp_dir	("/tmp")
-; DW5-CHECK-NEXT:               DW_AT_addr_base	(0x00000008)
-; DW5-CHECK-NEXT:               DW_AT_low_pc	(0x0000000000000000)
-; DW5-CHECK-NEXT:               DW_AT_high_pc	(0x0000000000000007)
-; DW5-CHECK-NEXT:               DW_AT_loclists_base	(0x0000000c)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x00000027:   DW_TAG_base_type
-; DW5-CHECK-NEXT:                 DW_AT_name	("DW_ATE_signed_8")
-; DW5-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW5-CHECK-NEXT:                 DW_AT_byte_size	(0x01)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000002b:   DW_TAG_base_type
-; DW5-CHECK-NEXT:                 DW_AT_name	("DW_ATE_signed_32")
-; DW5-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW5-CHECK-NEXT:                 DW_AT_byte_size	(0x04)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000002f:   DW_TAG_subprogram
-; DW5-CHECK-NEXT:                 DW_AT_low_pc	(0x0000000000000000)
-; DW5-CHECK-NEXT:                 DW_AT_high_pc	(0x0000000000000007)
-; DW5-CHECK-NEXT:                 DW_AT_frame_base	(DW_OP_reg7 RSP)
-; DW5-CHECK-NEXT:                 DW_AT_name	("foo")
-; DW5-CHECK-NEXT:                 DW_AT_decl_file	("/tmp/dbg.c")
-; DW5-CHECK-NEXT:                 DW_AT_decl_line	(1)
-; DW5-CHECK-NEXT:                 DW_AT_prototyped	(true)
-; DW5-CHECK-NEXT:                 DW_AT_type	(0x00000057 "signed char")
-; DW5-CHECK-NEXT:                 DW_AT_external	(true)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000003e:     DW_TAG_formal_parameter
-; DW5-CHECK-NEXT:                   DW_AT_location	(0x0000000c
-; DW5-CHECK-NEXT:                      [0x0000000000000003, 0x0000000000000006): DW_OP_reg0 RAX)
-; DW5-CHECK-NEXT:                   DW_AT_name	("x")
-; DW5-CHECK-NEXT:                   DW_AT_decl_file	("/tmp/dbg.c")
-; DW5-CHECK-NEXT:                   DW_AT_decl_line	(1)
-; DW5-CHECK-NEXT:                   DW_AT_type	(0x00000057 "signed char")
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000004a:     DW_TAG_variable
-; DW5-CHECK-NEXT:                   DW_AT_location	(0x00000012
-; DW5-CHECK-NEXT:                      [0x0000000000000003, 0x0000000000000006): DW_OP_breg0 RAX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_convert (0x00000027) "DW_ATE_signed_8", DW_OP_convert (0x0000002b) "DW_ATE_signed_32", DW_OP_stack_value)
-; DW5-CHECK-NEXT:                   DW_AT_name	("y")
-; DW5-CHECK-NEXT:                   DW_AT_decl_file	("/tmp/dbg.c")
-; DW5-CHECK-NEXT:                   DW_AT_decl_line	(3)
-; DW5-CHECK-NEXT:                   DW_AT_type	(0x0000005b "int")
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x00000056:     NULL
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x00000057:   DW_TAG_base_type
-; DW5-CHECK-NEXT:                 DW_AT_name	("signed char")
-; DW5-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed_char)
-; DW5-CHECK-NEXT:                 DW_AT_byte_size	(0x01)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000005b:   DW_TAG_base_type
-; DW5-CHECK-NEXT:                 DW_AT_name	("int")
-; DW5-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW5-CHECK-NEXT:                 DW_AT_byte_size	(0x04)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000005f:   NULL
-
-
-; DW4-CHECK: .debug_info contents:
-; DW4-CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000006d version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000071)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x0000000b: DW_TAG_compile_unit
-; DW4-CHECK-NEXT:               DW_AT_producer	("clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)")
-; DW4-CHECK-NEXT:               DW_AT_language	(DW_LANG_C99)
-; DW4-CHECK-NEXT:               DW_AT_name	("dbg.c")
-; DW4-CHECK-NEXT:               DW_AT_stmt_list	(0x00000000)
-; DW4-CHECK-NEXT:               DW_AT_comp_dir	("/tmp")
-; DW4-CHECK-NEXT:               DW_AT_low_pc	(0x0000000000000000)
-; DW4-CHECK-NEXT:               DW_AT_high_pc	(0x0000000000000007)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x0000002a:   DW_TAG_subprogram
-; DW4-CHECK-NEXT:                 DW_AT_low_pc	(0x0000000000000000)
-; DW4-CHECK-NEXT:                 DW_AT_high_pc	(0x0000000000000007)
-; DW4-CHECK-NEXT:                 DW_AT_frame_base	(DW_OP_reg7 RSP)
-; DW4-CHECK-NEXT:                 DW_AT_name	("foo")
-; DW4-CHECK-NEXT:                 DW_AT_decl_file	("/tmp/dbg.c")
-; DW4-CHECK-NEXT:                 DW_AT_decl_line	(1)
-; DW4-CHECK-NEXT:                 DW_AT_prototyped	(true)
-; DW4-CHECK-NEXT:                 DW_AT_type	(0x00000062 "signed char")
-; DW4-CHECK-NEXT:                 DW_AT_external	(true)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000043:     DW_TAG_formal_parameter
-; DW4-CHECK-NEXT:                   DW_AT_location	(0x00000000
-; DW4-CHECK-NEXT:                      [0x0000000000000003,  0x0000000000000006): DW_OP_reg0 RAX)
-; DW4-CHECK-NEXT:                   DW_AT_name	("x")
-; DW4-CHECK-NEXT:                   DW_AT_decl_file	("/tmp/dbg.c")
-; DW4-CHECK-NEXT:                   DW_AT_decl_line	(1)
-; DW4-CHECK-NEXT:                   DW_AT_type	(0x00000062 "signed char")
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000052:     DW_TAG_variable
-; DW4-CHECK-NEXT:                   DW_AT_location	(0x00000023
-; DW4-CHECK-NEXT:                      [0x0000000000000003,  0x0000000000000006): DW_OP_breg0 RAX+0, DW_OP_constu 0xff, DW_OP_and, DW_OP_dup, DW_OP_constu 0x7, DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_constu 0x8, DW_OP_shl, DW_OP_or, DW_OP_stack_value)
-; DW4-CHECK-NEXT:                   DW_AT_name	("y")
-; DW4-CHECK-NEXT:                   DW_AT_decl_file	("/tmp/dbg.c")
-; DW4-CHECK-NEXT:                   DW_AT_decl_line	(3)
-; DW4-CHECK-NEXT:                   DW_AT_type	(0x00000069 "int")
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000061:     NULL
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000062:   DW_TAG_base_type
-; DW4-CHECK-NEXT:                 DW_AT_name	("signed char")
-; DW4-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed_char)
-; DW4-CHECK-NEXT:                 DW_AT_byte_size	(0x01)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000069:   DW_TAG_base_type
-; DW4-CHECK-NEXT:                 DW_AT_name	("int")
-; DW4-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW4-CHECK-NEXT:                 DW_AT_byte_size	(0x04)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000070:   NULL
-
-
-; ModuleID = 'dbg.ll'
-source_filename = "dbg.c"
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
-; Function Attrs: noinline nounwind uwtable
-define dso_local signext i8 @foo(i8 signext %x) !dbg !7 {
-entry:
-  call void @llvm.dbg.value(metadata i8 %x, metadata !11, metadata !DIExpression()), !dbg !12
-  call void @llvm.dbg.value(metadata i8 %x, metadata !13, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)), !dbg !15
-  ret i8 %x, !dbg !16
-}
-
-; Function Attrs: nounwind readnone speculatable
-declare void @llvm.dbg.declare(metadata, metadata, metadata)
-
-; Function Attrs: nounwind readnone speculatable
-declare void @llvm.dbg.value(metadata, metadata, metadata)
-
-!llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
-!llvm.ident = !{!6}
-
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
-!1 = !DIFile(filename: "dbg.c", directory: "/tmp", checksumkind: CSK_MD5, checksum: "2a034da6937f5b9cf6dd2d89127f57fd")
-!2 = !{}
-!3 = !{i32 2, !"Dwarf Version", i32 5}
-!4 = !{i32 2, !"Debug Info Version", i32 3}
-!5 = !{i32 1, !"wchar_size", i32 4}
-!6 = !{!"clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)"}
-!7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !8, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
-!8 = !DISubroutineType(types: !9)
-!9 = !{!10, !10}
-!10 = !DIBasicType(name: "signed char", size: 8, encoding: DW_ATE_signed_char)
-!11 = !DILocalVariable(name: "x", arg: 1, scope: !7, file: !1, line: 1, type: !10)
-!12 = !DILocation(line: 1, column: 29, scope: !7)
-!13 = !DILocalVariable(name: "y", scope: !7, file: !1, line: 3, type: !14)
-!14 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!15 = !DILocation(line: 3, column: 14, scope: !7)
-!16 = !DILocation(line: 4, column: 3, scope: !7)
diff --git a/llvm/test/DebugInfo/Generic/convert-inlined.ll b/llvm/test/DebugInfo/Generic/convert-inlined.ll
deleted file mode 100644
index 95f04f770ee..00000000000
--- a/llvm/test/DebugInfo/Generic/convert-inlined.ll
+++ /dev/null
@@ -1,87 +0,0 @@
-; RUN: llc -dwarf-version=5 -filetype=obj -O0 < %s | llvm-dwarfdump - | FileCheck %s --match-full-lines --check-prefix=DW5-CHECK
-; RUN: llc -dwarf-version=4 -filetype=obj -O0 < %s | llvm-dwarfdump - | FileCheck %s --match-full-lines --check-prefix=DW4-CHECK
-
-; DW5-CHECK: .debug_info contents:
-; DW5-CHECK-NEXT: 0x00000000: Compile Unit: length = 0x0000003e version = 0x0005 unit_type = DW_UT_compile abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000042)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000000c: DW_TAG_compile_unit
-; DW5-CHECK-NEXT:               DW_AT_producer	("clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)")
-; DW5-CHECK-NEXT:               DW_AT_language	(DW_LANG_C99)
-; DW5-CHECK-NEXT:               DW_AT_name	("dbg.c")
-; DW5-CHECK-NEXT:               DW_AT_str_offsets_base	(0x00000008)
-; DW5-CHECK-NEXT:               DW_AT_stmt_list	(0x00000000)
-; DW5-CHECK-NEXT:               DW_AT_comp_dir	("/tmp")
-; DW5-CHECK-NEXT:               DW_AT_addr_base	(0x00000008)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000001e:   DW_TAG_base_type
-; DW5-CHECK-NEXT:                 DW_AT_name	("DW_ATE_signed_8")
-; DW5-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW5-CHECK-NEXT:                 DW_AT_byte_size	(0x01)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x00000022:   DW_TAG_base_type
-; DW5-CHECK-NEXT:                 DW_AT_name	("DW_ATE_signed_32")
-; DW5-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW5-CHECK-NEXT:                 DW_AT_byte_size	(0x04)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x00000026:   DW_TAG_variable
-; DW5-CHECK-NEXT:                 DW_AT_name	("global")
-; DW5-CHECK-NEXT:                 DW_AT_type	(0x0000003d "int")
-; DW5-CHECK-NEXT:                 DW_AT_external	(true)
-; DW5-CHECK-NEXT:                 DW_AT_decl_file	("/tmp/dbg.c")
-; DW5-CHECK-NEXT:                 DW_AT_decl_line	(1)
-; DW5-CHECK-NEXT:                 DW_AT_location	(DW_OP_addrx 0x0, DW_OP_deref, DW_OP_convert (0x0000001e) "DW_ATE_signed_8", DW_OP_convert (0x00000022) "DW_ATE_signed_32", DW_OP_stack_value)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x0000003d:   DW_TAG_base_type
-; DW5-CHECK-NEXT:                 DW_AT_name	("int")
-; DW5-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW5-CHECK-NEXT:                 DW_AT_byte_size	(0x04)
-; DW5-CHECK-EMPTY:
-; DW5-CHECK-NEXT: 0x00000041:   NULL
-
-
-; DW4-CHECK: .debug_info contents:
-; DW4-CHECK-NEXT: 0x00000000: Compile Unit: length = 0x00000044 version = 0x0004 abbr_offset = 0x0000 addr_size = 0x08 (next unit at 0x00000048)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x0000000b: DW_TAG_compile_unit
-; DW4-CHECK-NEXT:               DW_AT_producer	("clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)")
-; DW4-CHECK-NEXT:               DW_AT_language	(DW_LANG_C99)
-; DW4-CHECK-NEXT:               DW_AT_name	("dbg.c")
-; DW4-CHECK-NEXT:               DW_AT_stmt_list	(0x00000000)
-; DW4-CHECK-NEXT:               DW_AT_comp_dir	("/tmp")
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x0000001e:   DW_TAG_variable
-; DW4-CHECK-NEXT:                 DW_AT_name	("global")
-; DW4-CHECK-NEXT:                 DW_AT_type	(0x00000040 "int")
-; DW4-CHECK-NEXT:                 DW_AT_external	(true)
-; DW4-CHECK-NEXT:                 DW_AT_decl_file	("/tmp/dbg.c")
-; DW4-CHECK-NEXT:                 DW_AT_decl_line	(1)
-; DW4-CHECK-NEXT:                 DW_AT_location	(DW_OP_addr 0x0, DW_OP_deref, DW_OP_dup, DW_OP_constu 0x7, DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_constu 0x8, DW_OP_shl, DW_OP_or, DW_OP_stack_value)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000040:   DW_TAG_base_type
-; DW4-CHECK-NEXT:                 DW_AT_name	("int")
-; DW4-CHECK-NEXT:                 DW_AT_encoding	(DW_ATE_signed)
-; DW4-CHECK-NEXT:                 DW_AT_byte_size	(0x04)
-; DW4-CHECK-EMPTY:
-; DW4-CHECK-NEXT: 0x00000047:   NULL
-
-source_filename = "dbg.c"
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
-@global = dso_local global i32 255, align 4, !dbg !0
-
-!llvm.dbg.cu = !{!2}
-!llvm.module.flags = !{!7, !8, !9}
-!llvm.ident = !{!10}
-
-!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression(DW_OP_deref, DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value))
-!1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
-!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
-!3 = !DIFile(filename: "dbg.c", directory: "/tmp", checksumkind: CSK_MD5, checksum: "7c731722dd7304ccb8e366ae80269b82")
-!4 = !{}
-!5 = !{!0}
-!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!7 = !{i32 2, !"Dwarf Version", i32 5}
-!8 = !{i32 2, !"Debug Info Version", i32 3}
-!9 = !{i32 1, !"wchar_size", i32 4}
-!10 = !{!"clang version 9.0.0 (trunk 353791) (llvm/trunk 353801)"}
diff --git a/llvm/test/DebugInfo/Generic/convert-linked.ll b/llvm/test/DebugInfo/Generic/convert-linked.ll
deleted file mode 100644
index 8d277d8649e..00000000000
--- a/llvm/test/DebugInfo/Generic/convert-linked.ll
+++ /dev/null
@@ -1,72 +0,0 @@
-; RUN: llc -filetype=obj -O0 < %s | llvm-dwarfdump - | FileCheck %s
-
-; CHECK: DW_TAG_compile_unit
-; CHECK: [[CU0BT0:0x[0-9a-f]+]]: DW_TAG_base_type
-; CHECK-NEXT: DW_ATE_signed_8
-; CHECK: [[CU0BT1:0x[0-9a-f]+]]: DW_TAG_base_type
-; CHECK-NEXT: DW_ATE_signed_32
-; CHECK: DW_TAG_variable
-; CHECK: DW_OP_convert ([[CU0BT0]]) "DW_ATE_signed_8", DW_OP_convert ([[CU0BT1]]) "DW_ATE_signed_32"
-
-; CHECK: DW_TAG_compile_unit
-; CHECK: [[CU1BT0:0x[0-9a-f]+]]: DW_TAG_base_type
-; CHECK-NEXT: DW_ATE_signed_8
-; CHECK: [[CU1BT1:0x[0-9a-f]+]]: DW_TAG_base_type
-; CHECK-NEXT: DW_ATE_signed_16
-; CHECK: DW_TAG_variable
-; CHECK: DW_OP_convert ([[CU1BT0]]) "DW_ATE_signed_8", DW_OP_convert ([[CU1BT1]]) "DW_ATE_signed_16"
-
-; ModuleID = 'llvm-link'
-source_filename = "llvm-link"
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-unknown-linux-gnu"
-
-define dso_local signext i8 @foo(i8 signext %x) !dbg !9 {
-entry:
-  call void @llvm.dbg.value(metadata i8 %x, metadata !13, metadata !DIExpression()), !dbg !14
-  call void @llvm.dbg.value(metadata i8 %x, metadata !15, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)), !dbg !17
-  ret i8 %x, !dbg !18
-}
-
-define dso_local signext i8 @bar(i8 signext %x) !dbg !19 {
-entry:
-  call void @llvm.dbg.value(metadata i8 %x, metadata !20, metadata !DIExpression()), !dbg !21
-  call void @llvm.dbg.value(metadata i8 %x, metadata !22, metadata !DIExpression(DW_OP_LLVM_convert, 8, DW_ATE_signed, DW_OP_LLVM_convert, 16, DW_ATE_signed, DW_OP_stack_value)), !dbg !24
-  ret i8 %x, !dbg !25
-}
-
-; Function Attrs: nounwind readnone speculatable
-declare void @llvm.dbg.value(metadata, metadata, metadata) #1
-
-attributes #1 = { nounwind readnone speculatable }
-
-!llvm.dbg.cu = !{!0, !3}
-!llvm.ident = !{!5, !5}
-!llvm.module.flags = !{!6, !7, !8}
-
-!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 9.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
-!1 = !DIFile(filename: "dbg-foo.c", directory: "/tmp", checksumkind: CSK_MD5, checksum: "b35f80a032deb2a30bc187d564b5a775")
-!2 = !{}
-!3 = distinct !DICompileUnit(language: DW_LANG_C99, file: !4, producer: "clang version 9.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
-!4 = !DIFile(filename: "dbg-bar.c", directory: "/tmp", checksumkind: CSK_MD5, checksum: "9836bb594260d883960455e7d8bc51ea")
-!5 = !{!"clang version 9.0.0 "}
-!6 = !{i32 2, !"Dwarf Version", i32 5}
-!7 = !{i32 2, !"Debug Info Version", i32 3}
-!8 = !{i32 1, !"wchar_size", i32 4}
-!9 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 7, type: !10, scopeLine: 8, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
-!10 = !DISubroutineType(types: !11)
-!11 = !{!12, !12}
-!12 = !DIBasicType(name: "signed char", size: 8, encoding: DW_ATE_signed_char)
-!13 = !DILocalVariable(name: "x", arg: 1, scope: !9, file: !1, line: 7, type: !12)
-!14 = !DILocation(line: 7, column: 29, scope: !9)
-!15 = !DILocalVariable(name: "y", scope: !9, file: !1, line: 9, type: !16)
-!16 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
-!17 = !DILocation(line: 9, column: 14, scope: !9)
-!18 = !DILocation(line: 10, column: 3, scope: !9)
-!19 = distinct !DISubprogram(name: "bar", scope: !4, file: !4, line: 1, type: !10, scopeLine: 2, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !3, retainedNodes: !2)
-!20 = !DILocalVariable(name: "x", arg: 1, scope: !19, file: !4, line: 1, type: !12)
-!21 = !DILocation(line: 1, column: 29, scope: !19)
-!22 = !DILocalVariable(name: "z", scope: !19, file: !4, line: 3, type: !23)
-!23 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
-!24 = !DILocation(line: 3, column: 16, scope: !19)
-!25 = !DILocation(line: 4, column: 3, scope: !19)
diff --git a/llvm/test/Transforms/InstCombine/cast-set-preserve-signed-dbg-val.ll b/llvm/test/Transforms/InstCombine/cast-set-preserve-signed-dbg-val.ll
index 4d780aa9081..74fdfa88cd1 100644
--- a/llvm/test/Transforms/InstCombine/cast-set-preserve-signed-dbg-val.ll
+++ b/llvm/test/Transforms/InstCombine/cast-set-preserve-signed-dbg-val.ll
@@ -14,7 +14,7 @@ define i16 @test5(i16 %A) !dbg !34 {
   ;
   ; The high 16 bits of the original 'and' require sign-extending the new 16-bit and:
   ; CHECK-NEXT: call void @llvm.dbg.value(metadata i16 [[and]], metadata [[C:![0-9]+]],
-  ; CHECK-SAME:    metadata !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_stack_value)
+  ; CHECK-SAME:    metadata !DIExpression(DW_OP_dup, DW_OP_constu, 15, DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_or, DW_OP_stack_value)
 
   %D = trunc i32 %C to i16, !dbg !42
   call void @llvm.dbg.value(metadata i16 %D, metadata !38, metadata !DIExpression()), !dbg !42
diff --git a/llvm/unittests/Transforms/Utils/LocalTest.cpp b/llvm/unittests/Transforms/Utils/LocalTest.cpp
index f83e10af756..80f263d24a7 100644
--- a/llvm/unittests/Transforms/Utils/LocalTest.cpp
+++ b/llvm/unittests/Transforms/Utils/LocalTest.cpp
@@ -788,35 +788,31 @@ TEST(Local, ReplaceAllDbgUsesWith) {
   };
 
   // Case 1: The original expr is empty, so no deref is needed.
-  EXPECT_TRUE(hasADbgVal({DW_OP_LLVM_convert, 32, DW_ATE_signed,
-                         DW_OP_LLVM_convert, 64, DW_ATE_signed,
-                         DW_OP_stack_value}));
+  EXPECT_TRUE(hasADbgVal({DW_OP_dup, DW_OP_constu, 31, DW_OP_shr, DW_OP_lit0,
+                          DW_OP_not, DW_OP_mul, DW_OP_or, DW_OP_stack_value}));
 
   // Case 2: Perform an address calculation with the original expr, deref it,
   // then sign-extend the result.
-  EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_deref,
-                         DW_OP_LLVM_convert, 32, DW_ATE_signed,
-                         DW_OP_LLVM_convert, 64, DW_ATE_signed,
-                         DW_OP_stack_value}));
+  EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_deref, DW_OP_dup,
+                          DW_OP_constu, 31, DW_OP_shr, DW_OP_lit0, DW_OP_not,
+                          DW_OP_mul, DW_OP_or, DW_OP_stack_value}));
 
   // Case 3: Insert the sign-extension logic before the DW_OP_stack_value.
-  EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_LLVM_convert, 32,
-                         DW_ATE_signed, DW_OP_LLVM_convert, 64, DW_ATE_signed,
-                         DW_OP_stack_value}));
+  EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_dup, DW_OP_constu, 31,
+                          DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_or,
+                          DW_OP_stack_value}));
 
   // Cases 4-6: Just like cases 1-3, but preserve the fragment at the end.
-  EXPECT_TRUE(hasADbgVal({DW_OP_LLVM_convert, 32, DW_ATE_signed,
-                         DW_OP_LLVM_convert, 64, DW_ATE_signed,
-                         DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 8}));
-
-  EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_deref,
-                         DW_OP_LLVM_convert, 32, DW_ATE_signed,
-                         DW_OP_LLVM_convert, 64, DW_ATE_signed,
-                         DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 8}));
-
-  EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_LLVM_convert, 32,
-                         DW_ATE_signed, DW_OP_LLVM_convert, 64, DW_ATE_signed,
-                         DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 8}));
+  EXPECT_TRUE(hasADbgVal({DW_OP_dup, DW_OP_constu, 31, DW_OP_shr, DW_OP_lit0,
+                          DW_OP_not, DW_OP_mul, DW_OP_or, DW_OP_stack_value,
+                          DW_OP_LLVM_fragment, 0, 8}));
+  EXPECT_TRUE(
+      hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_deref, DW_OP_dup, DW_OP_constu,
+                  31, DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_or,
+                  DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 8}));
+  EXPECT_TRUE(hasADbgVal({DW_OP_lit0, DW_OP_mul, DW_OP_dup, DW_OP_constu, 31,
+                          DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_or,
+                          DW_OP_stack_value, DW_OP_LLVM_fragment, 0, 8}));
 
   verifyModule(*M, &errs(), &BrokenDebugInfo);
   ASSERT_FALSE(BrokenDebugInfo);