[NFC, CFI] Use unsigned type for CFI register values in parser/streamer code

[RamNalamothu]

Summary

While MCCFIInstruction uses proper type for CFI register values i.e. unsigned,
the interfacing code to that in parsers and streamers are feeding signed
arguments. This fixes the inconsistency and makes the interfacing code also
to use an unsigned type for CFI register values.

[MaskRay]

llvm/lib/MC/MCParser/MasmParser.cpp

1832

@epastor

[epastor]

llvm/lib/MC/MCParser/MasmParser.cpp

1832

I have no objection, this seems good to add here.

[scott.linder]

Would it be reasonable to just clean up all the types in these functions? I noted the ones I identified.

llvm/include/llvm/MC/MCStreamer.h

983

Should this just be uint64_t?

984

Same

993

Same

llvm/lib/MC/MCParser/AsmParser.cpp

1534

The Absolute in this case is just referring to "not relative", right? The Res value from evaluateAsAbsolute may be negative, and this cast will result in some large unsigned value for that case.

Maybe we just add an assert(Value > 0)? Or as you note a variant of evaluateAsAbsolute for unsigned which does the check could work.

llvm/lib/MC/MCParser/MasmParser.cpp

1844

Same

[MaskRay]

llvm/lib/MC/MCAsmStreamer.cpp

62

If you are changing the interface, you can rename the function to camelCase in the meanwhile.

[RamNalamothu]

Address the review comments.

[RamNalamothu]

In D102220#2752089, @scott.linder wrote:

Would it be reasonable to just clean up all the types in these functions? I noted the ones I identified.

Since these are virtual interfaces and will need changes in other places as well, I would defer that to an another patch.

llvm/lib/MC/MCParser/AsmParser.cpp

1534

I went ahead with an assert. Thank you.

For this patch, I feel it is a good point to stop here before getting into MCExpr and changing all variants of evaluateAsAbsolute() and probably parts of the interfacing code.

[RamNalamothu]

Missed changes in the previous update(s).

[scott.linder]

llvm/lib/MC/MCParser/MasmParser.cpp

1839

Looking at this again, it seems like at the same time you would make this change, you would probably just make parseAbsoluteExpression(uint64_t) virtual in the base class to match the signed variant? It seems odd to have an overload of parseAbsoluteExpression only in this derived class, so maybe a TODO at the declaration to clarify for future readers would be helpful?

1844

I don't think I considered the context fully here, as this will fire on pretty easy-to-write and reasonable user inputs, right? Any absolute expression in a CFA directive which ends up being negative will cause an assert.

Maybe this should be if (Value >= 0) return Error(...); instead?

[RamNalamothu]

llvm/lib/MC/MCParser/MasmParser.cpp

1839

I thought about it but while trying to limit the changes, I didn't explore it fully thinking that might trigger more changes but apparently not many changes. Will make it virtual in base class.

Yes, a TODO should have been helpful.

1844

If call sites invoke parseAbsoluteExpression(uint64_t) and expect a positive return value from an expression which actually yields negative value, I feel this check better be an assert so that those scenarios can be fixed appropriately.

[RamNalamothu]

Add virtual method parseAbsoluteExpression(uint64_t) to MCAsmParser.

[MaskRay]

the interfacing code in parsers and streamers are using both signed and unsigned type in different parts.

Where is uint64_t used? Most places use int64_t.

[RamNalamothu]

In D102220#2755545, @MaskRay wrote:

the interfacing code in parsers and streamers are using both signed and unsigned type in different parts.

Where is uint64_t used? Most places use int64_t.

For instance in AsmParser::parseRegisterOrRegisterNumber() and type cast in MCStreamer::emitCFIDefCfaRegister().

Anyway, I have changed the summary as the above scenarios are minor in the entire changes.

[MaskRay]

In D102220#2755883, @RamNalamothu wrote:

In D102220#2755545, @MaskRay wrote:

the interfacing code in parsers and streamers are using both signed and unsigned type in different parts.

Where is uint64_t used? Most places use int64_t.

For instance in AsmParser::parseRegisterOrRegisterNumber() and type cast in MCStreamer::emitCFIDefCfaRegister().

Anyway, I have changed the summary as the above scenarios are minor in the entire changes.

Both AsmParser::parseRegisterOrRegisterNumber() and MCStreamer::emitCFIDefCfaRegister() uses int64_t.

OK, I am now convinced that most places use int64_t.
Using unsigned type to represent "negative values aren't allowed" is not a good idea.

https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es106-dont-try-to-avoid-negative-values-by-using-unsigned

[RamNalamothu]

In D102220#2755984, @MaskRay wrote:

In D102220#2755883, @RamNalamothu wrote:

In D102220#2755545, @MaskRay wrote:

