[CommandLine] Provide parser<unsigned long> instantiation to allow cl::opt<uint64_t> on LP64 platforms

[MaskRay]

Summary

And migrate opt<unsigned long long> to opt<uint64_t>

Fixes PR19665

[yln]

include/llvm/Support/CommandLine.h

1012 ↗

(On Diff #195961)

Is this the "data type" or just the "kind" of the value? I am asking because float/double are just labeled "number".

Where is this string used? Is it included in the user error message on parse error?

lib/Support/CommandLine.cpp

1674 ↗

(On Diff #195961)

uint used here, but not above.
Best would probably be to use the exact data type everywhere (+ existing parsers)

lib/Support/RandomNumberGenerator.cpp

30 ↗

(On Diff #195961)

Thanks! Fixing a 5 year old issue. I am delighted! :)

[MaskRay]

include/llvm/Support/CommandLine.h

1012 ↗

(On Diff #195961)

It used in the -help message, e.g. -instcombine-max-num-phis=<uint>. It is also included in the error message when the parsing fails, e.g. ` return O.error("'" + Arg + "' value invalid for ulong argument!");
`

[MaskRay]

Rebase and make a drive-by fix uint -> ulong

[yln]

thanks!

llvm/trunk/include/llvm/Support/CommandLine.h

public:
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 
 extern template class basic_parser<unsigned>;
 
 //--------------------------------------------------
+// parser<unsigned long>
+//
+template <>
+class parser<unsigned long> final : public basic_parser<unsigned long> {
+public:
+  parser(Option &O) : basic_parser(O) {}
+
+  // parse - Return true on error.
+  bool parse(Option &O, StringRef ArgName, StringRef Arg, unsigned long &Val);
+
+  // getValueName - Overload in subclass to provide a better default value.
+  StringRef getValueName() const override { return "ulong"; }
+
+  void printOptionDiff(const Option &O, unsigned long V, OptVal Default,
+                       size_t GlobalWidth) const;
+
+  // An out-of-line virtual method to provide a 'home' for this class.
+  void anchor() override;
+};
+
+extern template class basic_parser<unsigned long>;
+
+//--------------------------------------------------
 // parser<unsigned long long>
 //
 template <>
 class parser<unsigned long long> final
     : public basic_parser<unsigned long long> {
 public:
   parser(Option &O) : basic_parser(O) {}
 
   // parse - Return true on error.
   bool parse(Option &O, StringRef ArgName, StringRef Arg,
              unsigned long long &Val);
 
   // getValueName - Overload in subclass to provide a better default value.
-  StringRef getValueName() const override { return "uint"; }
+  StringRef getValueName() const override { return "ulong"; }
 
   void printOptionDiff(const Option &O, unsigned long long V, OptVal Default,
                        size_t GlobalWidth) const;
 
   // An out-of-line virtual method to provide a 'home' for this class.
   void anchor() override;
 };
 

llvm/trunk/lib/Support/CommandLine.cpp

 // Template instantiations and anchors.
 //
 namespace llvm {
 namespace cl {
 template class basic_parser<bool>;
 template class basic_parser<boolOrDefault>;
 template class basic_parser<int>;
 template class basic_parser<unsigned>;
+template class basic_parser<unsigned long>;
 template class basic_parser<unsigned long long>;
 template class basic_parser<double>;
 template class basic_parser<float>;
 template class basic_parser<std::string>;
 template class basic_parser<char>;
 
 template class opt<unsigned>;
 template class opt<int>;
 template class opt<std::string>;
 template class opt<char>;
 template class opt<bool>;
 }
 } // end namespace llvm::cl
 
 // Pin the vtables to this file.
 void GenericOptionValue::anchor() {}
 void OptionValue<boolOrDefault>::anchor() {}
 void OptionValue<std::string>::anchor() {}
 void Option::anchor() {}
 void basic_parser_impl::anchor() {}
 void parser<bool>::anchor() {}
 void parser<boolOrDefault>::anchor() {}
 void parser<int>::anchor() {}
 void parser<unsigned>::anchor() {}
+void parser<unsigned long>::anchor() {}
 void parser<unsigned long long>::anchor() {}
 void parser<double>::anchor() {}
 void parser<float>::anchor() {}
 void parser<std::string>::anchor() {}
 void parser<char>::anchor() {}
 
 //===----------------------------------------------------------------------===//
 

 bool parser<unsigned>::parse(Option &O, StringRef ArgName, StringRef Arg,
                              unsigned &Value) {
 
   if (Arg.getAsInteger(0, Value))
     return O.error("'" + Arg + "' value invalid for uint argument!");
   return false;
 }
 
+// parser<unsigned long> implementation
+//
+bool parser<unsigned long>::parse(Option &O, StringRef ArgName, StringRef Arg,
+                                  unsigned long &Value) {
+
+  if (Arg.getAsInteger(0, Value))
+    return O.error("'" + Arg + "' value invalid for ulong argument!");
+  return false;
+}
+
 // parser<unsigned long long> implementation
 //
 bool parser<unsigned long long>::parse(Option &O, StringRef ArgName,
                                        StringRef Arg,
                                        unsigned long long &Value) {
 
   if (Arg.getAsInteger(0, Value))
-    return O.error("'" + Arg + "' value invalid for uint argument!");
+    return O.error("'" + Arg + "' value invalid for ullong argument!");
   return false;
 }
 
 // parser<double>/parser<float> implementation
 //
 static bool parseDouble(Option &O, StringRef Arg, double &Value) {
   if (to_float(Arg, Value))
     return false;
else                                                                       \
       outs() << "*no default*";                                                \
     outs() << ")\n";                                                           \
   }
 
 PRINT_OPT_DIFF(bool)
 PRINT_OPT_DIFF(boolOrDefault)
 PRINT_OPT_DIFF(int)
 PRINT_OPT_DIFF(unsigned)
+PRINT_OPT_DIFF(unsigned long)
 PRINT_OPT_DIFF(unsigned long long)
 PRINT_OPT_DIFF(double)
 PRINT_OPT_DIFF(float)
 PRINT_OPT_DIFF(char)
 
 void parser<std::string>::printOptionDiff(const Option &O, StringRef V,
                                           const OptionValue<std::string> &D,
                                           size_t GlobalWidth) const {

llvm/trunk/lib/Support/RandomNumberGenerator.cpp

 #else
 #include "Unix/Unix.h"
 #endif
 
 using namespace llvm;
 
 #define DEBUG_TYPE "rng"
 
-// Tracking BUG: 19665
-// http://llvm.org/bugs/show_bug.cgi?id=19665
-//
-// Do not change to cl::opt<uint64_t> since this silently breaks argument parsing.
-static cl::opt<unsigned long long>
-    Seed("rng-seed", cl::value_desc("seed"), cl::Hidden,
-         cl::desc("Seed for the random number generator"), cl::init(0));
+static cl::opt<uint64_t> Seed("rng-seed", cl::value_desc("seed"), cl::Hidden,
+                              cl::desc("Seed for the random number generator"),
+                              cl::init(0));
 
 RandomNumberGenerator::RandomNumberGenerator(StringRef Salt) {
   LLVM_DEBUG(if (Seed == 0) dbgs()
              << "Warning! Using unseeded random number generator.\n");
 
   // Combine seed and salts using std::seed_seq.
   // Data: Seed-low, Seed-high, Salt
   // Note: std::seed_seq can only store 32-bit values, even though we

llvm/trunk/lib/Transforms/Instrumentation/AddressSanitizer.cpp

 // These flags allow to change the shadow mapping.
 // The shadow mapping looks like
 //    Shadow = (Mem >> scale) + offset
 
 static cl::opt<int> ClMappingScale("asan-mapping-scale",
                                    cl::desc("scale of asan shadow mapping"),
                                    cl::Hidden, cl::init(0));
 
-static cl::opt<unsigned long long> ClMappingOffset(
-    "asan-mapping-offset",
-    cl::desc("offset of asan shadow mapping [EXPERIMENTAL]"), cl::Hidden,
-    cl::init(0));
+static cl::opt<uint64_t>
+    ClMappingOffset("asan-mapping-offset",
+                    cl::desc("offset of asan shadow mapping [EXPERIMENTAL]"),
+                    cl::Hidden, cl::init(0));
 
 // Optimization flags. Not user visible, used mostly for testing
 // and benchmarking the tool.
 
 static cl::opt<bool> ClOpt("asan-opt", cl::desc("Optimize instrumentation"),
                            cl::Hidden, cl::init(true));
 
 static cl::opt<bool> ClOptSameTemp(

llvm/trunk/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

static cl::opt<bool> ClEnableKhwasan(
     "hwasan-kernel",
     cl::desc("Enable KernelHWAddressSanitizer instrumentation"),
     cl::Hidden, cl::init(false));
 
 // These flags allow to change the shadow mapping and control how shadow memory
 // is accessed. The shadow mapping looks like:
 //    Shadow = (Mem >> scale) + offset
 
-static cl::opt<unsigned long long> ClMappingOffset(
-    "hwasan-mapping-offset",
-    cl::desc("HWASan shadow mapping offset [EXPERIMENTAL]"), cl::Hidden,
-    cl::init(0));
+static cl::opt<uint64_t>
+    ClMappingOffset("hwasan-mapping-offset",
+                    cl::desc("HWASan shadow mapping offset [EXPERIMENTAL]"),
+                    cl::Hidden, cl::init(0));
 
 static cl::opt<bool>
     ClWithIfunc("hwasan-with-ifunc",
                 cl::desc("Access dynamic shadow through an ifunc global on "
                          "platforms that support this"),
                 cl::Hidden, cl::init(false));
 
 static cl::opt<bool> ClWithTls(

llvm/trunk/lib/Transforms/Instrumentation/MemorySanitizer.cpp

 // This is off by default because of a bug in gold:
 // https://sourceware.org/bugzilla/show_bug.cgi?id=19002
 static cl::opt<bool> ClWithComdat("msan-with-comdat",
        cl::desc("Place MSan constructors in comdat sections"),
        cl::Hidden, cl::init(false));
 
 // These options allow to specify custom memory map parameters
 // See MemoryMapParams for details.
-static cl::opt<unsigned long long> ClAndMask("msan-and-mask",
+static cl::opt<uint64_t> ClAndMask("msan-and-mask",
                                    cl::desc("Define custom MSan AndMask"),
                                    cl::Hidden, cl::init(0));
 
-static cl::opt<unsigned long long> ClXorMask("msan-xor-mask",
+static cl::opt<uint64_t> ClXorMask("msan-xor-mask",
                                    cl::desc("Define custom MSan XorMask"),
                                    cl::Hidden, cl::init(0));
 
-static cl::opt<unsigned long long> ClShadowBase("msan-shadow-base",
+static cl::opt<uint64_t> ClShadowBase("msan-shadow-base",
                                       cl::desc("Define custom MSan ShadowBase"),
                                       cl::Hidden, cl::init(0));
 
-static cl::opt<unsigned long long> ClOriginBase("msan-origin-base",
+static cl::opt<uint64_t> ClOriginBase("msan-origin-base",
                                       cl::desc("Define custom MSan OriginBase"),
                                       cl::Hidden, cl::init(0));
 
 static const char *const kMsanModuleCtorName = "msan.module_ctor";
 static const char *const kMsanInitName = "__msan_init";
 
 namespace {
 
 // Memory map parameters used in application-to-shadow address calculation.
 // Offset = (Addr & ~AndMask) ^ XorMask

llvm/trunk/tools/llvm-cfi-verify/lib/GraphBuilder.h

 #include <string>
 #include <unordered_map>
 
 using Instr = llvm::cfi_verify::FileAnalysis::Instr;
 
 namespace llvm {
 namespace cfi_verify {
 
-extern unsigned long long SearchLengthForUndef;
-extern unsigned long long SearchLengthForConditionalBranch;
+extern uint64_t SearchLengthForUndef;
+extern uint64_t SearchLengthForConditionalBranch;
 
 struct ConditionalBranchNode {
   uint64_t Address;
   uint64_t Target;
   uint64_t Fallthrough;
   // Does this conditional branch look like it's used for CFI protection? i.e.
   //  - The exit point of a basic block whos entry point is {target|fallthrough}
   //    is a CFI trap, and...

llvm/trunk/tools/llvm-cfi-verify/lib/GraphBuilder.cpp

 #include "llvm/Support/raw_ostream.h"
 
 
 using Instr = llvm::cfi_verify::FileAnalysis::Instr;
 
 namespace llvm {
 namespace cfi_verify {
 
-unsigned long long SearchLengthForUndef;
-unsigned long long SearchLengthForConditionalBranch;
+uint64_t SearchLengthForUndef;
+uint64_t SearchLengthForConditionalBranch;
 
-static cl::opt<unsigned long long, true> SearchLengthForUndefArg(
+static cl::opt<uint64_t, true> SearchLengthForUndefArg(
     "search-length-undef",
     cl::desc("Specify the maximum amount of instructions "
              "to inspect when searching for an undefined "
              "instruction from a conditional branch."),
     cl::location(SearchLengthForUndef), cl::init(2));
 
-static cl::opt<unsigned long long, true> SearchLengthForConditionalBranchArg(
+static cl::opt<uint64_t, true> SearchLengthForConditionalBranchArg(
     "search-length-cb",
     cl::desc("Specify the maximum amount of instructions "
              "to inspect when searching for a conditional "
              "branch from an indirect control flow."),
     cl::location(SearchLengthForConditionalBranch), cl::init(20));
 
 std::vector<uint64_t> GraphResult::flattenAddress(uint64_t Address) const {
   std::vector<uint64_t> Addresses;

llvm/trunk/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

static alias IgnoreCaseAlias("i", desc("Alias for -ignore-case."),
                              aliasopt(IgnoreCase));
 static list<std::string> Name(
     "name",
     desc("Find and print all debug info entries whose name (DW_AT_name "
          "attribute) matches the exact text in <pattern>.  When used with the "
          "the -regex option <pattern> is interpreted as a regular expression."),
     value_desc("pattern"), cat(DwarfDumpCategory));
 static alias NameAlias("n", desc("Alias for -name"), aliasopt(Name));
-static opt<unsigned long long> Lookup("lookup",
+static opt<uint64_t>
+    Lookup("lookup",
            desc("Lookup <address> in the debug information and print out any "
                 "available file, function, block and line table details."),
            value_desc("address"), cat(DwarfDumpCategory));
 static opt<std::string>
     OutputFilename("out-file", cl::init("-"),
                    cl::desc("Redirect output to the specified file."),
                    cl::value_desc("filename"));
 static alias OutputFilenameAlias("o", desc("Alias for -out-file."),

llvm/trunk/tools/llvm-lto/llvm-lto.cpp

 
 static cl::opt<std::string>
     ThinLTOCacheDir("thinlto-cache-dir", cl::desc("Enable ThinLTO caching."));
 
 static cl::opt<int>
     ThinLTOCachePruningInterval("thinlto-cache-pruning-interval",
     cl::init(1200), cl::desc("Set ThinLTO cache pruning interval."));
 
-static cl::opt<unsigned long long>
-    ThinLTOCacheMaxSizeBytes("thinlto-cache-max-size-bytes",
+static cl::opt<uint64_t> ThinLTOCacheMaxSizeBytes(
+    "thinlto-cache-max-size-bytes",
     cl::desc("Set ThinLTO cache pruning directory maximum size in bytes."));
 
 static cl::opt<int>
     ThinLTOCacheMaxSizeFiles("thinlto-cache-max-size-files", cl::init(1000000),
     cl::desc("Set ThinLTO cache pruning directory maximum number of files."));
 
 static cl::opt<unsigned>
     ThinLTOCacheEntryExpiration("thinlto-cache-entry-expiration", cl::init(604800) /* 1w */,

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

 extern cl::opt<bool> InfoPlist;
 extern cl::opt<bool> LazyBind;
 extern cl::opt<bool> LinkOptHints;
 extern cl::opt<bool> ObjcMetaData;
 extern cl::opt<bool> Rebase;
 extern cl::opt<bool> UniversalHeaders;
 extern cl::opt<bool> WeakBind;
 
-static cl::opt<unsigned long long> AdjustVMA(
+static cl::opt<uint64_t> AdjustVMA(
     "adjust-vma",
     cl::desc("Increase the displayed address by the specified offset"),
     cl::value_desc("offset"), cl::init(0));
 
 static cl::opt<bool>
     AllHeaders("all-headers",
                cl::desc("Display all available header information"));
 static cl::alias AllHeadersShort("x", cl::desc("Alias for --all-headers"),

 static cl::opt<bool> PrintSource(
     "source",
     cl::desc(
         "Display source inlined with disassembly. Implies disassemble object"));
 static cl::alias PrintSourceShort("S", cl::desc("Alias for -source"),
                                   cl::NotHidden, cl::Grouping,
                                   cl::aliasopt(PrintSource));
 
-static cl::opt<unsigned long long>
+static cl::opt<uint64_t>
     StartAddress("start-address", cl::desc("Disassemble beginning at address"),
                  cl::value_desc("address"), cl::init(0));
-static cl::opt<unsigned long long>
-    StopAddress("stop-address", cl::desc("Stop disassembly at address"),
-                cl::value_desc("address"), cl::init(UINT64_MAX));
+static cl::opt<uint64_t> StopAddress("stop-address",
+                                     cl::desc("Stop disassembly at address"),
+                                     cl::value_desc("address"),
+                                     cl::init(UINT64_MAX));
 
 cl::opt<bool> SymbolTable("syms", cl::desc("Display the symbol table"));
 static cl::alias SymbolTableShort("t", cl::desc("Alias for --syms"),
                                   cl::NotHidden, cl::Grouping,
                                   cl::aliasopt(SymbolTable));
 
 cl::opt<std::string> TripleName("triple",
                                 cl::desc("Target triple to disassemble for, "

llvm/trunk/tools/llvm-rtdyld/llvm-rtdyld.cpp

MCPU("mcpu",
      cl::value_desc("cpu-name"),
      cl::init(""));
 
 static cl::list<std::string>
 CheckFiles("check",
            cl::desc("File containing RuntimeDyld verifier checks."),
            cl::ZeroOrMore);
 
-// Tracking BUG: 19665
-// http://llvm.org/bugs/show_bug.cgi?id=19665
-//
-// Do not change these options to cl::opt<uint64_t> since this silently breaks
-// argument parsing.
-static cl::opt<unsigned long long>
+static cl::opt<uint64_t>
     PreallocMemory("preallocate",
                    cl::desc("Allocate memory upfront rather than on-demand"),
                    cl::init(0));
 
-static cl::opt<unsigned long long>
-TargetAddrStart("target-addr-start",
-                cl::desc("For -verify only: start of phony target address "
-                         "range."),
-                cl::init(4096), // Start at "page 1" - no allocating at "null".
-                cl::Hidden);
+static cl::opt<uint64_t> TargetAddrStart(
+    "target-addr-start",
 
-static cl::opt<unsigned long long>
-TargetAddrEnd("target-addr-end",
-              cl::desc("For -verify only: end of phony target address range."),
-              cl::init(~0ULL),
-              cl::Hidden);
+static cl::opt<uint64_t> TargetAddrEnd(
+    "target-addr-end",
+    cl::init(~0ULL), cl::Hidden);
 
-static cl::opt<unsigned long long>
-TargetSectionSep("target-section-sep",
-                 cl::desc("For -verify only: Separation between sections in "
-                          "phony target address space."),
-                 cl::init(0),
-                 cl::Hidden);
+static cl::opt<uint64_t> TargetSectionSep(
+    "target-section-sep",
+    cl::init(0), cl::Hidden);
 
 static cl::list<std::string>
 SpecificSectionMappings("map-section",
                         cl::desc("For -verify only: Map a section to a "
                                  "specific address."),
                         cl::ZeroOrMore,
                         cl::Hidden);
 

llvm/trunk/tools/llvm-symbolizer/llvm-symbolizer.cpp

 static cl::opt<int> ClPrintSourceContextLines(
     "print-source-context-lines", cl::init(0),
     cl::desc("Print N number of source file context"));
 
 static cl::opt<bool> ClVerbose("verbose", cl::init(false),
                                cl::desc("Print verbose line info"));
 
 // -adjust-vma
-static cl::opt<unsigned long long>
+static cl::opt<uint64_t>
     ClAdjustVMA("adjust-vma", cl::init(0), cl::value_desc("offset"),
                 cl::desc("Add specified offset to object file addresses"));
 
 static cl::list<std::string> ClInputAddresses(cl::Positional,
                                               cl::desc("<input addresses>..."),
                                               cl::ZeroOrMore);
 
 static cl::opt<std::string>