Refactor: Simplify boolean conditional return statements in llvm/lib/MC

[LegalizeAdulthood]

Summary

Use clang-tidy to simplify boolean conditional return statements

[craig.topper]

lib/MC/WinCOFFObjectWriter.cpp

232

Push negate through

[LegalizeAdulthood]

lib/MC/WinCOFFObjectWriter.cpp

232

Is !MC || !MC->isTemporary() really more readable?

[abdulras]

lib/MC/MCSymbol.cpp

20

Push the negate through?

lib/MC/MachObjectWriter.cpp

49

I think that the comment should be retained and merged here.

695

Push the negate through?

lib/MC/ELFObjectWriter.cpp

bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
 
   // If the symbol is a thumb function the final relocation must set the lowest
   // bit. With a symbol that is done by just having the symbol have that bit
   // set, so we would lose the bit if we relocated with the section.
   // FIXME: We could use the section but add the bit to the relocation value.
   if (Asm.isThumbFunc(Sym))
     return true;
 
-  if (TargetObjectWriter->needsRelocateWithSymbol(*SD, Type))
-    return true;
-  return false;
+  return TargetObjectWriter->needsRelocateWithSymbol(*SD, Type);
 }
 
 static const MCSymbol *getWeakRef(const MCSymbolRefExpr &Ref) {
   const MCSymbol &Sym = Ref.getSymbol();
 
   if (Ref.getKind() == MCSymbolRefExpr::VK_WEAKREF)
     return &Sym;
 
if (Symbol.isVariable()) {
     if (Base && Base->isUndefined())
       return false;
   }
 
   bool IsGlobal = MCELF::GetBinding(Data) == ELF::STB_GLOBAL;
   if (!Symbol.isVariable() && Symbol.isUndefined() && !IsGlobal)
     return false;
 
-  if (Symbol.isTemporary())
-    return false;
-
-  return true;
+  return !Symbol.isTemporary();
 }
 
 bool ELFObjectWriter::isLocal(const MCSymbol &Symbol, bool isUsedInReloc) {
   const MCSymbolData &Data = Symbol.getData();
   if (Data.isExternal())
     return false;
 
   if (Symbol.isDefined())
     return true;
 
-  if (isUsedInReloc)
-    return false;
-
-  return true;
+  return !isUsedInReloc;
 }
 
 void ELFObjectWriter::computeSymbolTable(
     MCAssembler &Asm, const MCAsmLayout &Layout,
     const SectionIndexMapTy &SectionIndexMap,
     const RevGroupMapTy &RevGroupMap) {
   MCContext &Ctx = Asm.getContext();
   // Symbol table

lib/MC/MCAssembler.cpp

bool MCAssembler::isSymbolLinkerVisible(const MCSymbol &Symbol) const {
   // Non-temporary labels should always be visible to the linker.
   if (!Symbol.isTemporary())
     return true;
 
   // Absolute temporary labels are never visible.
   if (!Symbol.isInSection())
     return false;
 
-  if (isLocalUsedInReloc(Symbol))
-    return true;
-
-  return false;
+  return isLocalUsedInReloc(Symbol);
 }
 
 const MCSymbol *MCAssembler::getAtom(const MCSymbol &S) const {
   // Linker visible symbols define atoms.
   if (isSymbolLinkerVisible(S))
     return &S;
 
   // Absolute and undefined symbols have no defining atom.

lib/MC/MCMachOStreamer.cpp

if (SegName == "__IMPORT") {
 
     if (SecName == "__pointers")
       return true;
   }
 
   if (SegName == "__TEXT" && SecName == "__eh_frame")
     return true;
 
-  if (SegName == "__DATA" && SecName == "__nl_symbol_ptr")
-    return true;
-
-  return false;
+  return SegName == "__DATA" && SecName == "__nl_symbol_ptr";
 }
 
 void MCMachOStreamer::ChangeSection(MCSection *Section,
                                     const MCExpr *Subsection) {
   // Change the section normally.
   bool Created = MCObjectStreamer::changeSectionImpl(Section, Subsection);
   const MCSectionMachO &MSec = *cast<MCSectionMachO>(Section);
   StringRef SegName = MSec.getSegmentName();

lib/MC/MCObjectFileInfo.cpp

static bool useCompactUnwind(const Triple &T) {
   if (T.getArch() == Triple::aarch64)
     return true;
 
   // Use it on newer version of OS X.
   if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6))
     return true;
 
   // And the iOS simulator.
-  if (T.isiOS() &&
-      (T.getArch() == Triple::x86_64 || T.getArch() == Triple::x86))
-    return true;
-
-  return false;
+  return T.isiOS() &&
+      (T.getArch() == Triple::x86_64 || T.getArch() == Triple::x86);
 }
 
 void MCObjectFileInfo::InitMachOMCObjectFileInfo(Triple T) {
   // MachO
   SupportsWeakOmittedEHFrame = false;
 
   if (T.isOSDarwin() && T.getArch() == Triple::aarch64)
     SupportsCompactUnwindWithoutEHFrame = true;

lib/MC/MCSectionCOFF.cpp

 // ShouldOmitSectionDirective - Decides whether a '.section' directive
 // should be printed before the section name
 bool MCSectionCOFF::ShouldOmitSectionDirective(StringRef Name,
                                                const MCAsmInfo &MAI) const {
   if (COMDATSymbol)
     return false;
 
   // FIXME: Does .section .bss/.data/.text work everywhere??
-  if (Name == ".text" || Name == ".data" || Name == ".bss")
-    return true;
-
-  return false;
+  return Name == ".text" || Name == ".data" || Name == ".bss";
 }
 
 void MCSectionCOFF::setSelection(int Selection) const {
   assert(Selection != 0 && "invalid COMDAT selection type");
   this->Selection = Selection;
   Characteristics |= COFF::IMAGE_SCN_LNK_COMDAT;
 }
 

lib/MC/MCSectionELF.cpp

 // should be printed before the section name.
 bool MCSectionELF::ShouldOmitSectionDirective(StringRef Name,
                                               const MCAsmInfo &MAI) const {
 
   if (isUnique())
     return false;
 
   // FIXME: Does .section .bss/.data/.text work everywhere??
-  if (Name == ".text" || Name == ".data" ||
-      (Name == ".bss" && !MAI.usesELFSectionDirectiveForBSS()))
-    return true;
-
-  return false;
+  return Name == ".text" || Name == ".data" ||
+      (Name == ".bss" && !MAI.usesELFSectionDirectiveForBSS());
 }
 
 static void printName(raw_ostream &OS, StringRef Name) {
   if (Name.find_first_not_of("0123456789_."
                              "abcdefghijklmnopqrstuvwxyz"
                              "ABCDEFGHIJKLMNOPQRSTUVWXYZ") == Name.npos) {
     OS << Name;
     return;

lib/MC/MCSymbol.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 // Sentinel value for the absolute pseudo section.
 MCSection *MCSymbol::AbsolutePseudoSection = reinterpret_cast<MCSection *>(1);
 
 static bool isAcceptableChar(char C) {
-  if ((C < 'a' || C > 'z') &&
+  return !((C < 'a' || C > 'z') &&
       (C < 'A' || C > 'Z') &&
       (C < '0' || C > '9') &&
-      C != '_' && C != '$' && C != '.' && C != '@')
-    return false;
-  return true;
+      C != '_' && C != '$' && C != '.' && C != '@');
 }
 
 /// NameNeedsQuoting - Return true if the identifier \p Str needs quotes to be
 /// syntactically correct.
 static bool NameNeedsQuoting(StringRef Str) {
   assert(!Str.empty() && "Cannot create an empty MCSymbol");
 
   // If any of the characters in the string is an unacceptable character, force

lib/MC/MachObjectWriter.cpp

 
 bool MachObjectWriter::doesSymbolRequireExternRelocation(const MCSymbol &S) {
   // Undefined symbols are always extern.
   if (S.isUndefined())
     return true;
 
   // References to weak definitions require external relocation entries; the
   // definition may not always be the one in the same object file.
-  if (S.getData().getFlags() & SF_WeakDefinition)
-    return true;
-
-  // Otherwise, we can use an internal relocation.
-  return false;
+  return S.getData().getFlags() & SF_WeakDefinition;
 }
 
 bool MachObjectWriter::
 MachSymbolData::operator<(const MachSymbolData &RHS) const {
   return Symbol->getName() < RHS.Symbol->getName();
 }
 
 bool MachObjectWriter::isFixupKindPCRel(const MCAssembler &Asm, unsigned Kind) {
if (IsPCRel) {
     // don't need to worry about considering symbol differences fully resolved.
     //
     // If the file isn't using sub-sections-via-symbols, we can make the
     // same assumptions about any symbol that we normally make about
     // assembler locals.
 
     bool hasReliableSymbolDifference = isX86_64();
     if (!hasReliableSymbolDifference) {
-      if (!SA.isInSection() || &SecA != &SecB ||
+      return !(!SA.isInSection() || &SecA != &SecB ||
           (!SA.isTemporary() &&
            FB.getAtom() != Asm.getSymbolData(SA).getFragment()->getAtom() &&
-           Asm.getSubsectionsViaSymbols()))
-        return false;
-      return true;
+           Asm.getSubsectionsViaSymbols()));
     }
     // For Darwin x86_64, there is one special case when the reference IsPCRel.
     // If the fragment with the reference does not have a base symbol but meets
     // the simple way of dealing with this, in that it is a temporary symbol in
     // the same atom then it is assumed to be fully resolved.  This is needed so
     // a relocation entry is not created and so the static linker does not
     // mess up the reference later.
     else if(!FB.getAtom() &&
bool MachObjectWriter::IsSymbolRefDifferenceFullyResolvedImpl(
 
   const MCFragment *FA = Asm.getSymbolData(SA).getFragment();
 
   // Bail if the symbol has no fragment.
   if (!FA)
     return false;
 
   // If the atoms are the same, they are guaranteed to have the same address.
-  if (FA->getAtom() == FB.getAtom())
-    return true;
-
-  // Otherwise, we can't prove this is fully resolved.
-  return false;
+  return FA->getAtom() == FB.getAtom();
 }
 
 void MachObjectWriter::WriteObject(MCAssembler &Asm,
                                    const MCAsmLayout &Layout) {
   // Compute symbol table information and bind symbol indices.
   ComputeSymbolTable(Asm, LocalSymbolData, ExternalSymbolData,
                      UndefinedSymbolData);
 

lib/MC/WinCOFFObjectWriter.cpp

bool COFFSymbol::should_keep() const {
   if (Section->Number == -1)
       return false;
 
   // if it is the section symbol, keep it
   if (Section->Symbol == this)
     return true;
 
   // if its temporary, drop it
-  if (MC && MC->isTemporary())
-    return false;
-
-  // otherwise, keep it
-  return true;
+  return !(MC && MC->isTemporary());
 }
 
 //------------------------------------------------------------------------------
 // Section class implementation
 
 COFFSection::COFFSection(StringRef name)
   : Name(name)
   , MCData(nullptr)