the interfacing code in parsers and streamers are using both signed and unsigned type in different parts.

Where is uint64_t used? Most places use int64_t.

For instance in AsmParser::parseRegisterOrRegisterNumber() and type cast in MCStreamer::emitCFIDefCfaRegister().

Anyway, I have changed the summary as the above scenarios are minor in the entire changes.

Both AsmParser::parseRegisterOrRegisterNumber() and MCStreamer::emitCFIDefCfaRegister() uses int64_t.

bool AsmParser::parseRegisterOrRegisterNumber(int64_t &Register,          ---> signed for register
                                              SMLoc DirectiveLoc) {
  unsigned RegNo;                                                         ---> unsigned for register

  if (getLexer().isNot(AsmToken::Integer)) {
    if (getTargetParser().ParseRegister(RegNo, DirectiveLoc, DirectiveLoc))
      return true;
    Register = getContext().getRegisterInfo()->getDwarfRegNum(RegNo, true);
  } else
    return parseAbsoluteExpression(Register);

  return false;
}

OK, I am now convinced that most places use int64_t.
Using unsigned type to represent "negative values aren't allowed" is not a good idea.

Looks like I couldn't get the intent of this patch expressed better earlier.

This patch is based on the fact that we don't use negative numbers to represent registers in CFI, meaning DWARF register mappings always use positive numbers or at least that is what I understood. Based on that, we never emit

.cfi_register -2020, 2050 ---> value of register -2020 is saved in register 2050.

So, doesn't it make sense to use an unsigned type for a variable which is not expected to have negative numbers?
And that is what this patch is trying to achieve.

Otherwise, I think, we should be adding type casts similar to the one below

void MCStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset) {
   ....
   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
}

at all the call sites, in the streamers/parsers being modified in this patch, to the MCCFIInstruction::create* methods because they expect unsigned arguments. For e.g.

void MCStreamer::emitCFIRegister(int64_t Register1, int64_t Register2) {
  ......
  MCCFIInstruction Instruction =
    MCCFIInstruction::createRegister(Label, static_cast<unsigned>(Register1), static_cast<unsigned>(Register2));
 .....
}

llvm/include/llvm/MC/MCStreamer.h

public:
   /// Emit the absolute difference between two symbols encoded with ULEB128.
   virtual void emitAbsoluteSymbolDiffAsULEB128(const MCSymbol *Hi,
                                                const MCSymbol *Lo);
 
   virtual MCSymbol *getDwarfLineTableSymbol(unsigned CUID);
   virtual void emitCFISections(bool EH, bool Debug);
   void emitCFIStartProc(bool IsSimple, SMLoc Loc = SMLoc());
   void emitCFIEndProc();
-  virtual void emitCFIDefCfa(int64_t Register, int64_t Offset);
+  virtual void emitCFIDefCfa(uint64_t Register, int64_t Offset);
   virtual void emitCFIDefCfaOffset(int64_t Offset);
-  virtual void emitCFIDefCfaRegister(int64_t Register);
-  virtual void emitCFIOffset(int64_t Register, int64_t Offset);
+  virtual void emitCFIDefCfaRegister(uint64_t Register);
+  virtual void emitCFIOffset(uint64_t Register, int64_t Offset);
   virtual void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
   virtual void emitCFILsda(const MCSymbol *Sym, unsigned Encoding);
   virtual void emitCFIRememberState();
   virtual void emitCFIRestoreState();
-  virtual void emitCFISameValue(int64_t Register);
-  virtual void emitCFIRestore(int64_t Register);
-  virtual void emitCFIRelOffset(int64_t Register, int64_t Offset);
+  virtual void emitCFISameValue(uint64_t Register);
+  virtual void emitCFIRestore(uint64_t Register);
+  virtual void emitCFIRelOffset(uint64_t Register, int64_t Offset);
   virtual void emitCFIAdjustCfaOffset(int64_t Adjustment);
   virtual void emitCFIEscape(StringRef Values);
-  virtual void emitCFIReturnColumn(int64_t Register);
+  virtual void emitCFIReturnColumn(uint64_t Register);
   virtual void emitCFIGnuArgsSize(int64_t Size);
   virtual void emitCFISignalFrame();
-  virtual void emitCFIUndefined(int64_t Register);
-  virtual void emitCFIRegister(int64_t Register1, int64_t Register2);
+  virtual void emitCFIUndefined(uint64_t Register);
+  virtual void emitCFIRegister(uint64_t Register1, uint64_t Register2);
   virtual void emitCFIWindowSave();
   virtual void emitCFINegateRAState();
 
   virtual void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc = SMLoc());
   virtual void EmitWinCFIEndProc(SMLoc Loc = SMLoc());
   /// This is used on platforms, such as Windows on ARM64, that require function
   /// or funclet sizes to be emitted in .xdata before the End marker is emitted
   /// for the frame.  We cannot use the End marker, as it is not set at the

