contrib/llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

   1 //===-- llvm/CodeGen/DwarfExpression.cpp - Dwarf Debug Framework ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for writing dwarf debug info into asm files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "DwarfExpression.h"
  15 #include "DwarfDebug.h"
  16 #include "llvm/ADT/SmallBitVector.h"
  17 #include "llvm/CodeGen/AsmPrinter.h"
  18 #include "llvm/Support/Dwarf.h"
  19 #include "llvm/Target/TargetMachine.h"
  20 #include "llvm/Target/TargetRegisterInfo.h"
  21 #include "llvm/Target/TargetSubtargetInfo.h"
  22
  23 using namespace llvm;
  24
  25 void DwarfExpression::addReg(int DwarfReg, const char *Comment) {
  26  assert(DwarfReg >= 0 && "invalid negative dwarf register number");
  27  assert((LocationKind == Unknown || LocationKind == Register) &&
  28         "location description already locked down");
  29  LocationKind = Register;
  30  if (DwarfReg < 32) {
  31    emitOp(dwarf::DW_OP_reg0 + DwarfReg, Comment);
  32   } else {
  33     emitOp(dwarf::DW_OP_regx, Comment);
  34     emitUnsigned(DwarfReg);
  35   }
  36 }
  37
  38 void DwarfExpression::addBReg(int DwarfReg, int Offset) {
  39   assert(DwarfReg >= 0 && "invalid negative dwarf register number");
  40   assert(LocationKind != Register && "location description already locked down");
  41   if (DwarfReg < 32) {
  42     emitOp(dwarf::DW_OP_breg0 + DwarfReg);
  43   } else {
  44     emitOp(dwarf::DW_OP_bregx);
  45     emitUnsigned(DwarfReg);
  46   }
  47   emitSigned(Offset);
  48 }
  49
  50 void DwarfExpression::addFBReg(int Offset) {
  51   emitOp(dwarf::DW_OP_fbreg);
  52   emitSigned(Offset);
  53 }
  54
  55 void DwarfExpression::addOpPiece(unsigned SizeInBits, unsigned OffsetInBits) {
  56   if (!SizeInBits)
  57     return;
  58
  59   const unsigned SizeOfByte = 8;
  60   if (OffsetInBits > 0 || SizeInBits % SizeOfByte) {
  61     emitOp(dwarf::DW_OP_bit_piece);
  62     emitUnsigned(SizeInBits);
  63     emitUnsigned(OffsetInBits);
  64   } else {
  65     emitOp(dwarf::DW_OP_piece);
  66     unsigned ByteSize = SizeInBits / SizeOfByte;
  67     emitUnsigned(ByteSize);
  68   }
  69   this->OffsetInBits += SizeInBits;
  70 }
  71
  72 void DwarfExpression::addShr(unsigned ShiftBy) {
  73   emitOp(dwarf::DW_OP_constu);
  74   emitUnsigned(ShiftBy);
  75   emitOp(dwarf::DW_OP_shr);
  76 }
  77
  78 void DwarfExpression::addAnd(unsigned Mask) {
  79   emitOp(dwarf::DW_OP_constu);
  80   emitUnsigned(Mask);
  81   emitOp(dwarf::DW_OP_and);
  82 }
  83
  84 bool DwarfExpression::addMachineReg(const TargetRegisterInfo &TRI,
  85                                     unsigned MachineReg, unsigned MaxSize) {
  86   if (!TRI.isPhysicalRegister(MachineReg)) {
  87     if (isFrameRegister(TRI, MachineReg)) {
  88       DwarfRegs.push_back({-1, 0, nullptr});
  89       return true;
  90     }
  91     return false;
  92   }
  93
  94   int Reg = TRI.getDwarfRegNum(MachineReg, false);
  95
  96   // If this is a valid register number, emit it.
  97   if (Reg >= 0) {
  98     DwarfRegs.push_back({Reg, 0, nullptr});
  99     return true;
 100   }
 101
 102   // Walk up the super-register chain until we find a valid number.
 103   // For example, EAX on x86_64 is a 32-bit fragment of RAX with offset 0.
 104   for (MCSuperRegIterator SR(MachineReg, &TRI); SR.isValid(); ++SR) {
 105     Reg = TRI.getDwarfRegNum(*SR, false);
 106     if (Reg >= 0) {
 107       unsigned Idx = TRI.getSubRegIndex(*SR, MachineReg);
 108       unsigned Size = TRI.getSubRegIdxSize(Idx);
 109       unsigned RegOffset = TRI.getSubRegIdxOffset(Idx);
 110       DwarfRegs.push_back({Reg, 0, "super-register"});
 111       // Use a DW_OP_bit_piece to describe the sub-register.
 112       setSubRegisterPiece(Size, RegOffset);
 113       return true;
 114     }
 115   }
 116
 117   // Otherwise, attempt to find a covering set of sub-register numbers.
 118   // For example, Q0 on ARM is a composition of D0+D1.
 119   unsigned CurPos = 0;
 120   // The size of the register in bits.
 121   const TargetRegisterClass *RC = TRI.getMinimalPhysRegClass(MachineReg);
 122   unsigned RegSize = TRI.getRegSizeInBits(*RC);
 123   // Keep track of the bits in the register we already emitted, so we
 124   // can avoid emitting redundant aliasing subregs.
 125   SmallBitVector Coverage(RegSize, false);
 126   for (MCSubRegIterator SR(MachineReg, &TRI); SR.isValid(); ++SR) {
 127     unsigned Idx = TRI.getSubRegIndex(MachineReg, *SR);
 128     unsigned Size = TRI.getSubRegIdxSize(Idx);
 129     unsigned Offset = TRI.getSubRegIdxOffset(Idx);
 130     Reg = TRI.getDwarfRegNum(*SR, false);
 131
 132     // Intersection between the bits we already emitted and the bits
 133     // covered by this subregister.
 134     SmallBitVector Intersection(RegSize, false);
 135     Intersection.set(Offset, Offset + Size);
 136     Intersection ^= Coverage;
 137
 138     // If this sub-register has a DWARF number and we haven't covered
 139     // its range, emit a DWARF piece for it.
 140     if (Reg >= 0 && Intersection.any()) {
 141       // Emit a piece for any gap in the coverage.
 142       if (Offset > CurPos)
 143         DwarfRegs.push_back({-1, Offset - CurPos, nullptr});
 144       DwarfRegs.push_back(
 145           {Reg, std::min<unsigned>(Size, MaxSize - Offset), "sub-register"});
 146       if (Offset >= MaxSize)
 147         break;
 148
 149       // Mark it as emitted.
 150       Coverage.set(Offset, Offset + Size);
 151       CurPos = Offset + Size;
 152     }
 153   }
 154
 155   return CurPos;
 156 }
 157
 158 void DwarfExpression::addStackValue() {
 159   if (DwarfVersion >= 4)
 160     emitOp(dwarf::DW_OP_stack_value);
 161 }
 162
 163 void DwarfExpression::addSignedConstant(int64_t Value) {
 164   assert(LocationKind == Implicit || LocationKind == Unknown);
 165   LocationKind = Implicit;
 166   emitOp(dwarf::DW_OP_consts);
 167   emitSigned(Value);
 168 }
 169
 170 void DwarfExpression::addUnsignedConstant(uint64_t Value) {
 171   assert(LocationKind == Implicit || LocationKind == Unknown);
 172   LocationKind = Implicit;
 173   emitOp(dwarf::DW_OP_constu);
 174   emitUnsigned(Value);
 175 }
 176
 177 void DwarfExpression::addUnsignedConstant(const APInt &Value) {
 178   assert(LocationKind == Implicit || LocationKind == Unknown);
 179   LocationKind = Implicit;
 180
 181   unsigned Size = Value.getBitWidth();
 182   const uint64_t *Data = Value.getRawData();
 183
 184   // Chop it up into 64-bit pieces, because that's the maximum that
 185   // addUnsignedConstant takes.
 186   unsigned Offset = 0;
 187   while (Offset < Size) {
 188     addUnsignedConstant(*Data++);
 189     if (Offset == 0 && Size <= 64)
 190       break;
 191     addStackValue();
 192     addOpPiece(std::min(Size - Offset, 64u), Offset);
 193     Offset += 64;
 194   }
 195 }
 196
 197 bool DwarfExpression::addMachineRegExpression(const TargetRegisterInfo &TRI,
 198                                               DIExpressionCursor &ExprCursor,
 199                                               unsigned MachineReg,
 200                                               unsigned FragmentOffsetInBits) {
 201   auto Fragment = ExprCursor.getFragmentInfo();
 202   if (!addMachineReg(TRI, MachineReg, Fragment ? Fragment->SizeInBits : ~1U)) {
 203     LocationKind = Unknown;
 204     return false;
 205   }
 206
 207   bool HasComplexExpression = false;
 208   auto Op = ExprCursor.peek();
 209   if (Op && Op->getOp() != dwarf::DW_OP_LLVM_fragment)
 210     HasComplexExpression = true;
 211
 212   // If the register can only be described by a complex expression (i.e.,
 213   // multiple subregisters) it doesn't safely compose with another complex
 214   // expression. For example, it is not possible to apply a DW_OP_deref
 215   // operation to multiple DW_OP_pieces.
 216   if (HasComplexExpression && DwarfRegs.size() > 1) {
 217     DwarfRegs.clear();
 218     LocationKind = Unknown;
 219     return false;
 220   }
 221
 222   // Handle simple register locations.
 223   if (LocationKind != Memory && !HasComplexExpression) {
 224     for (auto &Reg : DwarfRegs) {
 225       if (Reg.DwarfRegNo >= 0)
 226         addReg(Reg.DwarfRegNo, Reg.Comment);
 227       addOpPiece(Reg.Size);
 228     }
 229     DwarfRegs.clear();
 230     return true;
 231   }
 232
 233   // Don't emit locations that cannot be expressed without DW_OP_stack_value.
 234   if (DwarfVersion < 4)
 235     if (std::any_of(ExprCursor.begin(), ExprCursor.end(),
 236                     [](DIExpression::ExprOperand Op) -> bool {
 237                       return Op.getOp() == dwarf::DW_OP_stack_value;
 238                     })) {
 239       DwarfRegs.clear();
 240       LocationKind = Unknown;
 241       return false;
 242     }
 243
 244   assert(DwarfRegs.size() == 1);
 245   auto Reg = DwarfRegs[0];
 246   bool FBReg = isFrameRegister(TRI, MachineReg);
 247   int SignedOffset = 0;
 248   assert(Reg.Size == 0 && "subregister has same size as superregister");
 249
 250   // Pattern-match combinations for which more efficient representations exist.
 251   // [Reg, Offset, DW_OP_plus] --> [DW_OP_breg, Offset].
 252   // [Reg, Offset, DW_OP_minus] --> [DW_OP_breg, -Offset].
 253   // If Reg is a subregister we need to mask it out before subtracting.
 254   if (Op && ((Op->getOp() == dwarf::DW_OP_plus) ||
 255              (Op->getOp() == dwarf::DW_OP_minus && !SubRegisterSizeInBits))) {
 256     int Offset = Op->getArg(0);
 257     SignedOffset = (Op->getOp() == dwarf::DW_OP_plus) ? Offset : -Offset;
 258     ExprCursor.take();
 259   }
 260   if (FBReg)
 261     addFBReg(SignedOffset);
 262   else
 263     addBReg(Reg.DwarfRegNo, SignedOffset);
 264   DwarfRegs.clear();
 265   return true;
 266 }
 267
 268 /// Assuming a well-formed expression, match "DW_OP_deref* DW_OP_LLVM_fragment?".
 269 static bool isMemoryLocation(DIExpressionCursor ExprCursor) {
 270   while (ExprCursor) {
 271     auto Op = ExprCursor.take();
 272     switch (Op->getOp()) {
 273     case dwarf::DW_OP_deref:
 274     case dwarf::DW_OP_LLVM_fragment:
 275       break;
 276     default:
 277       return false;
 278     }
 279   }
 280   return true;
 281 }
 282
 283 void DwarfExpression::addExpression(DIExpressionCursor &&ExprCursor,
 284                                     unsigned FragmentOffsetInBits) {
 285   // If we need to mask out a subregister, do it now, unless the next
 286   // operation would emit an OpPiece anyway.
 287   auto N = ExprCursor.peek();
 288   if (SubRegisterSizeInBits && N && (N->getOp() != dwarf::DW_OP_LLVM_fragment))
 289     maskSubRegister();
 290
 291   while (ExprCursor) {
 292     auto Op = ExprCursor.take();
 293     switch (Op->getOp()) {
 294     case dwarf::DW_OP_LLVM_fragment: {
 295       unsigned SizeInBits = Op->getArg(1);
 296       unsigned FragmentOffset = Op->getArg(0);
 297       // The fragment offset must have already been adjusted by emitting an
 298       // empty DW_OP_piece / DW_OP_bit_piece before we emitted the base
 299       // location.
 300       assert(OffsetInBits >= FragmentOffset && "fragment offset not added?");
 301
 302       // If addMachineReg already emitted DW_OP_piece operations to represent
 303       // a super-register by splicing together sub-registers, subtract the size
 304       // of the pieces that was already emitted.
 305       SizeInBits -= OffsetInBits - FragmentOffset;
 306
 307       // If addMachineReg requested a DW_OP_bit_piece to stencil out a
 308       // sub-register that is smaller than the current fragment's size, use it.
 309       if (SubRegisterSizeInBits)
 310         SizeInBits = std::min<unsigned>(SizeInBits, SubRegisterSizeInBits);
 311
 312       // Emit a DW_OP_stack_value for implicit location descriptions.
 313       if (LocationKind == Implicit)
 314         addStackValue();
 315
 316       // Emit the DW_OP_piece.
 317       addOpPiece(SizeInBits, SubRegisterOffsetInBits);
 318       setSubRegisterPiece(0, 0);
 319       // Reset the location description kind.
 320       LocationKind = Unknown;
 321       return;
 322     }
 323     case dwarf::DW_OP_plus:
 324       assert(LocationKind != Register);
 325       emitOp(dwarf::DW_OP_plus_uconst);
 326       emitUnsigned(Op->getArg(0));
 327       break;
 328     case dwarf::DW_OP_minus:
 329       assert(LocationKind != Register);
 330       // There is no DW_OP_minus_uconst.
 331       emitOp(dwarf::DW_OP_constu);
 332       emitUnsigned(Op->getArg(0));
 333       emitOp(dwarf::DW_OP_minus);
 334       break;
 335     case dwarf::DW_OP_deref: {
 336       assert(LocationKind != Register);
 337       if (LocationKind != Memory && isMemoryLocation(ExprCursor))
 338         // Turning this into a memory location description makes the deref
 339         // implicit.
 340         LocationKind = Memory;
 341       else
 342         emitOp(dwarf::DW_OP_deref);
 343       break;
 344     }
 345     case dwarf::DW_OP_constu:
 346       assert(LocationKind != Register);
 347       emitOp(dwarf::DW_OP_constu);
 348       emitUnsigned(Op->getArg(0));
 349       break;
 350     case dwarf::DW_OP_stack_value:
 351       LocationKind = Implicit;
 352       break;
 353     case dwarf::DW_OP_swap:
 354       assert(LocationKind != Register);
 355       emitOp(dwarf::DW_OP_swap);
 356       break;
 357     case dwarf::DW_OP_xderef:
 358       assert(LocationKind != Register);
 359       emitOp(dwarf::DW_OP_xderef);
 360       break;
 361     default:
 362       llvm_unreachable("unhandled opcode found in expression");
 363     }
 364   }
 365
 366   if (LocationKind == Implicit)
 367     // Turn this into an implicit location description.
 368     addStackValue();
 369 }
 370
 371 /// add masking operations to stencil out a subregister.
 372 void DwarfExpression::maskSubRegister() {
 373   assert(SubRegisterSizeInBits && "no subregister was registered");
 374   if (SubRegisterOffsetInBits > 0)
 375     addShr(SubRegisterOffsetInBits);
 376   uint64_t Mask = (1ULL << (uint64_t)SubRegisterSizeInBits) - 1ULL;
 377   addAnd(Mask);
 378 }
 379
 380
 381 void DwarfExpression::finalize() {
 382   assert(DwarfRegs.size() == 0 && "dwarf registers not emitted");
 383   // Emit any outstanding DW_OP_piece operations to mask out subregisters.
 384   if (SubRegisterSizeInBits == 0)
 385     return;
 386   // Don't emit a DW_OP_piece for a subregister at offset 0.
 387   if (SubRegisterOffsetInBits == 0)
 388     return;
 389   addOpPiece(SubRegisterSizeInBits, SubRegisterOffsetInBits);
 390 }
 391
 392 void DwarfExpression::addFragmentOffset(const DIExpression *Expr) {
 393   if (!Expr || !Expr->isFragment())
 394     return;
 395
 396   uint64_t FragmentOffset = Expr->getFragmentInfo()->OffsetInBits;
 397   assert(FragmentOffset >= OffsetInBits &&
 398          "overlapping or duplicate fragments");
 399   if (FragmentOffset > OffsetInBits)
 400     addOpPiece(FragmentOffset - OffsetInBits);
 401   OffsetInBits = FragmentOffset;
 402 }