[llvm-objdump] Remove "No" prefixes on variables

[thakis]

Summary

...to remove double negation in the code. Requested in D100583.

No behavior change.

[MaskRay]

Looks great!

llvm/tools/llvm-objdump/MachODump.h

 class InputArgList;
 } // namespace opt
 
 namespace objdump {
 
 void parseMachOOptions(const llvm::opt::InputArgList &InputArgs);
 
 // MachO specific options
-extern cl::OptionCategory MachOCat;
 extern bool Bind;
 extern bool DataInCode;
-extern bool DylibsUsed;
+extern std::string DisSymName;
 extern bool DylibId;
+extern bool DylibsUsed;
 extern bool ExportsTrie;
 extern bool FirstPrivateHeader;
 extern bool FullLeadingAddr;
 extern bool FunctionStarts;
 extern bool IndirectSymbols;
 extern bool InfoPlist;
 extern bool LazyBind;
+extern bool LeadingHeaders;
 extern bool LinkOptHints;
-extern bool NoLeadingHeaders;
-extern bool NoSymbolicOperands;
-extern bool Verbose;
 extern bool ObjcMetaData;
-extern std::string DisSymName;
 extern bool Rebase;
+extern bool SymbolicOperands;
 extern bool UniversalHeaders;
+extern bool Verbose;
 extern bool WeakBind;
 
 Error getMachORelocationValueString(const object::MachOObjectFile *Obj,
                                     const object::RelocationRef &RelRef,
                                     llvm::SmallVectorImpl<char> &Result);
 
 void parseInputMachO(StringRef Filename);
 void parseInputMachO(object::MachOUniversalBinary *UB);

llvm/tools/llvm-objdump/MachODump.cpp

 bool objdump::ExportsTrie;
 bool objdump::Rebase;
 bool objdump::Bind;
 bool objdump::LazyBind;
 bool objdump::WeakBind;
 static bool UseDbg;
 static std::string DSYMFile;
 bool objdump::FullLeadingAddr;
-bool objdump::NoLeadingHeaders;
+bool objdump::LeadingHeaders;
 bool objdump::UniversalHeaders;
 static bool ArchiveMemberOffsets;
 bool objdump::IndirectSymbols;
 bool objdump::DataInCode;
 bool objdump::FunctionStarts;
 bool objdump::LinkOptHints;
 bool objdump::InfoPlist;
 bool objdump::DylibsUsed;
 bool objdump::DylibId;
 bool objdump::Verbose;
 bool objdump::ObjcMetaData;
 std::string objdump::DisSymName;
-bool objdump::NoSymbolicOperands;
+bool objdump::SymbolicOperands;
 static std::vector<std::string> ArchFlags;
 
 static bool ArchAll = false;
 static std::string ThumbTripleName;
 
 void objdump::parseMachOOptions(const llvm::opt::InputArgList &InputArgs) {
   FirstPrivateHeader = InputArgs.hasArg(OBJDUMP_private_header);
   ExportsTrie = InputArgs.hasArg(OBJDUMP_exports_trie);
   Rebase = InputArgs.hasArg(OBJDUMP_rebase);
   Bind = InputArgs.hasArg(OBJDUMP_bind);
   LazyBind = InputArgs.hasArg(OBJDUMP_lazy_bind);
   WeakBind = InputArgs.hasArg(OBJDUMP_weak_bind);
   UseDbg = InputArgs.hasArg(OBJDUMP_g);
   DSYMFile = InputArgs.getLastArgValue(OBJDUMP_dsym_EQ).str();
   FullLeadingAddr = InputArgs.hasArg(OBJDUMP_full_leading_addr);
-  NoLeadingHeaders = InputArgs.hasArg(OBJDUMP_no_leading_headers);
+  LeadingHeaders = !InputArgs.hasArg(OBJDUMP_no_leading_headers);
   UniversalHeaders = InputArgs.hasArg(OBJDUMP_universal_headers);
   ArchiveMemberOffsets = InputArgs.hasArg(OBJDUMP_archive_member_offsets);
   IndirectSymbols = InputArgs.hasArg(OBJDUMP_indirect_symbols);
   DataInCode = InputArgs.hasArg(OBJDUMP_data_in_code);
   FunctionStarts = InputArgs.hasArg(OBJDUMP_function_starts);
   LinkOptHints = InputArgs.hasArg(OBJDUMP_link_opt_hints);
   InfoPlist = InputArgs.hasArg(OBJDUMP_info_plist);
   DylibsUsed = InputArgs.hasArg(OBJDUMP_dylibs_used);
   DylibId = InputArgs.hasArg(OBJDUMP_dylib_id);
   Verbose = !InputArgs.hasArg(OBJDUMP_non_verbose);
   ObjcMetaData = InputArgs.hasArg(OBJDUMP_objc_meta_data);
   DisSymName = InputArgs.getLastArgValue(OBJDUMP_dis_symname).str();
-  NoSymbolicOperands = InputArgs.hasArg(OBJDUMP_no_symbolic_operands);
+  SymbolicOperands = !InputArgs.hasArg(OBJDUMP_no_symbolic_operands);
   ArchFlags = InputArgs.getAllArgValues(OBJDUMP_arch_EQ);
 }
 
 static const Target *GetTarget(const MachOObjectFile *MachOObj,
                                const char **McpuDefault,
                                const Target **ThumbTarget) {
   // Figure out the target triple.
   Triple TT(TripleName);

 static uint64_t DumpDataInCode(const uint8_t *bytes, uint64_t Length,
                                unsigned short Kind) {
   uint32_t Value, Size = 1;
 
   switch (Kind) {
   default:
   case MachO::DICE_KIND_DATA:
     if (Length >= 4) {
-      if (!NoShowRawInsn)
+      if (ShowRawInsn)
         dumpBytes(makeArrayRef(bytes, 4), outs());
       Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
       outs() << "\t.long " << Value;
       Size = 4;
     } else if (Length >= 2) {
-      if (!NoShowRawInsn)
+      if (ShowRawInsn)
         dumpBytes(makeArrayRef(bytes, 2), outs());
       Value = bytes[1] << 8 | bytes[0];
       outs() << "\t.short " << Value;
       Size = 2;
     } else {
-      if (!NoShowRawInsn)
+      if (ShowRawInsn)
         dumpBytes(makeArrayRef(bytes, 2), outs());
       Value = bytes[0];
       outs() << "\t.byte " << Value;
       Size = 1;
     }
     if (Kind == MachO::DICE_KIND_DATA)
       outs() << "\t@ KIND_DATA\n";
     else
       outs() << "\t@ data in code kind = " << Kind << "\n";
     break;
   case MachO::DICE_KIND_JUMP_TABLE8:
-    if (!NoShowRawInsn)
+    if (ShowRawInsn)
       dumpBytes(makeArrayRef(bytes, 1), outs());
     Value = bytes[0];
     outs() << "\t.byte " << format("%3u", Value) << "\t@ KIND_JUMP_TABLE8\n";
     Size = 1;
     break;
   case MachO::DICE_KIND_JUMP_TABLE16:
-    if (!NoShowRawInsn)
+    if (ShowRawInsn)
       dumpBytes(makeArrayRef(bytes, 2), outs());
     Value = bytes[1] << 8 | bytes[0];
     outs() << "\t.short " << format("%5u", Value & 0xffff)
            << "\t@ KIND_JUMP_TABLE16\n";
     Size = 2;
     break;
   case MachO::DICE_KIND_JUMP_TABLE32:
   case MachO::DICE_KIND_ABS_JUMP_TABLE32:
-    if (!NoShowRawInsn)
+    if (ShowRawInsn)
       dumpBytes(makeArrayRef(bytes, 4), outs());
     Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
     outs() << "\t.long " << Value;
     if (Kind == MachO::DICE_KIND_JUMP_TABLE32)
       outs() << "\t@ KIND_JUMP_TABLE32\n";
     else
       outs() << "\t@ KIND_ABS_JUMP_TABLE32\n";
     Size = 4;
for (const SectionRef &Section : O->sections()) {
         uint32_t section_type = section_flags & MachO::SECTION_TYPE;
 
         StringRef BytesStr =
             unwrapOrError(Section.getContents(), O->getFileName());
         const char *sect = reinterpret_cast<const char *>(BytesStr.data());
         uint32_t sect_size = BytesStr.size();
         uint64_t sect_addr = Section.getAddress();
 
-        if (!NoLeadingHeaders)
+        if (LeadingHeaders)
           outs() << "Contents of (" << SegName << "," << SectName
                  << ") section\n";
 
         if (verbose) {
           if ((section_flags & MachO::S_ATTR_PURE_INSTRUCTIONS) ||
               (section_flags & MachO::S_ATTR_SOME_INSTRUCTIONS)) {
             DisassembleMachO(Filename, O, SegName, SectName);
             continue;
           }
           if (SegName == "__TEXT" && SectName == "__info_plist") {
             outs() << sect;
             continue;
           }
           if (SegName == "__OBJC" && SectName == "__protocol") {
             DumpProtocolSection(O, sect, sect_size, sect_addr);
             continue;
           }
 #ifdef HAVE_LIBXAR
           if (SegName == "__LLVM" && SectName == "__bundle") {
-            DumpBitcodeSection(O, sect, sect_size, verbose, !NoSymbolicOperands,
+            DumpBitcodeSection(O, sect, sect_size, verbose, SymbolicOperands,
                                ArchiveHeaders, "");
             continue;
           }
 #endif // defined(HAVE_LIBXAR)
           switch (section_type) {
           case MachO::S_REGULAR:
             DumpRawSectionContents(O, sect, sect_size, sect_addr);
             break;
           case MachO::S_ZEROFILL:
             outs() << "zerofill section and has no contents in the file\n";
             break;
           case MachO::S_CSTRING_LITERALS:
-            DumpCstringSection(O, sect, sect_size, sect_addr, !NoLeadingAddr);
+            DumpCstringSection(O, sect, sect_size, sect_addr, LeadingAddr);
             break;
           case MachO::S_4BYTE_LITERALS:
-            DumpLiteral4Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
+            DumpLiteral4Section(O, sect, sect_size, sect_addr, LeadingAddr);
             break;
           case MachO::S_8BYTE_LITERALS:
-            DumpLiteral8Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
+            DumpLiteral8Section(O, sect, sect_size, sect_addr, LeadingAddr);
             break;
           case MachO::S_16BYTE_LITERALS:
-            DumpLiteral16Section(O, sect, sect_size, sect_addr, !NoLeadingAddr);
+            DumpLiteral16Section(O, sect, sect_size, sect_addr, LeadingAddr);
             break;
           case MachO::S_LITERAL_POINTERS:
             DumpLiteralPointerSection(O, Section, sect, sect_size, sect_addr,
-                                      !NoLeadingAddr);
+                                      LeadingAddr);
             break;
           case MachO::S_MOD_INIT_FUNC_POINTERS:
           case MachO::S_MOD_TERM_FUNC_POINTERS:
             DumpInitTermPointerSection(O, Section, sect, sect_size, sect_addr,
                                        &AddrMap, verbose);
             break;
           default:
             outs() << "Unknown section type ("
for (const SectionRef &Section : O->sections()) {
     if (SecNameOrErr)
       SectName = *SecNameOrErr;
     else
       consumeError(SecNameOrErr.takeError());
 
     DataRefImpl Ref = Section.getRawDataRefImpl();
     StringRef SegName = O->getSectionFinalSegmentName(Ref);
     if (SegName == "__TEXT" && SectName == "__info_plist") {
-      if (!NoLeadingHeaders)
+      if (LeadingHeaders)
         outs() << "Contents of (" << SegName << "," << SectName << ") section\n";
       StringRef BytesStr =
           unwrapOrError(Section.getContents(), O->getFileName());
       const char *sect = reinterpret_cast<const char *>(BytesStr.data());
       outs() << format("%.*s", BytesStr.size(), sect) << "\n";
       return;
     }
   }
static void ProcessMachO(StringRef Name, MachOObjectFile *MachOOF,
                          StringRef ArchitectureName = StringRef()) {
   // If we are doing some processing here on the Mach-O file print the header
   // info.  And don't print it otherwise like in the case of printing the
   // UniversalHeaders or ArchiveHeaders.
   if (Disassemble || Relocations || PrivateHeaders || ExportsTrie || Rebase ||
       Bind || SymbolTable || LazyBind || WeakBind || IndirectSymbols ||
       DataInCode || FunctionStarts || LinkOptHints || DylibsUsed || DylibId ||
       ObjcMetaData || (!FilterSections.empty())) {
-    if (!NoLeadingHeaders) {
+    if (LeadingHeaders) {
       outs() << Name;
       if (!ArchiveMemberName.empty())
         outs() << '(' << ArchiveMemberName << ')';
       if (!ArchitectureName.empty())
         outs() << " (architecture " << ArchitectureName << ")";
       outs() << ":\n";
     }
   }
for (const SymbolRef &Symbol : MachOOF->symbols()) {
           DisSymNameFound = true;
       }
     }
     if (!DisSymName.empty() && !DisSymNameFound) {
       outs() << "Can't find -dis-symname: " << DisSymName << "\n";
       return;
     }
     // Set up the block of info used by the Symbolizer call backs.
-    SymbolizerInfo.verbose = !NoSymbolicOperands;
+    SymbolizerInfo.verbose = SymbolicOperands;
     SymbolizerInfo.O = MachOOF;
     SymbolizerInfo.S = Sections[SectIdx];
     SymbolizerInfo.AddrMap = &AddrMap;
     SymbolizerInfo.Sections = &Sections;
     // Same for the ThumbSymbolizer
-    ThumbSymbolizerInfo.verbose = !NoSymbolicOperands;
+    ThumbSymbolizerInfo.verbose = SymbolicOperands;
     ThumbSymbolizerInfo.O = MachOOF;
     ThumbSymbolizerInfo.S = Sections[SectIdx];
     ThumbSymbolizerInfo.AddrMap = &AddrMap;
     ThumbSymbolizerInfo.Sections = &Sections;
 
     unsigned int Arch = MachOOF->getArch();
 
     // Skip all symbols if this is a stubs file.
for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
 
         // If this is the first symbol in the section and it was not at the
         // start of the section, see if we are at its Index now and if so print
         // the symbol name.
         if (FirstSymbol && !FirstSymbolAtSectionStart && Index == SymbolStart)
           outs() << SymName << ":\n";
 
         uint64_t PC = SectAddress + Index;
-        if (!NoLeadingAddr) {
+        if (LeadingAddr) {
           if (FullLeadingAddr) {
             if (MachOOF->is64Bit())
               outs() << format("%016" PRIx64, PC);
             else
               outs() << format("%08" PRIx64, PC);
           } else {
             outs() << format("%8" PRIx64 ":", PC);
           }
         }
-        if (!NoShowRawInsn || Arch == Triple::arm)
+        if (ShowRawInsn || Arch == Triple::arm)
           outs() << "\t";
 
         if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, Size))
           continue;
 
         SmallVector<char, 64> AnnotationsBytes;
         raw_svector_ostream Annotations(AnnotationsBytes);
 
         bool gotInst;
         if (UseThumbTarget)
           gotInst = ThumbDisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                                 PC, Annotations);
         else
           gotInst = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), PC,
                                            Annotations);
         if (gotInst) {
-          if (!NoShowRawInsn || Arch == Triple::arm) {
+          if (ShowRawInsn || Arch == Triple::arm) {
             dumpBytes(makeArrayRef(Bytes.data() + Index, Size), outs());
           }
           formatted_raw_ostream FormattedOS(outs());
           StringRef AnnotationsStr = Annotations.str();
           if (UseThumbTarget)
             ThumbIP->printInst(&Inst, PC, AnnotationsStr, *ThumbSTI,
                                FormattedOS);
           else
if (!symbolTableWorked) {
 
         if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, InstSize))
           continue;
 
         SmallVector<char, 64> AnnotationsBytes;
         raw_svector_ostream Annotations(AnnotationsBytes);
         if (DisAsm->getInstruction(Inst, InstSize, Bytes.slice(Index), PC,
                                    Annotations)) {
-          if (!NoLeadingAddr) {
+          if (LeadingAddr) {
             if (FullLeadingAddr) {
               if (MachOOF->is64Bit())
                 outs() << format("%016" PRIx64, PC);
               else
                 outs() << format("%08" PRIx64, PC);
             } else {
               outs() << format("%8" PRIx64 ":", PC);
             }
           }
-          if (!NoShowRawInsn || Arch == Triple::arm) {
+          if (ShowRawInsn || Arch == Triple::arm) {
             outs() << "\t";
             dumpBytes(makeArrayRef(Bytes.data() + Index, InstSize), outs());
           }
           StringRef AnnotationsStr = Annotations.str();
           IP->printInst(&Inst, PC, AnnotationsStr, *STI, outs());
           outs() << "\n";
         } else {
           if (MachOOF->getArchTriple().isX86()) {

llvm/tools/llvm-objdump/llvm-objdump.h

 namespace objdump {
 
 extern bool ArchiveHeaders;
 extern bool Demangle;
 extern bool Disassemble;
 extern bool DisassembleAll;
 extern DIDumpType DwarfDumpType;
 extern std::vector<std::string> FilterSections;
+extern bool LeadingAddr;
 extern std::vector<std::string> MAttrs;
 extern std::string MCPU;
-extern bool NoShowRawInsn;
-extern bool NoLeadingAddr;
 extern std::string Prefix;
 extern uint32_t PrefixStrip;
 extern bool PrintImmHex;
 extern bool PrivateHeaders;
 extern bool Relocations;
 extern bool SectionHeaders;
 extern bool SectionContents;
+extern bool ShowRawInsn;
 extern bool SymbolDescription;
 extern bool SymbolTable;
 extern std::string TripleName;
 extern bool UnwindInfo;
 
 extern StringSet<> FoundSectionSet;
 
 typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;

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

 static bool FaultMapSection;
 static bool FileHeaders;
 bool objdump::SectionContents;
 static std::vector<std::string> InputFilenames;
 static bool PrintLines;
 static bool MachOOpt;
 std::string objdump::MCPU;
 std::vector<std::string> objdump::MAttrs;
-bool objdump::NoShowRawInsn;
-bool objdump::NoLeadingAddr;
+bool objdump::ShowRawInsn;
+bool objdump::LeadingAddr;
 static bool RawClangAST;
 bool objdump::Relocations;
 bool objdump::PrintImmHex;
 bool objdump::PrivateHeaders;
 std::vector<std::string> objdump::FilterSections;
 bool objdump::SectionHeaders;
 static bool ShowLMA;
 static bool PrintSource;
static bool getHidden(RelocationRef RelRef) {
   return false;
 }
 
 namespace {
 
 /// Get the column at which we want to start printing the instruction
 /// disassembly, taking into account anything which appears to the left of it.
 unsigned getInstStartColumn(const MCSubtargetInfo &STI) {
-  return NoShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24;
+  return !ShowRawInsn ? 16 : STI.getTargetTriple().isX86() ? 40 : 24;
 }
 
 /// Stores a single expression representing the location of a source-level
 /// variable, along with the PC range for which that expression is valid.
 struct LiveVariable {
   DWARFLocationExpression LocExpr;
   const char *VarName;
   DWARFUnit *Unit;
printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
             StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
             StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
             LiveVariablePrinter &LVP) {
     if (SP && (PrintSource || PrintLines))
       SP->printSourceLine(OS, Address, ObjectFilename, LVP);
     LVP.printBetweenInsts(OS, false);
 
     size_t Start = OS.tell();
-    if (!NoLeadingAddr)
+    if (LeadingAddr)
       OS << format("%8" PRIx64 ":", Address.Address);
-    if (!NoShowRawInsn) {
+    if (ShowRawInsn) {
       OS << ' ';
       dumpBytes(Bytes, OS);
     }
 
     // The output of printInst starts with a tab. Print some spaces so that
     // the tab has 1 column and advances to the target tab stop.
     unsigned TabStop = getInstStartColumn(STI);
     unsigned Column = OS.tell() - Start;

 PrettyPrinter PrettyPrinterInst;
 
 class HexagonPrettyPrinter : public PrettyPrinter {
 public:
   void printLead(ArrayRef<uint8_t> Bytes, uint64_t Address,
                  formatted_raw_ostream &OS) {
     uint32_t opcode =
       (Bytes[3] << 24) | (Bytes[2] << 16) | (Bytes[1] << 8) | Bytes[0];
-    if (!NoLeadingAddr)
+    if (LeadingAddr)
       OS << format("%8" PRIx64 ":", Address);
-    if (!NoShowRawInsn) {
+    if (ShowRawInsn) {
       OS << "\t";
       dumpBytes(Bytes.slice(0, 4), OS);
       OS << format("\t%08" PRIx32, opcode);
     }
   }
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
                  object::SectionedAddress Address, formatted_raw_ostream &OS,
                  StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,

 public:
   void printInst(MCInstPrinter &IP, const MCInst *MI, ArrayRef<uint8_t> Bytes,
                  object::SectionedAddress Address, formatted_raw_ostream &OS,
                  StringRef Annot, MCSubtargetInfo const &STI, SourcePrinter *SP,
                  StringRef ObjectFilename, std::vector<RelocationRef> *Rels,
                  LiveVariablePrinter &LVP) override {
     if (SP && (PrintSource || PrintLines))
       SP->printSourceLine(OS, Address, ObjectFilename, LVP);
-    if (!NoLeadingAddr)
+    if (LeadingAddr)
       OS << format("%8" PRId64 ":", Address.Address / 8);
-    if (!NoShowRawInsn) {
+    if (ShowRawInsn) {
       OS << "\t";
       dumpBytes(Bytes, OS);
     }
     if (MI)
       IP.printInst(MI, Address.Address, "", STI, OS);
     else
       OS << "\t<unknown>";
   }
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
         PrintedSection = true;
         outs() << "\nDisassembly of section ";
         if (!SegmentName.empty())
           outs() << SegmentName << ",";
         outs() << SectionName << ":\n";
       }
 
       outs() << '\n';
-      if (!NoLeadingAddr)
+      if (LeadingAddr)
         outs() << format(Is64Bits ? "%016" PRIx64 " " : "%08" PRIx64 " ",
                          SectionAddr + Start + VMAAdjustment);
       if (Obj->isXCOFF() && SymbolDescription) {
         outs() << getXCOFFSymbolDescription(Symbols[SI], SymbolName) << ":\n";
       } else
         outs() << '<' << SymbolName << ">:\n";
 
       // Don't print raw contents of a virtual section. A virtual section
static void parseOtoolOptions(const llvm::opt::InputArgList &InputArgs) {
   LinkOptHints = InputArgs.hasArg(OTOOL_C);
   if (InputArgs.hasArg(OTOOL_d))
     FilterSections.push_back("__DATA,__data");
   DylibId = InputArgs.hasArg(OTOOL_D);
   UniversalHeaders = InputArgs.hasArg(OTOOL_f);
   DataInCode = InputArgs.hasArg(OTOOL_G);
   FirstPrivateHeader = InputArgs.hasArg(OTOOL_h);
   IndirectSymbols = InputArgs.hasArg(OTOOL_I);
-  NoShowRawInsn = !InputArgs.hasArg(OTOOL_j);
+  ShowRawInsn = InputArgs.hasArg(OTOOL_j);
   PrivateHeaders = InputArgs.hasArg(OTOOL_l);
   DylibsUsed = InputArgs.hasArg(OTOOL_L);
   MCPU = InputArgs.getLastArgValue(OTOOL_mcpu_EQ).str();
   ObjcMetaData = InputArgs.hasArg(OTOOL_o);
   DisSymName = InputArgs.getLastArgValue(OTOOL_p).str();
   InfoPlist = InputArgs.hasArg(OTOOL_P);
   Relocations = InputArgs.hasArg(OTOOL_r);
   if (const Arg *A = InputArgs.getLastArg(OTOOL_s)) {
     auto Filter = (A->getValue(0) + StringRef(",") + A->getValue(1)).str();
     FilterSections.push_back(Filter);
   }
   if (InputArgs.hasArg(OTOOL_t))
     FilterSections.push_back("__TEXT,__text");
-  Verbose = (InputArgs.hasArg(OTOOL_v) || InputArgs.hasArg(OTOOL_V) ||
-             InputArgs.hasArg(OTOOL_o));
-  NoSymbolicOperands = !InputArgs.hasArg(OTOOL_V);
+  Verbose = InputArgs.hasArg(OTOOL_v) || InputArgs.hasArg(OTOOL_V) ||
+            InputArgs.hasArg(OTOOL_o);
+  SymbolicOperands = InputArgs.hasArg(OTOOL_V);
   if (InputArgs.hasArg(OTOOL_x))
     FilterSections.push_back(",__text");
-  NoLeadingAddr = NoLeadingHeaders = InputArgs.hasArg(OTOOL_X);
+  LeadingAddr = LeadingHeaders = !InputArgs.hasArg(OTOOL_X);
 
   InputFilenames = InputArgs.getAllArgValues(OTOOL_INPUT);
   if (InputFilenames.empty())
     reportCmdLineError("no input file");
 
   for (const Arg *A : InputArgs) {
     const Option &O = A->getOption();
     if (O.getGroup().isValid() && O.getGroup().getID() == OTOOL_grp_obsolete) {
static void parseObjdumpOptions(const llvm::opt::InputArgList &InputArgs) {
   FaultMapSection = InputArgs.hasArg(OBJDUMP_fault_map_section);
   FileHeaders = InputArgs.hasArg(OBJDUMP_file_headers);
   SectionContents = InputArgs.hasArg(OBJDUMP_full_contents);
   PrintLines = InputArgs.hasArg(OBJDUMP_line_numbers);
   InputFilenames = InputArgs.getAllArgValues(OBJDUMP_INPUT);
   MachOOpt = InputArgs.hasArg(OBJDUMP_macho);
   MCPU = InputArgs.getLastArgValue(OBJDUMP_mcpu_EQ).str();
   MAttrs = commaSeparatedValues(InputArgs, OBJDUMP_mattr_EQ);
-  NoShowRawInsn = InputArgs.hasArg(OBJDUMP_no_show_raw_insn);
-  NoLeadingAddr = InputArgs.hasArg(OBJDUMP_no_leading_addr);
+  ShowRawInsn = !InputArgs.hasArg(OBJDUMP_no_show_raw_insn);
+  LeadingAddr = !InputArgs.hasArg(OBJDUMP_no_leading_addr);
   RawClangAST = InputArgs.hasArg(OBJDUMP_raw_clang_ast);
   Relocations = InputArgs.hasArg(OBJDUMP_reloc);
   PrintImmHex =
       InputArgs.hasFlag(OBJDUMP_print_imm_hex, OBJDUMP_no_print_imm_hex, false);
   PrivateHeaders = InputArgs.hasArg(OBJDUMP_private_headers);
   FilterSections = InputArgs.getAllArgValues(OBJDUMP_section_EQ);
   SectionHeaders = InputArgs.hasArg(OBJDUMP_section_headers);
   ShowLMA = InputArgs.hasArg(OBJDUMP_show_lma);