llvm/lib/MC/MCAsmStreamer.cpp

class MCAsmStreamer final : public MCStreamer {
   SmallString<128> CommentToEmit;
   raw_svector_ostream CommentStream;
   raw_null_ostream NullStream;
 
   unsigned IsVerboseAsm : 1;
   unsigned ShowInst : 1;
   unsigned UseDwarfDirectory : 1;
 
-  void EmitRegisterName(int64_t Register);
+  void emitRegisterName(uint64_t Register);
   void PrintQuotedString(StringRef Data, raw_ostream &OS) const;
   void printDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                StringRef Filename,
                                Optional<MD5::MD5Result> Checksum,
                                Optional<StringRef> Source,
                                bool UseDwarfDirectory,
                                raw_svector_ostream &OS) const;
   void emitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
public:
   void emitCVStringTableDirective() override;
   void emitCVFileChecksumsDirective() override;
   void emitCVFileChecksumOffsetDirective(unsigned FileNo) override;
   void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc L) override;
 
   void emitIdent(StringRef IdentString) override;
   void emitCFIBKeyFrame() override;
   void emitCFISections(bool EH, bool Debug) override;
-  void emitCFIDefCfa(int64_t Register, int64_t Offset) override;
+  void emitCFIDefCfa(uint64_t Register, int64_t Offset) override;
   void emitCFIDefCfaOffset(int64_t Offset) override;
-  void emitCFIDefCfaRegister(int64_t Register) override;
-  void emitCFIOffset(int64_t Register, int64_t Offset) override;
+  void emitCFIDefCfaRegister(uint64_t Register) override;
+  void emitCFIOffset(uint64_t Register, int64_t Offset) override;
   void emitCFIPersonality(const MCSymbol *Sym, unsigned Encoding) override;
   void emitCFILsda(const MCSymbol *Sym, unsigned Encoding) override;
   void emitCFIRememberState() override;
   void emitCFIRestoreState() override;
-  void emitCFIRestore(int64_t Register) override;
-  void emitCFISameValue(int64_t Register) override;
-  void emitCFIRelOffset(int64_t Register, int64_t Offset) override;
+  void emitCFIRestore(uint64_t Register) override;
+  void emitCFISameValue(uint64_t Register) override;
+  void emitCFIRelOffset(uint64_t Register, int64_t Offset) override;
   void emitCFIAdjustCfaOffset(int64_t Adjustment) override;
   void emitCFIEscape(StringRef Values) override;
   void emitCFIGnuArgsSize(int64_t Size) override;
   void emitCFISignalFrame() override;
-  void emitCFIUndefined(int64_t Register) override;
-  void emitCFIRegister(int64_t Register1, int64_t Register2) override;
+  void emitCFIUndefined(uint64_t Register) override;
+  void emitCFIRegister(uint64_t Register1, uint64_t Register2) override;
   void emitCFIWindowSave() override;
   void emitCFINegateRAState() override;
-  void emitCFIReturnColumn(int64_t Register) override;
+  void emitCFIReturnColumn(uint64_t Register) override;
 
   void EmitWinCFIStartProc(const MCSymbol *Symbol, SMLoc Loc) override;
   void EmitWinCFIEndProc(SMLoc Loc) override;
   void EmitWinCFIFuncletOrFuncEnd(SMLoc Loc) override;
   void EmitWinCFIStartChained(SMLoc Loc) override;
   void EmitWinCFIEndChained(SMLoc Loc) override;
   void EmitWinCFIPushReg(MCRegister Register, SMLoc Loc) override;
   void EmitWinCFISetFrame(MCRegister Register, unsigned Offset,

 }
 
 void MCAsmStreamer::emitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
   MCStreamer::emitCFIEndProcImpl(Frame);
   OS << "\t.cfi_endproc";
   EmitEOL();
 }
 
