[MC,NVPTX] Add MCAsmPrinter support for unsigned-only data directives.

[tra]

Summary

PTX does not support negative values in .bNN data directives and we must
emit such values in a way that ptxas can parse.

MCAsmInfo can now specify whether the target can emit negative values.

[tra]

Updated existing test which produced data directive w/ negative value.

[tra]

Ping!

[hfinkel]

llvm/lib/MC/MCExpr.cpp

69

Will uint64_t always be correct here? Shouldn't this depend on SizeInBytes (like the hex printing does)?

[tra]

llvm/lib/MC/MCExpr.cpp

69

MCConstantExpr::getValue() returns int64_t so casting it to uint64_t should be safe.

I guess I can find the matching unsigned type using std::make_unsigned. E.g:

using unsigned_t = typename std::make_unsigned<decltype(Value)>::type;
OS <<  static_cast<unsigned_t>(v);

[tra]

Use std::make_unsigned to find the matching unsigned type.

[hfinkel]

llvm/lib/MC/MCExpr.cpp

69

I'm not worried about the cast being unsafe, at the C++ level, I'm worried about it printing a number larger than the relevant directive actually accepts. In your test, the directive is .b64, which presumably takes a 64-bit integer, so everything's fine. What if it were .b8 and the printed argument were 18446744073709551613 (or whatever)?

[tra]

Mask out unwanted bits in the unsigned representation of the Value.

[tra]

llvm/lib/MC/MCExpr.cpp

69

Got it. I've masked out the unwanted bits.

[ABataev]

llvm/lib/MC/MCExpr.cpp

69

Does cuda gdb correctly handle the bitfields with this fix? Can you read/write values to/from bitfield in the debugger?

[tra]

llvm/lib/MC/MCExpr.cpp

69

Sort of. It seems to handle field bits within a byte and knows correct bit field length, but struggles with the field which crosses the byte boundary.

E.g:

    struct s {
      unsigned char a : 3;
      unsigned char b : 6;
    } __attribute__((__packed__)) b;

(cuda-gdb) set var b.a=7   # This sets the field correctly.
(cuda-gdb) p b
$7 = {
  a = 7 '\a',
  b = 0 '\000'
}
(cuda-gdb) x/2bx &b
0x7fffca800100: 0x07    0x00
(cuda-gdb) set var b.a=8
warning: Value does not fit in 3 bits. 

(cuda-gdb) set var b.b=0x3f   # This one loses the top bit.
(cuda-gdb) p b
$8 = {
  a = 0 '\000',
  b = 31 '\037'   # Only 5 bits are set.
}
(cuda-gdb) x/2bx &b
0x7fffca800100: 0xf8    0x00  # Should've been 0xf8 0x01

[ABataev]

llvm/lib/MC/MCExpr.cpp

69

Hm, did you try to emit it as hexadecimal?

[hfinkel]

llvm/lib/MC/MCExpr.cpp

69

Hm, did you try to emit it as hexadecimal?

Good point. Maybe we want the option to just force hex printing instead of this new case? Then we can just reuse the existing logic above for that.

[tra]

llvm/lib/MC/MCExpr.cpp

69

Makes no difference. I've run ptxas on .ptx with the constant represented as decimal or as hex. ptxas accepted both and produced bit-for-bit identical binaries.

[hfinkel]

llvm/lib/MC/MCExpr.cpp

69

In that case, I recommend that we go with Alexey's suggestion. Remove this logic and make the condition above if (PrintInHex || (MAI && !MAI->supportsSignedData())) (or something like that).

[tra]

llvm/lib/MC/MCExpr.cpp

69

I'm concerned that the extra 0x and always-on zero-padding will noticeably increase the size of PTX with the debug info as DWARF output seems to be predominantly .b8. Large builds like tensorflow already struggle with their binary size (we already run into ELF reloc overflows in debug builds unless we limit the number of GPUs we target) and this will contribute to the issue.

[hfinkel]

llvm/lib/MC/MCExpr.cpp

69

I'm concerned that the extra 0x and always-on zero-padding will noticeably increase the size of PTX with the debug info as DWARF output seems to be predominantly .b8. Large builds like tensorflow already struggle with their binary size (we already run into ELF reloc overflows in debug builds unless we limit the number of GPUs we target) and this will contribute to the issue.

