[dsymutil] Ensure PC offsets with within specified bit width

[vsk]

Summary

Fixes a bug where dsymutil did not truncate negative PC offsets to the specified width. E.g: if "Low + LocPcOffset" is negative and AddressSize is 4, the bits 32..63 are high, which causes EmitIntValue to assertion-fail.

[friss]

I'm not sure we should fix this. The fact that we get this assertion means that the link did something wrong, and most likely we should fix the issue there. We shouldn't end up with negative/overflowing addresses here.

It might be that for some reason getting this is unavoidable, but I want to understand the root cause first.

[vsk]

Fred's right, we can come back to this later if needed.

include/llvm/Support/MathExtras.h

inline uint32_t Hi_32(uint64_t Value) {
   return static_cast<uint32_t>(Value >> 32);
 }
 
 /// Lo_32 - This function returns the low 32 bits of a 64 bit value.
 inline uint32_t Lo_32(uint64_t Value) {
   return static_cast<uint32_t>(Value);
 }
 
+/// Lo_Bits - This function returns the low \p Bits bits of Value.
+inline uint64_t Lo_Bits(uint64_t Value, unsigned Bits) {
+  assert(Bits <= 64);
+  return Value & (~0ULL >> (64 - Bits));
+}
+
 /// Make_64 - This functions makes a 64-bit integer from a high / low pair of
 ///           32-bit integers.
 inline uint64_t Make_64(uint32_t High, uint32_t Low) {
   return ((uint64_t)High << 32) | (uint64_t)Low;
 }
 
 /// isInt - Checks if an integer fits into the given bit width.
 template<unsigned N>

tools/dsymutil/DwarfLinker.cpp

 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/LEB128.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 #include <tuple>
 
 namespace llvm {
 namespace dsymutil {
while (Data.isValidOffset(Offset)) {
       uint64_t Low = Data.getUnsigned(&Offset, AddressSize);
       uint64_t High = Data.getUnsigned(&Offset, AddressSize);
       LocSectionSize += 2 * AddressSize;
       if (Low == 0 && High == 0) {
         Asm->OutStreamer->EmitIntValue(0, AddressSize);
         Asm->OutStreamer->EmitIntValue(0, AddressSize);
         break;
       }
-      Asm->OutStreamer->EmitIntValue(Low + LocPcOffset, AddressSize);
-      Asm->OutStreamer->EmitIntValue(High + LocPcOffset, AddressSize);
+      Asm->OutStreamer->EmitIntValue(
+          llvm::Lo_Bits(Low + LocPcOffset, 8 * AddressSize), AddressSize);
+      Asm->OutStreamer->EmitIntValue(
+          llvm::Lo_Bits(High + LocPcOffset, 8 * AddressSize), AddressSize);
       uint64_t Length = Data.getU16(&Offset);
       Asm->OutStreamer->EmitIntValue(Length, 2);
       // Just copy the bytes over.
       Asm->OutStreamer->EmitBytes(
           StringRef(InputSec.Data.substr(Offset, Length)));
       Offset += Length;
       LocSectionSize += Length + 2;
     }