-void MCAsmStreamer::EmitRegisterName(int64_t Register) {
+void MCAsmStreamer::emitRegisterName(uint64_t Register) {
   if (!MAI->useDwarfRegNumForCFI()) {
     // User .cfi_* directives can use arbitrary DWARF register numbers, not
     // just ones that map to LLVM register numbers and have known names.
     // Fall back to using the original number directly if no name is known.
     const MCRegisterInfo *MRI = getContext().getRegisterInfo();
     if (Optional<unsigned> LLVMRegister = MRI->getLLVMRegNum(Register, true)) {
       InstPrinter->printRegName(OS, *LLVMRegister);
       return;
     }
   }
   OS << Register;
 }
 
-void MCAsmStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset) {
+void MCAsmStreamer::emitCFIDefCfa(uint64_t Register, int64_t Offset) {
   MCStreamer::emitCFIDefCfa(Register, Offset);
   OS << "\t.cfi_def_cfa ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   OS << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIDefCfaOffset(int64_t Offset) {
   MCStreamer::emitCFIDefCfaOffset(Offset);
   OS << "\t.cfi_def_cfa_offset " << Offset;
   EmitEOL();
void MCAsmStreamer::emitCFIGnuArgsSize(int64_t Size) {
 
   uint8_t Buffer[16] = { dwarf::DW_CFA_GNU_args_size };
   unsigned Len = encodeULEB128(Size, Buffer + 1) + 1;
 
   PrintCFIEscape(OS, StringRef((const char *)&Buffer[0], Len));
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFIDefCfaRegister(int64_t Register) {
+void MCAsmStreamer::emitCFIDefCfaRegister(uint64_t Register) {
   MCStreamer::emitCFIDefCfaRegister(Register);
   OS << "\t.cfi_def_cfa_register ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFIOffset(int64_t Register, int64_t Offset) {
+void MCAsmStreamer::emitCFIOffset(uint64_t Register, int64_t Offset) {
   this->MCStreamer::emitCFIOffset(Register, Offset);
   OS << "\t.cfi_offset ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   OS << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIPersonality(const MCSymbol *Sym,
                                        unsigned Encoding) {
   MCStreamer::emitCFIPersonality(Sym, Encoding);
   OS << "\t.cfi_personality " << Encoding << ", ";

 }
 
 void MCAsmStreamer::emitCFIRestoreState() {
   MCStreamer::emitCFIRestoreState();
   OS << "\t.cfi_restore_state";
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFIRestore(int64_t Register) {
+void MCAsmStreamer::emitCFIRestore(uint64_t Register) {
   MCStreamer::emitCFIRestore(Register);
   OS << "\t.cfi_restore ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFISameValue(int64_t Register) {
+void MCAsmStreamer::emitCFISameValue(uint64_t Register) {
   MCStreamer::emitCFISameValue(Register);
   OS << "\t.cfi_same_value ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFIRelOffset(int64_t Register, int64_t Offset) {
+void MCAsmStreamer::emitCFIRelOffset(uint64_t Register, int64_t Offset) {
   MCStreamer::emitCFIRelOffset(Register, Offset);
   OS << "\t.cfi_rel_offset ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   OS << ", " << Offset;
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIAdjustCfaOffset(int64_t Adjustment) {
   MCStreamer::emitCFIAdjustCfaOffset(Adjustment);
   OS << "\t.cfi_adjust_cfa_offset " << Adjustment;
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFISignalFrame() {
   MCStreamer::emitCFISignalFrame();
   OS << "\t.cfi_signal_frame";
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFIUndefined(int64_t Register) {
+void MCAsmStreamer::emitCFIUndefined(uint64_t Register) {
   MCStreamer::emitCFIUndefined(Register);
   OS << "\t.cfi_undefined ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFIRegister(int64_t Register1, int64_t Register2) {
+void MCAsmStreamer::emitCFIRegister(uint64_t Register1, uint64_t Register2) {
   MCStreamer::emitCFIRegister(Register1, Register2);
   OS << "\t.cfi_register ";
-  EmitRegisterName(Register1);
+  emitRegisterName(Register1);
   OS << ", ";
-  EmitRegisterName(Register2);
+  emitRegisterName(Register2);
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIWindowSave() {
   MCStreamer::emitCFIWindowSave();
   OS << "\t.cfi_window_save";
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFINegateRAState() {
   MCStreamer::emitCFINegateRAState();
   OS << "\t.cfi_negate_ra_state";
   EmitEOL();
 }
 
-void MCAsmStreamer::emitCFIReturnColumn(int64_t Register) {
+void MCAsmStreamer::emitCFIReturnColumn(uint64_t Register) {
   MCStreamer::emitCFIReturnColumn(Register);
   OS << "\t.cfi_return_column ";
-  EmitRegisterName(Register);
+  emitRegisterName(Register);
   EmitEOL();
 }
 
 void MCAsmStreamer::emitCFIBKeyFrame() {
   MCStreamer::emitCFIBKeyFrame();
   OS << "\t.cfi_b_key_frame";
   EmitEOL();
 }

llvm/lib/MC/MCParser/AsmParser.cpp

public:
   bool parseExpression(const MCExpr *&Res);
   bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
                         AsmTypeInfo *TypeInfo) override;
   bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
                              SMLoc &EndLoc) override;
   bool parseAbsoluteExpression(int64_t &Res) override;
+  bool parseAbsoluteExpression(uint64_t &Res);
 
   /// Parse a floating point expression using the float \p Semantics
   /// and set \p Res to the value.
   bool parseRealValue(const fltSemantics &Semantics, APInt &Res);
 
   /// Parse an identifier or string (as a quoted identifier)
   /// and set \p Res to the identifier contents.
   bool parseIdentifier(StringRef &Res) override;
private:
 
   unsigned getBinOpPrecedence(AsmToken::TokenKind K,
                               MCBinaryExpr::Opcode &Kind);
 
   bool parseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);
   bool parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc);
   bool parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);
 
-  bool parseRegisterOrRegisterNumber(int64_t &Register, SMLoc DirectiveLoc);
+  bool parseRegisterOrRegisterNumber(uint64_t &Register, SMLoc DirectiveLoc);
 
   bool parseCVFunctionId(int64_t &FunctionId, StringRef DirectiveName);
   bool parseCVFileId(int64_t &FileId, StringRef DirectiveName);
 
   // Generic (target and platform independent) directive parsing.
   enum DirectiveKind {
     DK_NO_DIRECTIVE, // Placeholder
     DK_SET,
if (parseExpression(Expr))
     return true;
 
   if (!Expr->evaluateAsAbsolute(Res, getStreamer().getAssemblerPtr()))
     return Error(StartLoc, "expected absolute expression");
 
   return false;
 }
 
+bool AsmParser::parseAbsoluteExpression(uint64_t &Res) {
+  const MCExpr *Expr;
+
+  SMLoc StartLoc = Lexer.getLoc();
+  if (parseExpression(Expr))
+    return true;
+
+  // FIXME: overload evaluateAsAbsolute() for uint64_t type?
+  int64_t Value;
+  if (!Expr->evaluateAsAbsolute(Value, getStreamer().getAssemblerPtr()))
+    return Error(StartLoc, "expected absolute expression");
+
+  assert(Value >= 0);
+  Res = static_cast<uint64_t>(Value);
+
+  return false;
+}
+
 static unsigned getDarwinBinOpPrecedence(AsmToken::TokenKind K,
                                          MCBinaryExpr::Opcode &Kind,
                                          bool ShouldUseLogicalShr) {
   switch (K) {
   default:
     return 0; // not a binop.
 
   // Lowest Precedence: &&, ||

 bool AsmParser::parseDirectiveCFIEndProc() {
   if (parseEOL())
     return true;
   getStreamer().emitCFIEndProc();
   return false;
 }
 
 /// parse register name or number.
-bool AsmParser::parseRegisterOrRegisterNumber(int64_t &Register,
+bool AsmParser::parseRegisterOrRegisterNumber(uint64_t &Register,
                                               SMLoc DirectiveLoc) {
   unsigned RegNo;
 
   if (getLexer().isNot(AsmToken::Integer)) {
     if (getTargetParser().ParseRegister(RegNo, DirectiveLoc, DirectiveLoc))
       return true;
     Register = getContext().getRegisterInfo()->getDwarfRegNum(RegNo, true);
   } else
     return parseAbsoluteExpression(Register);
 
   return false;
 }
 
 /// parseDirectiveCFIDefCfa
 /// ::= .cfi_def_cfa register,  offset
 bool AsmParser::parseDirectiveCFIDefCfa(SMLoc DirectiveLoc) {
-  int64_t Register = 0, Offset = 0;
+  uint64_t Register = 0;
+  int64_t Offset = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseComma() ||
       parseAbsoluteExpression(Offset) || parseEOL())
     return true;
 
   getStreamer().emitCFIDefCfa(Register, Offset);
   return false;
 }
 
 /// parseDirectiveCFIDefCfaOffset
 /// ::= .cfi_def_cfa_offset offset
 bool AsmParser::parseDirectiveCFIDefCfaOffset() {
   int64_t Offset = 0;
   if (parseAbsoluteExpression(Offset) || parseEOL())
     return true;
 
   getStreamer().emitCFIDefCfaOffset(Offset);
   return false;
 }
 
 /// parseDirectiveCFIRegister
 /// ::= .cfi_register register, register
 bool AsmParser::parseDirectiveCFIRegister(SMLoc DirectiveLoc) {
-  int64_t Register1 = 0, Register2 = 0;
+  uint64_t Register1 = 0, Register2 = 0;
   if (parseRegisterOrRegisterNumber(Register1, DirectiveLoc) || parseComma() ||
       parseRegisterOrRegisterNumber(Register2, DirectiveLoc) || parseEOL())
     return true;
 
   getStreamer().emitCFIRegister(Register1, Register2);
   return false;
 }
 
bool AsmParser::parseDirectiveCFIAdjustCfaOffset() {
 
   getStreamer().emitCFIAdjustCfaOffset(Adjustment);
   return false;
 }
 
 /// parseDirectiveCFIDefCfaRegister
 /// ::= .cfi_def_cfa_register register
 bool AsmParser::parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL())
     return true;
 
   getStreamer().emitCFIDefCfaRegister(Register);
   return false;
 }
 
 /// parseDirectiveCFIOffset
 /// ::= .cfi_offset register, offset
 bool AsmParser::parseDirectiveCFIOffset(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   int64_t Offset = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseComma() ||
       parseAbsoluteExpression(Offset) || parseEOL())
     return true;
 
   getStreamer().emitCFIOffset(Register, Offset);
   return false;
 }
 
 /// parseDirectiveCFIRelOffset
 /// ::= .cfi_rel_offset register, offset
 bool AsmParser::parseDirectiveCFIRelOffset(SMLoc DirectiveLoc) {
-  int64_t Register = 0, Offset = 0;
+  uint64_t Register = 0;
+  int64_t Offset = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseComma() ||
       parseAbsoluteExpression(Offset) || parseEOL())
     return true;
 
   getStreamer().emitCFIRelOffset(Register, Offset);
   return false;
 }
if (parseEOL())
     return true;
   getStreamer().emitCFIRestoreState();
   return false;
 }
 
 /// parseDirectiveCFISameValue
 /// ::= .cfi_same_value register
 bool AsmParser::parseDirectiveCFISameValue(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL())
     return true;
 
   getStreamer().emitCFISameValue(Register);
   return false;
 }
 
 /// parseDirectiveCFIRestore
 /// ::= .cfi_restore register
 bool AsmParser::parseDirectiveCFIRestore(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL())
     return true;
 
   getStreamer().emitCFIRestore(Register);
   return false;
 }
 
 /// parseDirectiveCFIEscape
bool AsmParser::parseDirectiveCFIEscape() {
 
   getStreamer().emitCFIEscape(Values);
   return false;
 }
 
 /// parseDirectiveCFIReturnColumn
 /// ::= .cfi_return_column register
 bool AsmParser::parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL())
     return true;
   getStreamer().emitCFIReturnColumn(Register);
   return false;
 }
 
 /// parseDirectiveCFISignalFrame
 /// ::= .cfi_signal_frame
 bool AsmParser::parseDirectiveCFISignalFrame() {
   if (parseEOL())
     return true;
 
   getStreamer().emitCFISignalFrame();
   return false;
 }
 
 /// parseDirectiveCFIUndefined
 /// ::= .cfi_undefined register
 bool AsmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) || parseEOL())
     return true;
 
   getStreamer().emitCFIUndefined(Register);
   return false;
 }
 

llvm/lib/MC/MCParser/MasmParser.cpp

public:
   bool parseExpression(const MCExpr *&Res);
   bool parseExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
                         AsmTypeInfo *TypeInfo) override;
   bool parseParenExpression(const MCExpr *&Res, SMLoc &EndLoc) override;
   bool parseParenExprOfDepth(unsigned ParenDepth, const MCExpr *&Res,
                              SMLoc &EndLoc) override;
   bool parseAbsoluteExpression(int64_t &Res) override;
+  bool parseAbsoluteExpression(uint64_t &Res);
 
   /// Parse a floating point expression using the float \p Semantics
   /// and set \p Res to the value.
   bool parseRealValue(const fltSemantics &Semantics, APInt &Res);
 
   /// Parse an identifier or string (as a quoted identifier)
   /// and set \p Res to the identifier contents.
   bool parseIdentifier(StringRef &Res) override;
private:
 
   unsigned getBinOpPrecedence(AsmToken::TokenKind K,
                               MCBinaryExpr::Opcode &Kind);
 
   bool parseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);
   bool parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc);
   bool parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);
 