Ah, okay. I can understand that.

Can you make a test case where this affects the printing of a .b8 directive?

[ABataev]

llvm/lib/MC/MCExpr.cpp

69

Maybe just print the value as hexadecimal if it is negative?

[ABataev]

llvm/lib/MC/MCExpr.cpp

69

Also, I can try to check if another my patch for bitfields works correctly.

[tra]

llvm/lib/MC/MCExpr.cpp

69

The DWARF so far is the only way I've found to get MC to generate constant values in PTX.
Global variables use appropriate .s8/.u8 directives.
Arrays always use .b8 with unsigned byte values.
Nothing else other than DWARF produces .bXX directives, AFAICT.

MC tests run into the problem that they seem to rely on assembling/disassembling something and we can do neither for PTX.

I'm not particularly familiar with MC, so I may be missing something. Ideas/suggestions are welcome.

[ABataev]

llvm/lib/MC/MCExpr.cpp

69

Yes, DWARF is the only place that produces .bXX directives.

[tra]

Print negative values as hex.

[tra]

llvm/lib/MC/MCExpr.cpp

69

Maybe just print the value as hexadecimal if it is negative?

Good idea. Done.

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// current section.  If a data directive is set to null, smaller data
   /// directives will be used to emit the large sizes.  Defaults to "\t.byte\t",
   /// "\t.short\t", "\t.long\t", "\t.quad\t"
   const char *Data8bitsDirective;
   const char *Data16bitsDirective;
   const char *Data32bitsDirective;
   const char *Data64bitsDirective;
 
+  /// True if data directives support signed values
+  bool SupportsSignedData = true;
+
   /// If non-null, a directive that is used to emit a word which should be
   /// relocated as a 64-bit GP-relative offset, e.g. .gpdword on Mips.  Defaults
   /// to nullptr.
   const char *GPRel64Directive = nullptr;
 
   /// If non-null, a directive that is used to emit a word which should be
   /// relocated as a 32-bit GP-relative offset, e.g. .gpword on Mips or .gprel32
   /// on Alpha.  Defaults to nullptr.
public:
   bool hasSubsectionsViaSymbols() const { return HasSubsectionsViaSymbols; }
 
   // Data directive accessors.
 
   const char *getData8bitsDirective() const { return Data8bitsDirective; }
   const char *getData16bitsDirective() const { return Data16bitsDirective; }
   const char *getData32bitsDirective() const { return Data32bitsDirective; }
   const char *getData64bitsDirective() const { return Data64bitsDirective; }
+  bool supportsSignedData() const { return SupportsSignedData; }
   const char *getGPRel64Directive() const { return GPRel64Directive; }
   const char *getGPRel32Directive() const { return GPRel32Directive; }
   const char *getDTPRel64Directive() const { return DTPRel64Directive; }
   const char *getDTPRel32Directive() const { return DTPRel32Directive; }
   const char *getTPRel64Directive() const { return TPRel64Directive; }
   const char *getTPRel32Directive() const { return TPRel32Directive; }
 
   /// Targets can implement this method to specify a section to switch to if the

llvm/lib/MC/MCExpr.cpp

if (PrintInHex)
         break;
       case 4:
         OS << format("0x%08" PRIx64, Value);
         break;
       case 8:
         OS << format("0x%016" PRIx64, Value);
         break;
       }
