Commit 9e484220 authored by Nico Weber's avatar Nico Weber
Browse files

Revert "[llvm-objdump] Display locations of variables alongside disassembly" 

Makes tests fail on Windows, see https://reviews.llvm.org/D70720#1924542

This reverts commit 3a5ddeda, and
follow-ups:
f4cb9c91
042eb048
c0cf5f5d
18649f48
f62b898c
parent ebb181cf

llvm/docs/CommandGuide/llvm-objdump.rst

+0 −11
Original line number Diff line number Diff line
@@ -119,17 +119,6 @@ OPTIONS 


  Demangle symbol names in the output.



.. option:: --debug-vars=<format>



  Print the locations (in registers or memory) of source-level variables

  alongside disassembly. ``format`` may be ``unicode`` or ``ascii``, defaulting

  to ``unicode`` if omitted.



.. option:: --debug-vars-indent=<width>



  Distance to indent the source-level variable display, relative to the start

  of the disassembly. Defaults to 40 characters.



.. option:: -j, --section=<section1[,section2,...]>



  Perform commands on the specified sections only. For Mach-O use

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

+0 −10
Original line number Diff line number Diff line
@@ -122,10 +122,6 @@ public: 
      return Op;

    }



    iterator skipBytes(uint64_t Add) {

      return iterator(Expr, Op.EndOffset + Add);

    }



    // Comparison operators are provided out of line.

    friend bool operator==(const iterator &, const iterator &);

  };
@@ -141,12 +137,6 @@ public: 
  void print(raw_ostream &OS, const MCRegisterInfo *RegInfo, DWARFUnit *U,

             bool IsEH = false) const;



  /// Print the expression in a format intended to be compact and useful to a

  /// user, but not perfectly unambiguous, or capable of representing every

  /// valid DWARF expression. Returns true if the expression was sucessfully

  /// printed.

  bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo);



  bool verify(DWARFUnit *U);



private:

llvm/include/llvm/Support/FormattedStream.h

+4 −10
Original line number Diff line number Diff line
@@ -105,17 +105,11 @@ public: 
  /// \param NewCol - The column to move to.

  formatted_raw_ostream &PadToColumn(unsigned NewCol);



  unsigned getColumn() {

    // Calculate current position, taking buffer contents into account.

    ComputePosition(getBufferStart(), GetNumBytesInBuffer());

    return Position.first;

  }

  /// getColumn - Return the column number

  unsigned getColumn() { return Position.first; }



  unsigned getLine() {

    // Calculate current position, taking buffer contents into account.

    ComputePosition(getBufferStart(), GetNumBytesInBuffer());

    return Position.second;

  }

  /// getLine - Return the line number

  unsigned getLine() { return Position.second; }



  raw_ostream &resetColor() override {

    TheStream->resetColor();

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

+0 −122
Original line number Diff line number Diff line
@@ -351,126 +351,4 @@ bool DWARFExpression::verify(DWARFUnit *U) { 
  return true;

}



/// A user-facing string representation of a DWARF expression. This might be an

/// Address expression, in which case it will be implicitly dereferenced, or a

/// Value expression.

struct PrintedExpr {

  enum ExprKind {

    Address,

    Value,

  };

  ExprKind Kind;

  SmallString<16> String;



  PrintedExpr(ExprKind K = Address) : Kind(K) {}

};



static bool printCompactDWARFExpr(raw_ostream &OS, DWARFExpression::iterator I,

                                  const DWARFExpression::iterator E,

                                  const MCRegisterInfo &MRI) {

  SmallVector<PrintedExpr, 4> Stack;



  while (I != E) {

    DWARFExpression::Operation &Op = *I;

    uint8_t Opcode = Op.getCode();

    switch (Opcode) {

    case dwarf::DW_OP_regx: {

      // DW_OP_regx: A register, with the register num given as an operand.

      // Printed as the plain register name.

      uint64_t DwarfRegNum = Op.getRawOperand(0);

      Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);

      if (!LLVMRegNum) {

        OS << "<unknown register " << DwarfRegNum << ">";

        return false;

      }

      raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);

      S << MRI.getName(*LLVMRegNum);

      break;

    }

    case dwarf::DW_OP_bregx: {

      int DwarfRegNum = Op.getRawOperand(0);

      int64_t Offset = Op.getRawOperand(1);

      Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);

      if (!LLVMRegNum) {

        OS << "<unknown register " << DwarfRegNum << ">";

        return false;

      }

      raw_svector_ostream S(Stack.emplace_back().String);

      S << MRI.getName(*LLVMRegNum);

      if (Offset)

        S << format("%+" PRId64, Offset);

      break;

    }

    case dwarf::DW_OP_entry_value:

    case dwarf::DW_OP_GNU_entry_value: {

      // DW_OP_entry_value contains a sub-expression which must be rendered

      // separately.

      uint64_t SubExprLength = Op.getRawOperand(0);

      DWARFExpression::iterator SubExprEnd = I.skipBytes(SubExprLength);

      ++I;

      raw_svector_ostream S(Stack.emplace_back().String);

      S << "entry(";

      printCompactDWARFExpr(S, I, SubExprEnd, MRI);

      S << ")";

      I = SubExprEnd;

      continue;

    }

    case dwarf::DW_OP_stack_value: {

      // The top stack entry should be treated as the actual value of tne

      // variable, rather than the address of the variable in memory.

      assert(!Stack.empty());

      Stack.back().Kind = PrintedExpr::Value;

      break;

    }

    default:

      if (Opcode >= dwarf::DW_OP_reg0 && Opcode <= dwarf::DW_OP_reg31) {

        // DW_OP_reg<N>: A register, with the register num implied by the

        // opcode. Printed as the plain register name.

        uint64_t DwarfRegNum = Opcode - dwarf::DW_OP_reg0;

        Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);

        if (!LLVMRegNum) {

          OS << "<unknown register " << DwarfRegNum << ">";

          return false;

        }

        raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);

        S << MRI.getName(*LLVMRegNum);

      } else if (Opcode >= dwarf::DW_OP_breg0 &&

                 Opcode <= dwarf::DW_OP_breg31) {

        int DwarfRegNum = Opcode - dwarf::DW_OP_breg0;

        int64_t Offset = Op.getRawOperand(0);

        Optional<unsigned> LLVMRegNum = MRI.getLLVMRegNum(DwarfRegNum, false);

        if (!LLVMRegNum) {

          OS << "<unknown register " << DwarfRegNum << ">";

          return false;

        }

        raw_svector_ostream S(Stack.emplace_back().String);

        S << MRI.getName(*LLVMRegNum);

        if (Offset)

          S << format("%+" PRId64, Offset);

      } else {

        // If we hit an unknown operand, we don't know its effect on the stack,

        // so bail out on the whole expression.

        OS << "<unknown op " << dwarf::OperationEncodingString(Opcode) << " ("

           << (int)Opcode << ")>";

        return false;

      }

      break;

    }

    ++I;

  }



  assert(Stack.size() == 1 && "expected one value on stack");



  if (Stack.front().Kind == PrintedExpr::Address)

    OS << "[" << Stack.front().String << "]";

  else

    OS << Stack.front().String;



  return true;

}



bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI) {

  return printCompactDWARFExpr(OS, begin(), end(), MRI);

}



} // namespace llvm

llvm/lib/Support/FormattedStream.cpp

+5 −24
Original line number Diff line number Diff line
@@ -11,9 +11,7 @@ 
//===----------------------------------------------------------------------===//



#include "llvm/Support/FormattedStream.h"

#include "llvm/Support/ConvertUTF.h"

#include "llvm/Support/Debug.h"

#include "llvm/Support/Locale.h"

#include "llvm/Support/raw_ostream.h"

#include <algorithm>
@@ -21,32 +19,15 @@ using namespace llvm; 


/// UpdatePosition - Examine the given char sequence and figure out which

/// column we end up in after output, and how many line breaks are contained.

/// This assumes that the input string is well-formed UTF-8, and takes into

/// account unicode characters which render as multiple columns wide.

static void UpdatePosition(std::pair<unsigned, unsigned> &Position,

                           const char *Ptr, size_t Size) {

///

static void UpdatePosition(std::pair<unsigned, unsigned> &Position, const char *Ptr, size_t Size) {

  unsigned &Column = Position.first;

  unsigned &Line = Position.second;



  // Keep track of the current column and line by scanning the string for

  // special characters.

  unsigned NumBytes;

  for (const char *End = Ptr + Size; Ptr < End; Ptr += NumBytes) {

    NumBytes = getNumBytesForUTF8(*Ptr);



    // The string should never end part way through a multi-byte sequence.

    assert((Ptr + NumBytes) <= End && "Malformed multi-byte sequence");



    int Width = sys::locale::columnWidth(StringRef(Ptr, NumBytes));

    // columnWidth returns -1 for non-printing characters.

    if (Width != -1)

      Column += Width;



    // If this is the final byte of a multi-byte sequence, it can't be any of

    // the special whitespace characters below.

    if (NumBytes > 1)

      continue;



  // special characters

  for (const char *End = Ptr + Size; Ptr != End; ++Ptr) {

    ++Column;

    switch (*Ptr) {

    case '\n':

      Line += 1;