-  bool parseRegisterOrRegisterNumber(int64_t &Register, SMLoc DirectiveLoc);
+  bool parseRegisterOrRegisterNumber(uint64_t &Register, SMLoc DirectiveLoc);
 
   bool parseCVFunctionId(int64_t &FunctionId, StringRef DirectiveName);
   bool parseCVFileId(int64_t &FileId, StringRef DirectiveName);
 
   // Generic (target and platform independent) directive parsing.
   enum DirectiveKind {
     DK_NO_DIRECTIVE, // Placeholder
     DK_HANDLER_DIRECTIVE,
if (parseExpression(Expr))
     return true;
 
   if (!Expr->evaluateAsAbsolute(Res, getStreamer().getAssemblerPtr()))
     return Error(StartLoc, "expected absolute expression");
 
   return false;
 }
 
+bool MasmParser::parseAbsoluteExpression(uint64_t &Res) {
+  const MCExpr *Expr;
+
+  SMLoc StartLoc = Lexer.getLoc();
+  if (parseExpression(Expr))
+    return true;
+
+  // FIXME: overload evaluateAsAbsolute() for uint64_t type?
+  int64_t Value;
+  if (!Expr->evaluateAsAbsolute(Value, getStreamer().getAssemblerPtr()))
+    return Error(StartLoc, "expected absolute expression");
+
+  assert(Value >= 0);
+  Res = static_cast<uint64_t>(Value);
+
+  return false;
+}
+
 static unsigned getGNUBinOpPrecedence(AsmToken::TokenKind K,
                                       MCBinaryExpr::Opcode &Kind,
                                       bool ShouldUseLogicalShr,
                                       bool EndExpressionAtGreater) {
   switch (K) {
   default:
     return 0; // not a binop.
 

 /// parseDirectiveCFIEndProc
 /// ::= .cfi_endproc
 bool MasmParser::parseDirectiveCFIEndProc() {
   getStreamer().emitCFIEndProc();
   return false;
 }
 
 /// parse register name or number.
-bool MasmParser::parseRegisterOrRegisterNumber(int64_t &Register,
+bool MasmParser::parseRegisterOrRegisterNumber(uint64_t &Register,
                                                SMLoc DirectiveLoc) {
   unsigned RegNo;
 
   if (getLexer().isNot(AsmToken::Integer)) {
     if (getTargetParser().ParseRegister(RegNo, DirectiveLoc, DirectiveLoc))
       return true;
     Register = getContext().getRegisterInfo()->getDwarfRegNum(RegNo, true);
   } else
     return parseAbsoluteExpression(Register);
 
   return false;
 }
 
 /// parseDirectiveCFIDefCfa
 /// ::= .cfi_def_cfa register,  offset
 bool MasmParser::parseDirectiveCFIDefCfa(SMLoc DirectiveLoc) {
-  int64_t Register = 0, Offset = 0;
+  uint64_t Register = 0;
+  int64_t Offset = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
       parseToken(AsmToken::Comma, "unexpected token in directive") ||
       parseAbsoluteExpression(Offset))
     return true;
 
   getStreamer().emitCFIDefCfa(Register, Offset);
   return false;
 }
 
 /// parseDirectiveCFIDefCfaOffset
 /// ::= .cfi_def_cfa_offset offset
 bool MasmParser::parseDirectiveCFIDefCfaOffset() {
   int64_t Offset = 0;
   if (parseAbsoluteExpression(Offset))
     return true;
 
   getStreamer().emitCFIDefCfaOffset(Offset);
   return false;
 }
 
 /// parseDirectiveCFIRegister
 /// ::= .cfi_register register, register
 bool MasmParser::parseDirectiveCFIRegister(SMLoc DirectiveLoc) {
-  int64_t Register1 = 0, Register2 = 0;
+  uint64_t Register1 = 0, Register2 = 0;
   if (parseRegisterOrRegisterNumber(Register1, DirectiveLoc) ||
       parseToken(AsmToken::Comma, "unexpected token in directive") ||
       parseRegisterOrRegisterNumber(Register2, DirectiveLoc))
     return true;
 
   getStreamer().emitCFIRegister(Register1, Register2);
   return false;
 }
bool MasmParser::parseDirectiveCFIAdjustCfaOffset() {
 
   getStreamer().emitCFIAdjustCfaOffset(Adjustment);
   return false;
 }
 
 /// parseDirectiveCFIDefCfaRegister
 /// ::= .cfi_def_cfa_register register
 bool MasmParser::parseDirectiveCFIDefCfaRegister(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
     return true;
 
   getStreamer().emitCFIDefCfaRegister(Register);
   return false;
 }
 
 /// parseDirectiveCFIOffset
 /// ::= .cfi_offset register, offset
 bool MasmParser::parseDirectiveCFIOffset(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   int64_t Offset = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
       parseToken(AsmToken::Comma, "unexpected token in directive") ||
       parseAbsoluteExpression(Offset))
     return true;
 
   getStreamer().emitCFIOffset(Register, Offset);
   return false;
 }
 
 /// parseDirectiveCFIRelOffset
 /// ::= .cfi_rel_offset register, offset
 bool MasmParser::parseDirectiveCFIRelOffset(SMLoc DirectiveLoc) {
-  int64_t Register = 0, Offset = 0;
+  uint64_t Register = 0;
+  int64_t Offset = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc) ||
       parseToken(AsmToken::Comma, "unexpected token in directive") ||
       parseAbsoluteExpression(Offset))
     return true;
 
   getStreamer().emitCFIRelOffset(Register, Offset);
   return false;

 bool MasmParser::parseDirectiveCFIRestoreState() {
   getStreamer().emitCFIRestoreState();
   return false;
 }
 
 /// parseDirectiveCFISameValue
 /// ::= .cfi_same_value register
 bool MasmParser::parseDirectiveCFISameValue(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
     return true;
 
   getStreamer().emitCFISameValue(Register);
   return false;
 }
 
 /// parseDirectiveCFIRestore
 /// ::= .cfi_restore register
 bool MasmParser::parseDirectiveCFIRestore(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
     return true;
 
   getStreamer().emitCFIRestore(Register);
   return false;
 }
 
 /// parseDirectiveCFIEscape