+    else if (MAI && !MAI->supportsSignedData())
+      OS << static_cast<uint64_t>(Value);
     else
       OS << Value;
     return;
   }
   case MCExpr::SymbolRef: {
     const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(*this);
     const MCSymbol &Sym = SRE.getSymbol();
     // Parenthesize names that start with $ so that they don't look like

llvm/lib/Target/NVPTX/MCTargetDesc/NVPTXMCAsmInfo.cpp

NVPTXMCAsmInfo::NVPTXMCAsmInfo(const Triple &TheTriple,
   Data16bitsDirective = nullptr; // not supported
   Data32bitsDirective = ".b32 ";
   Data64bitsDirective = ".b64 ";
   ZeroDirective = ".b8";
   AsciiDirective = nullptr; // not supported
   AscizDirective = nullptr; // not supported
   SupportsQuotedNames = false;
   SupportsExtendedDwarfLocDirective = false;
+  SupportsSignedData = false;
 
   // @TODO: Can we just disable this?
   WeakDirective = "\t// .weak\t";
   GlobalDirective = "\t// .globl\t";
 
   UseIntegratedAssembler = false;
 }

llvm/test/CodeGen/NVPTX/data-direcitve-negative-values.ll

+; PTX only allows unsigned values in .b64/32/8 directives.  However,
+; MCAsmPrinter only deals with int64 values and if the value happens to be
+; negative, we ended up with invalid PTX. Fortunately, data directives are
+; almost never produced and when they are, they are normally used with small
+; unsigned values representable by int64. One exception is DWARF which emits a
+; lot of data and some of the values may be negative. The IR below has been
+; produced by the following CUDA code compiled with DWARF debug info enabled.
+;
+;struct {
+;  char : 3;
+;  char a : 6;
+;} __attribute__((__packed__)) b;
+;__attribute__((global)) void c() { auto d = b; }
+;
+; RUN: llc -O0 < %s -march=nvptx64 -mcpu=sm_60 | FileCheck %s
+;
+; Make sure there are no negative values
+; CHECK-NOT: .b64 -
+;
+target datalayout = "e-i64:64-i128:128-v16:16-v32:32-n16:32:64"
+target triple = "nvptx64-nvidia-cuda"
+
+%struct.anon = type { i16 }
+
+@b = external dso_local addrspace(1) global %struct.anon, align 1
+
+; Function Attrs: convergent noinline norecurse nounwind optnone
+define dso_local void @_Z1cv() #0 !dbg !9 {
+entry:
+  %d = alloca %struct.anon, align 1
+  call void @llvm.dbg.declare(metadata %struct.anon* %d, metadata !12, metadata !DIExpression()), !dbg !17
+  %0 = bitcast %struct.anon* %d to i8*, !dbg !18
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %0, i8* align 1 addrspacecast (i8 addrspace(1)* bitcast (%struct.anon addrspace(1)* @b to i8 addrspace(1)*) to i8*), i64 2, i1 false), !dbg !18
+  ret void, !dbg !19
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #2
+
+attributes #0 = { convergent noinline norecurse nounwind optnone "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="sm_60" "target-features"="+ptx32,+sm_60" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone speculatable willreturn }
+attributes #2 = { argmemonly nounwind willreturn }
+
+!llvm.dbg.cu = !{!0}
+!nvvm.annotations = !{!3}
+!llvm.module.flags = !{!4, !5, !6, !7}
+!llvm.ident = !{!8}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_11, file: !1, producer: "clang version 11.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "b64.cu", directory: "/usr/local/google/home/tra/work/llvm/build/debug")
+!2 = !{}
+!3 = !{void ()* @_Z1cv, !"kernel", i32 1}
+!4 = !{i32 7, !"Dwarf Version", i32 2}
+!5 = !{i32 2, !"Debug Info Version", i32 3}
+!6 = !{i32 1, !"wchar_size", i32 4}
+!7 = !{i32 4, !"nvvm-reflect-ftz", i32 0}
+!8 = !{!"clang version 11.0.0 "}
+!9 = distinct !DISubprogram(name: "c", linkageName: "_Z1cv", scope: !1, file: !1, line: 5, type: !10, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!10 = !DISubroutineType(types: !11)
+!11 = !{null}
+!12 = !DILocalVariable(name: "d", scope: !9, file: !1, line: 5, type: !13)
+!13 = distinct !DICompositeType(tag: DW_TAG_structure_type, file: !1, line: 1, size: 16, flags: DIFlagTypePassByValue, elements: !14)
+!14 = !{!15}
+!15 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !13, file: !1, line: 3, baseType: !16, size: 6, offset: 3, flags: DIFlagBitField, extraData: i64 0)
+!16 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!17 = !DILocation(line: 5, column: 41, scope: !9)
+!18 = !DILocation(line: 5, column: 45, scope: !9)
+!19 = !DILocation(line: 5, column: 48, scope: !9)