bool MasmParser::parseDirectiveCFIEscape() {
 
   getStreamer().emitCFIEscape(Values);
   return false;
 }
 
 /// parseDirectiveCFIReturnColumn
 /// ::= .cfi_return_column register
 bool MasmParser::parseDirectiveCFIReturnColumn(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
     return true;
   getStreamer().emitCFIReturnColumn(Register);
   return false;
 }
 
 /// parseDirectiveCFISignalFrame
 /// ::= .cfi_signal_frame
 bool MasmParser::parseDirectiveCFISignalFrame() {
   if (parseToken(AsmToken::EndOfStatement,
                  "unexpected token in '.cfi_signal_frame'"))
     return true;
 
   getStreamer().emitCFISignalFrame();
   return false;
 }
 
 /// parseDirectiveCFIUndefined
 /// ::= .cfi_undefined register
 bool MasmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
-  int64_t Register = 0;
+  uint64_t Register = 0;
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
     return true;
 
   getStreamer().emitCFIUndefined(Register);
   return false;
 }
 

llvm/lib/MC/MCStreamer.cpp

 }
 
 MCSymbol *MCStreamer::emitCFILabel() {
   // Return a dummy non-null value so that label fields appear filled in when
   // generating textual assembly.
   return (MCSymbol *)1;
 }
 
-void MCStreamer::emitCFIDefCfa(int64_t Register, int64_t Offset) {
+void MCStreamer::emitCFIDefCfa(uint64_t Register, int64_t Offset) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
       MCCFIInstruction::cfiDefCfa(Label, Register, Offset);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
-  CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
+  CurFrame->CurrentCfaRegister = Register;
 }
 
 void MCStreamer::emitCFIDefCfaOffset(int64_t Offset) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
       MCCFIInstruction::cfiDefCfaOffset(Label, Offset);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
 
 void MCStreamer::emitCFIAdjustCfaOffset(int64_t Adjustment) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
 
-void MCStreamer::emitCFIDefCfaRegister(int64_t Register) {
+void MCStreamer::emitCFIDefCfaRegister(uint64_t Register) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createDefCfaRegister(Label, Register);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
-  CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
+  CurFrame->CurrentCfaRegister = Register;
 }
 
-void MCStreamer::emitCFIOffset(int64_t Register, int64_t Offset) {
+void MCStreamer::emitCFIOffset(uint64_t Register, int64_t Offset) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createOffset(Label, Register, Offset);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
 
-void MCStreamer::emitCFIRelOffset(int64_t Register, int64_t Offset) {
+void MCStreamer::emitCFIRelOffset(uint64_t Register, int64_t Offset) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createRelOffset(Label, Register, Offset);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
void MCStreamer::emitCFIRestoreState() {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
 
-void MCStreamer::emitCFISameValue(int64_t Register) {
+void MCStreamer::emitCFISameValue(uint64_t Register) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createSameValue(Label, Register);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
 
-void MCStreamer::emitCFIRestore(int64_t Register) {
+void MCStreamer::emitCFIRestore(uint64_t Register) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createRestore(Label, Register);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }

 
 void MCStreamer::emitCFISignalFrame() {
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->IsSignalFrame = true;
 }
 
-void MCStreamer::emitCFIUndefined(int64_t Register) {
+void MCStreamer::emitCFIUndefined(uint64_t Register) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createUndefined(Label, Register);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
 
-void MCStreamer::emitCFIRegister(int64_t Register1, int64_t Register2) {
+void MCStreamer::emitCFIRegister(uint64_t Register1, uint64_t Register2) {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction =
     MCCFIInstruction::createRegister(Label, Register1, Register2);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
void MCStreamer::emitCFINegateRAState() {
   MCSymbol *Label = emitCFILabel();
   MCCFIInstruction Instruction = MCCFIInstruction::createNegateRAState(Label);
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->Instructions.push_back(Instruction);
 }
 
-void MCStreamer::emitCFIReturnColumn(int64_t Register) {
+void MCStreamer::emitCFIReturnColumn(uint64_t Register) {
   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
   if (!CurFrame)
     return;
   CurFrame->RAReg = Register;
 }
 
 WinEH::FrameInfo *MCStreamer::EnsureValidWinFrameInfo(SMLoc Loc) {
   const MCAsmInfo *MAI = Context.getAsmInfo();