Changes in clang after running http://reviews.llvm.org/D18821

[Prazek]

Summary

I am not done with analysis, and I don't want to push it to repo as it is, because in many cases when programmer wrote true/false he wanted to have bool instead of int.

Some nice example:
unsigned IsFilled : 1;

/// Simplified kind of \c CommentDecl, see \c DeclKind enum.
unsigned Kind : 3;

/// Is \c CommentDecl a template declaration.
unsigned TemplateKind : 2;

/// Is \c CommentDecl an ObjCMethodDecl.
unsigned IsObjCMethod : 1;

/// Is \c CommentDecl a non-static member function of C++ class or
/// instance method of ObjC class.
/// Can be true only if \c IsFunctionDecl is true.
unsigned IsInstanceMethod : 1;

/// Is \c CommentDecl a static member function of C++ class or
/// class method of ObjC class.
/// Can be true only if \c IsFunctionDecl is true.
unsigned IsClassMethod : 1;

I want to replace all unsigned that are 1 bits with bool.

[thakis]

I want to replace all unsigned that are 1 bits with bool.

MSVC only packs bitfields of the same type together, so doing that change would make clang use much more memory on Windows.

[Prazek]

In D19105#400966, @thakis wrote:

I want to replace all unsigned that are 1 bits with bool.

MSVC only packs bitfields of the same type together, so doing that change would make clang use much more memory on Windows.

Seriously MSVC? Seriously?
I guess I will have add something to my check to ignore bitfields of 1.

[alexfh]

Ignoring 1-bit wide bitfields seems like a reasonable thing to do for the check. Most of the changes I see here are making the code less idiomatic, I'd say.

[Prazek]

It seems that is doing it's work right now.

I will have to change some places to post it to llvm like:

• changing functions return type to bool
• removng comparasion with bool for bools

[• Quuxplusone]

It seems like this proposed diagnostic and fixit, statistically speaking, is *never* correct.
In the cases where there is a code issue to be corrected, the diagnosable issue really seems to involve dataflow analysis:

"Here is a variable of integral type (not bool), which over its lifetime assumes only the values 0 and 1. This variable should be declared as type bool."
"Here is a function returning integral type (not bool), which returns only the values 0 and 1. This function should be declared as returning type bool."
"Here is a parameter of integral type (not bool), which (via whole-program analysis) assumes only the values 0 and 1. This parameter should be declared as type bool."

lib/AST/DeclPrinter.cpp

1016

This is clearly the wrong correction, don't you think? Should be s/unsigned/bool/, not s/true/1/.

lib/AST/DeclarationName.cpp

104

This seems like it might be a real bug: somebody in the past cut-and-pasting the implementation of operator<() into this compare() function. I suspect (but please don't trust me) that the proper fix is s/true/-1/ s/false/1/.

lib/Bitcode/Writer/BitWriter.cpp

40

This also seems like the wrong correction.

lib/Bitcode/Writer/BitcodeWriter.cpp

1332

This seems like a "correct" but unwanted adjustment. *Maybe* there's a case for static_cast<uint64_t>(true)... but personally I'd leave the true alone.

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

594

Here is the first clearly beneficial correction I've noticed.

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

1562

If I understand correctly, the idiomatic C++11 way to write this code would be

static constexpr bool IsBottomUp = true;
static constexpr bool HasReadyFilter = false;

I think the proposed correction is worse than the original, because it makes this look like an integer enumeration.

lib/Driver/Tools.cpp

2022 ↗

(On Diff #56250)

Shouldn't the original code already have triggered some warning about explicit comparison with a boolean value?

if (OptionIter->second) {

doesn't have literally the same semantics, but it's clearly IMHO what was intended.
Also, if decltype(llvm::StringMap<bool>::iterator{}->second) is not bool, something weird is going on.

lib/IR/Core.cpp

222

This correction is wrong; either true should be accepted as a valid value for LLVMBool, or LLVMBool should be replaced with bool.

[jfb]

lib/Transforms/IPO/MergeFunctions.cpp

147

This change should go to ValueMap, I think it should be moved to an enum class, and all uses of ValueMap should be changed accordingly. This is meant to act as a bool IMO, it's odd to make it otherwise.

[Prazek]

In D19105#422702, @Quuxplusone wrote:

It seems like this proposed diagnostic and fixit, statistically speaking, is *never* correct.
In the cases where there is a code issue to be corrected, the diagnosable issue really seems to involve dataflow analysis:

"Here is a variable of integral type (not bool), which over its lifetime assumes only the values 0 and 1. This variable should be declared as type bool."
"Here is a function returning integral type (not bool), which returns only the values 0 and 1. This function should be declared as returning type bool."
"Here is a parameter of integral type (not bool), which (via whole-program analysis) assumes only the values 0 and 1. This parameter should be declared as type bool."

You are right, if someone is using true/false, then he probably mean it, and he is just assigning it to wrong type. But I don't see a point spending too much time to write something that would be smart enough to fix most of the issues as we would like. I think having this fixit is good for now and I would leave it like this.
From my usage, I like when clang-tidy touch some files and changes it somewhow, so it is much simpler to check it in git than to look at the warnings.

lib/Driver/Tools.cpp

2022 ↗

(On Diff #56250)

te misc-simplify-boolean-expression is to solve this problem. I will check if this code make sense.

[alexfh]

Too much noise here as well. Particularly, someBool == true should not be changed to someBool == 1. Please fix the check and update the results.

clang-tidy/readability/ImplicitBoolCastCheck.cpp

253 ↗

(On Diff #56250)

Seems like a bug. CXXBoolLiteralExpr::getValue() returns bool.

lib/AsmParser/LLParser.cpp

4868

Looks like this should return InstResult and the return values should be replaced by proper enumerators.

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

1562

I agree that changing this to integers is a regression. However, we can't yet use constexpr, since VS2013 doesn't support it. Looks like this file just needs to be reverted.

lib/IR/Core.cpp

222

This function is a part of C API, so we can't use bool here, and LLVMBool is the right choice. However, it might make sense to add LLVM_TRUE and LLVM_FALSE constants/macros to include/llvm-c/Types.h to more clearly specify possible values for the LLVMBool type.

lib/Lex/PPMacroExpansion.cpp

1689

This actually seems like a useful replacement ;)

lib/MC/MCContext.cpp

314

That one is interesting: passing true (or 1) to unsigned UniqueID seems like a very weird thing to do. Please at least add a /*UniqueID=*/ comment before the argument to make this weirdness more explicit.

lib/Sema/SemaOpenMP.cpp

4487

Instead, the parameter type should be changed to bool.

lib/Serialization/ASTReader.cpp

5453

That's wrong. Instead, Record[Idx++] should be changed to Record[Idx++] != 0.

lib/Target/Hexagon/MCTargetDesc/HexagonMCShuffler.cpp

194 ↗

(On Diff #56250)

This is wrong.

[alexfh]

The bottom line is that the fixit in its current form is not particularly useful in most cases. We should try to detect some cases where the replacement is unlikely to be useful, e.g. the enum { FollowRAUW = false }; pattern, returning a bool from a function that is declared to return a typedef to an integral type that contains bool in its name (e.g. LLVMBool), and maybe some other cases.

[Prazek]

In D19105#426903, @alexfh wrote:

returning a bool from a function that is declared to return a typedef to an integral type that contains bool in its name (e.g. LLVMBool), and maybe some other cases.

Isn't it LLVMBool issue?

I won't have enough time to fix it, so I would prefer to comment fixit and only push warnings.

[Prazek]

lib/Target/Hexagon/MCTargetDesc/HexagonMCShuffler.cpp

194 ↗

(On Diff #56250)

Of course it is, but the prevoius code was also creepy :P

[alexfh]

In D19105#427046, @Prazek wrote:

In D19105#426903, @alexfh wrote:

returning a bool from a function that is declared to return a typedef to an integral type that contains bool in its name (e.g. LLVMBool), and maybe some other cases.

Isn't it LLVMBool issue?

I won't have enough time to fix it, so I would prefer to comment fixit and only push warnings.

Whether we disable fixits or not, there seem to be too many false positives for the check to be useful. We should fix at least cases like bool b; ... if (b == true) ... and bool b; ... b ^= true;.

[Prazek]

Fixed many stuff.

Note that I won't push this patch mainly because of LLVMBool stuff and some other small issues. I don't think there can be done anything more for this check.

[deadalnix]

include/llvm-c/Core.h

604

Please keep LLVMBool in the C API. ABI change are a NO NO.

[Prazek]

include/llvm-c/Core.h

604

As I said in my comment, I won't commit most of the changes. This review is only to show what check has found.

[alexfh]

Most of the fixits are still useless, but I didn't notice any false positives (i.e. all warnings would be useful to some degree). So I suggest disabling the fixes completely at least for now.

include/llvm-c/Core.h

604

From what I see in this patch, changing the function type to bool not a useful fix, and certainly a dangerous one, since 1. ABI changes, 2. The check can't see all the users of the function.

lib/AST/Decl.cpp

173

Apparently, the check should filter out template instantiations.

lib/CodeGen/CGOpenMPRuntime.cpp

1934

Looks like the parameter type should be changed to bool instead.

lib/CodeGen/SplitKit.h

298

Is it an automated fix?

lib/Target/ARM/ARMConstantIslandPass.cpp

1643

In this case, changing the type would be better.

utils/TableGen/CTagsEmitter.cpp

36

One of the few cases where changing the function return type makes sense.

[Prazek]

lib/CodeGen/SplitKit.h

298

No, this is the only one that I'have made by hand, so it won't change some calls on this type

include/clang-c/Documentation.h

  * \brief A \c CXComment_Paragraph node is considered whitespace if it contains
  * only \c CXComment_Text nodes that are empty or whitespace.
  *
  * Other AST nodes (except \c CXComment_Paragraph and \c CXComment_Text) are
  * never considered whitespace.
  *
  * \returns non-zero if \c Comment is whitespace.
  */
-CINDEX_LINKAGE unsigned clang_Comment_isWhitespace(CXComment Comment);
+CINDEX_LINKAGE bool clang_Comment_isWhitespace(CXComment Comment);
 
 /**
  * \returns non-zero if \c Comment is inline content and has a newline
  * immediately following it in the comment text.  Newlines between paragraphs
  * do not count.
  */
 CINDEX_LINKAGE
-unsigned clang_InlineContentComment_hasTrailingNewline(CXComment Comment);
+bool clang_InlineContentComment_hasTrailingNewline(CXComment Comment);
 
 /**
  * \param Comment a \c CXComment_Text AST node.
  *
  * \returns text contained in the AST node.
  */
 CINDEX_LINKAGE CXString clang_TextComment_getText(CXComment Comment);
 

 CINDEX_LINKAGE CXString clang_HTMLTagComment_getTagName(CXComment Comment);
 
 /**
  * \param Comment a \c CXComment_HTMLStartTag AST node.
  *
  * \returns non-zero if tag is self-closing (for example, <br />).
  */
 CINDEX_LINKAGE
-unsigned clang_HTMLStartTagComment_isSelfClosing(CXComment Comment);
+bool clang_HTMLStartTagComment_isSelfClosing(CXComment Comment);
 
 /**
  * \param Comment a \c CXComment_HTMLStartTag AST node.
  *
  * \returns number of attributes (name-value pairs) attached to the start tag.
  */
 CINDEX_LINKAGE unsigned clang_HTMLStartTag_getNumAttrs(CXComment Comment);
 

 /**
  * \param Comment a \c CXComment_ParamCommand AST node.
  *
  * \returns non-zero if the parameter that this AST node represents was found
  * in the function prototype and \c clang_ParamCommandComment_getParamIndex
  * function will return a meaningful value.
  */
 CINDEX_LINKAGE
-unsigned clang_ParamCommandComment_isParamIndexValid(CXComment Comment);
+bool clang_ParamCommandComment_isParamIndexValid(CXComment Comment);
 
 /**
  * \param Comment a \c CXComment_ParamCommand AST node.
  *
  * \returns zero-based parameter index in function prototype.
  */
 CINDEX_LINKAGE
 unsigned clang_ParamCommandComment_getParamIndex(CXComment Comment);
 
 /**
  * \param Comment a \c CXComment_ParamCommand AST node.
  *
  * \returns non-zero if parameter passing direction was specified explicitly in
  * the comment.
  */
 CINDEX_LINKAGE
-unsigned clang_ParamCommandComment_isDirectionExplicit(CXComment Comment);
+bool clang_ParamCommandComment_isDirectionExplicit(CXComment Comment);
 
 /**
  * \param Comment a \c CXComment_ParamCommand AST node.
  *
  * \returns parameter passing direction.
  */
 CINDEX_LINKAGE
 enum CXCommentParamPassDirection clang_ParamCommandComment_getDirection(

  *
  * \returns non-zero if the parameter that this AST node represents was found
  * in the template parameter list and
  * \c clang_TParamCommandComment_getDepth and
  * \c clang_TParamCommandComment_getIndex functions will return a meaningful
  * value.
  */
 CINDEX_LINKAGE
-unsigned clang_TParamCommandComment_isParamPositionValid(CXComment Comment);
+bool clang_TParamCommandComment_isParamPositionValid(CXComment Comment);
 
 /**
  * \param Comment a \c CXComment_TParamCommand AST node.
  *
  * \returns zero-based nesting depth of this parameter in the template parameter list.
  *
  * For example,
  * \verbatim

include/clang-c/Index.h

  */
 CINDEX_LINKAGE CXFile clang_getFile(CXTranslationUnit tu,
                                     const char *file_name);
 
 /**
  * \brief Returns non-zero if the \c file1 and \c file2 point to the same file,
  * or they are both NULL.
  */
-CINDEX_LINKAGE int clang_File_isEqual(CXFile file1, CXFile file2);
+CINDEX_LINKAGE bool clang_File_isEqual(CXFile file1, CXFile file2);
 
 /**
  * @}
  */
 
 /**
  * \defgroup CINDEX_LOCATIONS Physical source locations
  *

 /**
  * \brief Determine whether two source locations, which must refer into
  * the same translation unit, refer to exactly the same point in the source
  * code.
  *
  * \returns non-zero if the source locations refer to the same location, zero
  * if they refer to different locations.
  */
-CINDEX_LINKAGE unsigned clang_equalLocations(CXSourceLocation loc1,
+CINDEX_LINKAGE bool clang_equalLocations(CXSourceLocation loc1,
                                              CXSourceLocation loc2);
 
 /**
  * \brief Retrieves the source location associated with a given file/line/column
  * in a particular translation unit.
  */
 CINDEX_LINKAGE CXSourceLocation clang_getLocation(CXTranslationUnit tu,
                                                   CXFile file,

 CINDEX_LINKAGE CXSourceRange clang_getRange(CXSourceLocation begin,
                                             CXSourceLocation end);
 
 /**
  * \brief Determine whether two ranges are equivalent.
  *
  * \returns non-zero if the ranges are the same, zero if they differ.
  */
-CINDEX_LINKAGE unsigned clang_equalRanges(CXSourceRange range1,
+CINDEX_LINKAGE bool clang_equalRanges(CXSourceRange range1,
                                           CXSourceRange range2);
 
 /**
  * \brief Returns non-zero if \p range is null.
  */
 CINDEX_LINKAGE int clang_Range_isNull(CXSourceRange range);
 
 /**

  * The translation unit cursor can be used to start traversing the
  * various declarations within the given translation unit.
  */
 CINDEX_LINKAGE CXCursor clang_getTranslationUnitCursor(CXTranslationUnit);
 
 /**
  * \brief Determine whether two cursors are equivalent.
  */
-CINDEX_LINKAGE unsigned clang_equalCursors(CXCursor, CXCursor);
+CINDEX_LINKAGE bool clang_equalCursors(CXCursor, CXCursor);
 
 /**
  * \brief Returns non-zero if \p cursor is null.
  */
 CINDEX_LINKAGE int clang_Cursor_isNull(CXCursor cursor);
 
 /**
  * \brief Compute a hash value for the given cursor.
  */
 CINDEX_LINKAGE unsigned clang_hashCursor(CXCursor);
   
 /**
  * \brief Retrieve the kind of the given cursor.
  */
 CINDEX_LINKAGE enum CXCursorKind clang_getCursorKind(CXCursor);
 
 /**
  * \brief Determine whether the given cursor kind represents a declaration.
  */
-CINDEX_LINKAGE unsigned clang_isDeclaration(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isDeclaration(enum CXCursorKind);
 
 /**
  * \brief Determine whether the given cursor kind represents a simple
  * reference.
  *
  * Note that other kinds of cursors (such as expressions) can also refer to
  * other cursors. Use clang_getCursorReferenced() to determine whether a
  * particular cursor refers to another entity.
  */
-CINDEX_LINKAGE unsigned clang_isReference(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isReference(enum CXCursorKind);
 
 /**
  * \brief Determine whether the given cursor kind represents an expression.
  */
-CINDEX_LINKAGE unsigned clang_isExpression(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isExpression(enum CXCursorKind);
 
 /**
  * \brief Determine whether the given cursor kind represents a statement.
  */
-CINDEX_LINKAGE unsigned clang_isStatement(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isStatement(enum CXCursorKind);
 
 /**
  * \brief Determine whether the given cursor kind represents an attribute.
  */
-CINDEX_LINKAGE unsigned clang_isAttribute(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isAttribute(enum CXCursorKind);
 
 /**
  * \brief Determine whether the given cursor has any attributes.
  */
 CINDEX_LINKAGE unsigned clang_Cursor_hasAttrs(CXCursor C);
 
 /**
  * \brief Determine whether the given cursor kind represents an invalid
  * cursor.
  */
-CINDEX_LINKAGE unsigned clang_isInvalid(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isInvalid(enum CXCursorKind);
 
 /**
  * \brief Determine whether the given cursor kind represents a translation
  * unit.
  */
-CINDEX_LINKAGE unsigned clang_isTranslationUnit(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isTranslationUnit(enum CXCursorKind);
 
 /***
  * \brief Determine whether the given cursor represents a preprocessing
  * element, such as a preprocessor directive or macro instantiation.
  */
-CINDEX_LINKAGE unsigned clang_isPreprocessing(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isPreprocessing(enum CXCursorKind);
   
 /***
  * \brief Determine whether the given cursor represents a currently
  *  unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).
  */
-CINDEX_LINKAGE unsigned clang_isUnexposed(enum CXCursorKind);
+CINDEX_LINKAGE bool clang_isUnexposed(enum CXCursorKind);
 
 /**
  * \brief Describe the linkage of the entity referred to by a cursor.
  */
 enum CXLinkageKind {
   /** \brief This value indicates that no linkage information is available
    * for a provided CXCursor. */
   CXLinkage_Invalid,

     CXCursor C, unsigned I);
 
 /**
  * \brief Determine whether two CXTypes represent the same type.
  *
  * \returns non-zero if the CXTypes represent the same type and
  *          zero otherwise.
  */
-CINDEX_LINKAGE unsigned clang_equalTypes(CXType A, CXType B);
+CINDEX_LINKAGE bool clang_equalTypes(CXType A, CXType B);
 
 /**
  * \brief Return the canonical type for a CXType.
  *
  * Clang's type system explicitly models typedefs and all the ways
  * a specific type can be represented.  The canonical type is the underlying
  * type with all the "sugar" removed.  For example, if 'T' is a typedef
  * for 'int', the canonical type for 'T' would be 'int'.
  */
 CINDEX_LINKAGE CXType clang_getCanonicalType(CXType T);
 
 /**
  * \brief Determine whether a CXType has the "const" qualifier set,
  * without looking through typedefs that may have added "const" at a
  * different level.
  */
-CINDEX_LINKAGE unsigned clang_isConstQualifiedType(CXType T);
+CINDEX_LINKAGE bool clang_isConstQualifiedType(CXType T);
 
 /**
  * \brief Determine whether a  CXCursor that is a macro, is
  * function like.
  */
-CINDEX_LINKAGE unsigned clang_Cursor_isMacroFunctionLike(CXCursor C);
+CINDEX_LINKAGE bool clang_Cursor_isMacroFunctionLike(CXCursor C);
 
 /**
  * \brief Determine whether a  CXCursor that is a macro, is a
  * builtin one.
  */
-CINDEX_LINKAGE unsigned clang_Cursor_isMacroBuiltin(CXCursor C);
+CINDEX_LINKAGE bool clang_Cursor_isMacroBuiltin(CXCursor C);
 
 /**
  * \brief Determine whether a  CXCursor that is a function declaration, is an
  * inline declaration.
  */
-CINDEX_LINKAGE unsigned clang_Cursor_isFunctionInlined(CXCursor C);
+CINDEX_LINKAGE bool clang_Cursor_isFunctionInlined(CXCursor C);
 
 /**
  * \brief Determine whether a CXType has the "volatile" qualifier set,
  * without looking through typedefs that may have added "volatile" at
  * a different level.
  */
-CINDEX_LINKAGE unsigned clang_isVolatileQualifiedType(CXType T);
+CINDEX_LINKAGE bool clang_isVolatileQualifiedType(CXType T);
 
 /**
  * \brief Determine whether a CXType has the "restrict" qualifier set,
  * without looking through typedefs that may have added "restrict" at a
  * different level.
  */
-CINDEX_LINKAGE unsigned clang_isRestrictQualifiedType(CXType T);
+CINDEX_LINKAGE bool clang_isRestrictQualifiedType(CXType T);
 
 /**
  * \brief For pointer types, returns the type of the pointee.
  */
 CINDEX_LINKAGE CXType clang_getPointeeType(CXType T);
 
 /**
  * \brief Return the cursor for the declaration of the given type.

  * child of \p parent.
  *
  * \param client_data pointer data supplied by the client, which will
  * be passed to the visitor each time it is invoked.
  *
  * \returns a non-zero value if the traversal was terminated
  * prematurely by the visitor returning \c CXChildVisit_Break.
  */
-CINDEX_LINKAGE unsigned clang_visitChildren(CXCursor parent,
+CINDEX_LINKAGE bool clang_visitChildren(CXCursor parent,
                                             CXCursorVisitor visitor,
                                             CXClientData client_data);
 #ifdef __has_feature
 #  if __has_feature(blocks)
 /**
  * \brief Visitor invoked for each cursor found by a traversal.
  *
  * This visitor block will be invoked for each cursor found by

   /**
    * \brief Called to index a reference of an entity.
    */
   void (*indexEntityReference)(CXClientData client_data,
                                const CXIdxEntityRefInfo *);
 
 } IndexerCallbacks;
 
-CINDEX_LINKAGE int clang_index_isEntityObjCContainerKind(CXIdxEntityKind);
+CINDEX_LINKAGE bool clang_index_isEntityObjCContainerKind(CXIdxEntityKind);
 CINDEX_LINKAGE const CXIdxObjCContainerDeclInfo *
 clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *);
 
 CINDEX_LINKAGE const CXIdxObjCInterfaceDeclInfo *
 clang_index_getObjCInterfaceDeclInfo(const CXIdxDeclInfo *);
 
 CINDEX_LINKAGE
 const CXIdxObjCCategoryDeclInfo *

  * field of \p T.
  *
  * \param client_data pointer data supplied by the client, which will
  * be passed to the visitor each time it is invoked.
  *
  * \returns a non-zero value if the traversal was terminated
  * prematurely by the visitor returning \c CXFieldVisit_Break.
  */
-CINDEX_LINKAGE unsigned clang_Type_visitFields(CXType T,
+CINDEX_LINKAGE bool clang_Type_visitFields(CXType T,
                                                CXFieldVisitor visitor,
                                                CXClientData client_data);
 
 /**
  * @}
  */
 
 /**
  * @}
  */
 
 #ifdef __cplusplus
 }
 #endif
 #endif

include/llvm-c/Core.h

 void LLVMDumpModule(LLVMModuleRef M);
 
 /**
  * Print a representation of a module to a file. The ErrorMessage needs to be
  * disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.
  *
  * @see Module::print()
  */
-LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
+bool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
                                char **ErrorMessage);
 
 /**
  * Return a string representation of the module. Use
  * LLVMDisposeMessage to free the string.
  *
  * @see Module::print()
  */

 
 /**
  * Whether the type has a known size.
  *
  * Things that don't have a size are abstract types, labels, and void.a
  *
  * @see llvm::Type::isSized()
  */
-LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty);
+bool LLVMTypeIsSized(LLVMTypeRef Ty);
 
 /**
  * Obtain the context to which this type instance is associated.
  *
  * @see llvm::Type::getContext()
  */
 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty);
 

  */
 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
                              LLVMBool IsVarArg);
 
 /**
  * Returns whether a function type is variadic.
  */
-LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
+bool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy);
 
 /**
  * Obtain the Type this function Type returns.
  */
 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy);
 
 /**
  * Obtain the number of parameters this function accepts.

  */
 LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i);
 
 /**
  * Determine whether a structure is packed.
  *
  * @see llvm::StructType::isPacked()
  */
-LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy);
+bool LLVMIsPackedStruct(LLVMTypeRef StructTy);
 
 /**
  * Determine whether a structure is opaque.
  *
  * @see llvm::StructType::isOpaque()
  */
-LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
+bool LLVMIsOpaqueStruct(LLVMTypeRef StructTy);
 
 /**
  * @}
  */
 
 /**
  * @defgroup LLVMCCoreTypeSequential Sequential Types
  *

  *
  * @see llvm::Value::replaceAllUsesWith()
  */
 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal);
 
 /**
  * Determine whether the specified value instance is constant.
  */
-LLVMBool LLVMIsConstant(LLVMValueRef Val);
+bool LLVMIsConstant(LLVMValueRef Val);
 
 /**
  * Determine whether a value instance is undefined.
  */
-LLVMBool LLVMIsUndef(LLVMValueRef Val);
+bool LLVMIsUndef(LLVMValueRef Val);
 
 /**
  * Convert value instances between types.
  *
  * Internally, an LLVMValueRef is "pinned" to a specific type. This
  * series of functions allows you to cast an instance to a specific
  * type.
  *

  */
 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty);
 
 /**
  * Determine whether a value instance is null.
  *
  * @see llvm::Constant::isNullValue()
  */
-LLVMBool LLVMIsNull(LLVMValueRef Val);
+bool LLVMIsNull(LLVMValueRef Val);
 
 /**
  * Obtain a constant that is a constant pointer pointing to NULL for a
  * specified type.
  */
 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty);
 
 /**

 LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
                              LLVMBool DontNullTerminate);
 
 /**
  * Returns true if the specified constant is an array of i8.
  *
  * @see ConstantDataSequential::getAsString()
  */
-LLVMBool LLVMIsConstantString(LLVMValueRef c);
+bool LLVMIsConstantString(LLVMValueRef c);
 
 /**
  * Get the given constant data sequential as a string.
  *
  * @see ConstantDataSequential::getAsString()
  */
 const char *LLVMGetAsString(LLVMValueRef c, size_t *Length);
 

  * this group relate to functions in the llvm::GlobalValue class tree.
  *
  * @see llvm::GlobalValue
  *
  * @{
  */
 
 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global);
-LLVMBool LLVMIsDeclaration(LLVMValueRef Global);
+bool LLVMIsDeclaration(LLVMValueRef Global);
 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global);
 void LLVMSetLinkage(LLVMValueRef Global, LLVMLinkage Linkage);
 const char *LLVMGetSection(LLVMValueRef Global);
 void LLVMSetSection(LLVMValueRef Global, const char *Section);
 LLVMVisibility LLVMGetVisibility(LLVMValueRef Global);
 void LLVMSetVisibility(LLVMValueRef Global, LLVMVisibility Viz);
 LLVMDLLStorageClass LLVMGetDLLStorageClass(LLVMValueRef Global);
 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class);
-LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global);
+bool LLVMHasUnnamedAddr(LLVMValueRef Global);
 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr);
 
 /**
  * @defgroup LLVMCCoreValueWithAlignment Values with alignment
  *
  * Functions in this group only apply to values with alignment, i.e.
  * global variables, load and store instructions.
  */

 LLVMValueRef LLVMGetNamedGlobal(LLVMModuleRef M, const char *Name);
 LLVMValueRef LLVMGetFirstGlobal(LLVMModuleRef M);
 LLVMValueRef LLVMGetLastGlobal(LLVMModuleRef M);
 LLVMValueRef LLVMGetNextGlobal(LLVMValueRef GlobalVar);
 LLVMValueRef LLVMGetPreviousGlobal(LLVMValueRef GlobalVar);
 void LLVMDeleteGlobal(LLVMValueRef GlobalVar);
 LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar);
 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal);
-LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
+bool LLVMIsThreadLocal(LLVMValueRef GlobalVar);
 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal);
-LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
+bool LLVMIsGlobalConstant(LLVMValueRef GlobalVar);
 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant);
 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar);
 void LLVMSetThreadLocalMode(LLVMValueRef GlobalVar, LLVMThreadLocalMode Mode);
-LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar);
+bool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar);
 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit);
 
 /**
  * @}
  */
 
 /**
  * @defgroup LLVMCoreValueConstantGlobalAlias Global Aliases

  */
 void LLVMDeleteFunction(LLVMValueRef Fn);
 
 /**
  * Check whether the given function has a personality function.
  *
  * @see llvm::Function::hasPersonalityFn()
  */
-LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn);
+bool LLVMHasPersonalityFn(LLVMValueRef Fn);
 
 /**
  * Obtain the personality function attached to the function.
  *
  * @see llvm::Function::getPersonalityFn()
  */
 LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn);
 

 /**
  * Convert a basic block instance to a value type.
  */
 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB);
 
 /**
  * Determine whether an LLVMValueRef is itself a basic block.
  */
-LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val);
+bool LLVMValueIsBasicBlock(LLVMValueRef Val);
 
 /**
  * Convert an LLVMValueRef to an LLVMBasicBlockRef instance.
  */
 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val);
 
 /**
  * Obtain the string name of a basic block.

  * llvm::Instruction types, e.g. llvm::CallInst.
  *
  * @{
  */
 
 /**
  * Determine whether an instruction has any metadata attached.
  */
-int LLVMHasMetadata(LLVMValueRef Val);
+bool LLVMHasMetadata(LLVMValueRef Val);
 
 /**
  * Return metadata associated with an instruction value.
  */
 LLVMValueRef LLVMGetMetadata(LLVMValueRef Val, unsigned KindID);
 
 /**
  * Set metadata associated with an instruction value.

 
 /**
  * Obtain whether a call instruction is a tail call.
  *
  * This only works on llvm::CallInst instructions.
  *
  * @see llvm::CallInst::isTailCall()
  */
-LLVMBool LLVMIsTailCall(LLVMValueRef CallInst);
+bool LLVMIsTailCall(LLVMValueRef CallInst);
 
 /**
  * Set whether a call instruction is a tail call.
  *
  * This only works on llvm::CallInst instructions.
  *
  * @see llvm::CallInst::setTailCall()
  */

 
 /**
  * Return if a branch is conditional.
  *
  * This only works on llvm::BranchInst instructions.
  *
  * @see llvm::BranchInst::isConditional
  */
-LLVMBool LLVMIsConditional(LLVMValueRef Branch);
+bool LLVMIsConditional(LLVMValueRef Branch);
 
 /**
  * Return the condition of a branch instruction.
  *
  * This only works on llvm::BranchInst instructions.
  *
  * @see llvm::BranchInst::getCondition
  */

  * llvm::GetElementPtrInst instances.
  *
  * @{
  */
 
 /**
  * Check whether the given GEP instruction is inbounds.
  */
-LLVMBool LLVMIsInBounds(LLVMValueRef GEP);
+bool LLVMIsInBounds(LLVMValueRef GEP);
 
 /**
  * Set the given GEP instruction to be inbounds or not.
  */
 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds);
 
 /**
  * @}

 
 /* Get the value of the clause at idnex Idx on the landingpad instruction */
 LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx);
 
 /* Add a catch or filter clause to the landingpad instruction */
 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal);
 
 /* Get the 'cleanup' flag in the landingpad instruction */
-LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad);
+bool LLVMIsCleanup(LLVMValueRef LandingPad);
 
 /* Set the 'cleanup' flag in the landingpad instruction */
 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val);
 
 /* Arithmetic */
 LLVMValueRef LLVMBuildAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
                           const char *Name);
 LLVMValueRef LLVMBuildNSWAdd(LLVMBuilderRef, LLVMValueRef LHS, LLVMValueRef RHS,
LLVMValueRef LLVMBuildInBoundsGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
                                   LLVMValueRef *Indices, unsigned NumIndices,
                                   const char *Name);
 LLVMValueRef LLVMBuildStructGEP(LLVMBuilderRef B, LLVMValueRef Pointer,
                                 unsigned Idx, const char *Name);
 LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
                                    const char *Name);
 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
                                       const char *Name);
-LLVMBool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
+bool LLVMGetVolatile(LLVMValueRef MemoryAccessInst);
 void LLVMSetVolatile(LLVMValueRef MemoryAccessInst, LLVMBool IsVolatile);
 LLVMAtomicOrdering LLVMGetOrdering(LLVMValueRef MemoryAccessInst);
 void LLVMSetOrdering(LLVMValueRef MemoryAccessInst, LLVMAtomicOrdering Ordering);
 
 /* Casts */
 LLVMValueRef LLVMBuildTrunc(LLVMBuilderRef, LLVMValueRef Val,
                             LLVMTypeRef DestTy, const char *Name);
 LLVMValueRef LLVMBuildZExt(LLVMBuilderRef, LLVMValueRef Val,
LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B, LLVMAtomicRMWBinOp op,
                                 LLVMAtomicOrdering ordering,
                                 LLVMBool singleThread);
 LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
                                     LLVMValueRef Cmp, LLVMValueRef New,
                                     LLVMAtomicOrdering SuccessOrdering,
                                     LLVMAtomicOrdering FailureOrdering,
                                     LLVMBool SingleThread);
 
-LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst);
+bool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst);
 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool SingleThread);
 
 LLVMAtomicOrdering LLVMGetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst);
 void LLVMSetCmpXchgSuccessOrdering(LLVMValueRef CmpXchgInst,
                                    LLVMAtomicOrdering Ordering);
 LLVMAtomicOrdering LLVMGetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst);
 void LLVMSetCmpXchgFailureOrdering(LLVMValueRef CmpXchgInst,
                                    LLVMAtomicOrdering Ordering);

 
 /** Deprecated: Use LLVMCreateFunctionPassManagerForModule instead. */
 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef MP);
 
 /** Initializes, executes on the provided module, and finalizes all of the
     passes scheduled in the pass manager. Returns 1 if any of the passes
     modified the module, 0 otherwise.
     @see llvm::PassManager::run(Module&) */
-LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
+bool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M);
 
 /** Initializes all of the function passes scheduled in the function pass
     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
     @see llvm::FunctionPassManager::doInitialization */
-LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
+bool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM);
 
 /** Executes all of the function passes scheduled in the function pass manager
     on the provided function. Returns 1 if any of the passes modified the
     function, false otherwise.
     @see llvm::FunctionPassManager::run(Function&) */
-LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
+bool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F);
 
 /** Finalizes all of the function passes scheduled in in the function pass
     manager. Returns 1 if any of the passes modified the module, 0 otherwise.
     @see llvm::FunctionPassManager::doFinalization */
-LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
+bool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM);
 
 /** Frees the memory of a pass pipeline. For function pipelines, does not free
     the module provider.
     @see llvm::PassManagerBase::~PassManagerBase. */
 void LLVMDisposePassManager(LLVMPassManagerRef PM);
 
 /**
  * @}

 LLVMBool LLVMStartMultithreaded(void);
 
 /** Deprecated: Multi-threading can only be enabled/disabled with the compile
     time define LLVM_ENABLE_THREADS. */
 void LLVMStopMultithreaded(void);
 
 /** Check whether LLVM is executing in thread-safe mode or not.
     @see llvm::llvm_is_multithreaded */
-LLVMBool LLVMIsMultithreaded(void);
+bool LLVMIsMultithreaded(void);
 
 /**
  * @}
  */
 
 /**
  * @}
  */

include/llvm-c/Disassembler.h

LLVMCreateDisasmCPUFeatures(const char *Triple, const char *CPU,
                             const char *Features, void *DisInfo, int TagType,
                             LLVMOpInfoCallback GetOpInfo,
                             LLVMSymbolLookupCallback SymbolLookUp);
 
 /**
  * Set the disassembler's options.  Returns 1 if it can set the Options and 0
  * otherwise.
  */
-int LLVMSetDisasmOptions(LLVMDisasmContextRef DC, uint64_t Options);
+bool LLVMSetDisasmOptions(LLVMDisasmContextRef DC, uint64_t Options);
 
 /* The option to produce marked up assembly. */
 #define LLVMDisassembler_Option_UseMarkup 1
 /* The option to print immediates as hex. */
 #define LLVMDisassembler_Option_PrintImmHex 2
 /* The option use the other assembler printer variant */
 #define LLVMDisassembler_Option_AsmPrinterVariant 4
 /* The option to set comment on instructions */

include/llvm-c/Object.h

LLVMBool LLVMIsSymbolIteratorAtEnd(LLVMObjectFileRef ObjectFile,
                                 LLVMSymbolIteratorRef SI);
 void LLVMMoveToNextSymbol(LLVMSymbolIteratorRef SI);
 
 // SectionRef accessors
 const char *LLVMGetSectionName(LLVMSectionIteratorRef SI);
 uint64_t LLVMGetSectionSize(LLVMSectionIteratorRef SI);
 const char *LLVMGetSectionContents(LLVMSectionIteratorRef SI);
 uint64_t LLVMGetSectionAddress(LLVMSectionIteratorRef SI);
-LLVMBool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
+bool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
                                  LLVMSymbolIteratorRef Sym);
 
 // Section Relocation iterators
 LLVMRelocationIteratorRef LLVMGetRelocations(LLVMSectionIteratorRef Section);
 void LLVMDisposeRelocationIterator(LLVMRelocationIteratorRef RI);
 LLVMBool LLVMIsRelocationIteratorAtEnd(LLVMSectionIteratorRef Section,
                                        LLVMRelocationIteratorRef RI);
 void LLVMMoveToNextRelocation(LLVMRelocationIteratorRef RI);

include/llvm-c/Support.h

 #endif
 
 /**
  * This function permanently loads the dynamic library at the given path.
  * It is safe to call this function multiple times for the same library.
  *
  * @see sys::DynamicLibrary::LoadLibraryPermanently()
   */
-LLVMBool LLVMLoadLibraryPermanently(const char* Filename);
+bool LLVMLoadLibraryPermanently(const char* Filename);
 
 /**
  * This function parses the given arguments using the LLVM command line parser.
  * Note that the only stable thing about this function is its signature; you
  * cannot rely on any particular set of command line arguments being interpreted
  * the same way across LLVM versions.
  *
  * @see llvm::cl::ParseCommandLineOptions()

include/llvm-c/TargetMachine.h

 
 /** Returns the name of a target. See llvm::Target::getName */
 const char *LLVMGetTargetName(LLVMTargetRef T);
 
 /** Returns the description  of a target. See llvm::Target::getDescription */
 const char *LLVMGetTargetDescription(LLVMTargetRef T);
 
 /** Returns if the target has a JIT */
-LLVMBool LLVMTargetHasJIT(LLVMTargetRef T);
+bool LLVMTargetHasJIT(LLVMTargetRef T);
 
 /** Returns if the target has a TargetMachine associated */
-LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T);
+bool LLVMTargetHasTargetMachine(LLVMTargetRef T);
 
 /** Returns if the target as an ASM backend (required for emitting output) */
-LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T);
+bool LLVMTargetHasAsmBackend(LLVMTargetRef T);
 
 /*===-- Target Machine ----------------------------------------------------===*/
 /** Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine */
 LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
   const char *Triple, const char *CPU, const char *Features,
   LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc, LLVMCodeModel CodeModel);
 
 /** Dispose the LLVMTargetMachineRef instance generated by

 
 /** Set the target machine's ASM verbosity. */
 void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
                                       LLVMBool VerboseAsm);
 
 /** Emits an asm or object file for the given module to the filename. This
   wraps several c++ only classes (among them a file stream). Returns any
   error in ErrorMessage. Use LLVMDisposeMessage to dispose the message. */
-LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
+bool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
   char *Filename, LLVMCodeGenFileType codegen, char **ErrorMessage);
 
 /** Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf. */
-LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T, LLVMModuleRef M,
+bool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T, LLVMModuleRef M,
   LLVMCodeGenFileType codegen, char** ErrorMessage, LLVMMemoryBufferRef *OutMemBuf);
 
 /*===-- Triple ------------------------------------------------------------===*/
 /** Get a triple for the host machine as a string. The result needs to be
   disposed with LLVMDisposeMessage. */
 char* LLVMGetDefaultTargetTriple(void);
 
 /** Adds the target-specific analysis passes to the pass manager. */
 void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, LLVMPassManagerRef PM);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif

include/llvm/ADT/APInt.h

 
   /// Assign one bignum to another.
   static void tcAssign(integerPart *, const integerPart *, unsigned int);
 
   /// Returns true if a bignum is zero, false otherwise.
   static bool tcIsZero(const integerPart *, unsigned int);
 
   /// Extract the given bit of a bignum; returns 0 or 1.  Zero-based.
-  static int tcExtractBit(const integerPart *, unsigned int bit);
+  static bool tcExtractBit(const integerPart *, unsigned int bit);
 
   /// Copy the bit vector of width srcBITS from SRC, starting at bit srcLSB, to
   /// DST, of dstCOUNT parts, such that the bit srcLSB becomes the least
   /// significant bit of DST.  All high bits above srcBITS in DST are
   /// zero-filled.
   static void tcExtract(integerPart *, unsigned int dstCount,
                         const integerPart *, unsigned int srcBits,
                         unsigned int srcLSB);

   /// Otherwise set LHS to LHS / RHS with the fractional part discarded, set
   /// REMAINDER to the remainder, return zero.  i.e.
   ///
   ///  OLD_LHS = RHS * LHS + REMAINDER
   ///
   /// SCRATCH is a bignum of the same size as the operands and result for use by
   /// the routine; its contents need not be initialized and are destroyed.  LHS,
   /// REMAINDER and SCRATCH must be distinct.
-  static int tcDivide(integerPart *lhs, const integerPart *rhs,
+  static bool tcDivide(integerPart *lhs, const integerPart *rhs,
                       integerPart *remainder, integerPart *scratch,
                       unsigned int parts);
 
   /// Shift a bignum left COUNT bits.  Shifted in bits are zero.  There are no
   /// restrictions on COUNT.
   static void tcShiftLeft(integerPart *, unsigned int parts,
                           unsigned int count);
 
   /// Shift a bignum right COUNT bits.  Shifted in bits are zero.  There are no
   /// restrictions on COUNT.
   static void tcShiftRight(integerPart *, unsigned int parts,
                            unsigned int count);
 
   /// The obvious AND, OR and XOR and complement operations.
   static void tcAnd(integerPart *, const integerPart *, unsigned int);
   static void tcOr(integerPart *, const integerPart *, unsigned int);
   static void tcXor(integerPart *, const integerPart *, unsigned int);
   static void tcComplement(integerPart *, unsigned int);
 
   /// Comparison (unsigned) of two bignums.
   static int tcCompare(const integerPart *, const integerPart *, unsigned int);
 
   /// Increment a bignum in-place.  Return the carry flag.
-  static integerPart tcIncrement(integerPart *, unsigned int);
+  static bool tcIncrement(integerPart *, unsigned int);
 
   /// Decrement a bignum in-place.  Return the borrow flag.
   static integerPart tcDecrement(integerPart *, unsigned int);
 
   /// Set the least significant BITS and clear the rest.
   static void tcSetLeastSignificantBits(integerPart *, unsigned int,
                                         unsigned int bits);
 

include/llvm/Object/MachO.h

public:
   bool getPlainRelocationExternal(const MachO::any_relocation_info &RE) const;
   bool getScatteredRelocationScattered(
                                     const MachO::any_relocation_info &RE) const;
   uint32_t getScatteredRelocationValue(
                                     const MachO::any_relocation_info &RE) const;
   uint32_t getScatteredRelocationType(
                                     const MachO::any_relocation_info &RE) const;
   unsigned getAnyRelocationAddress(const MachO::any_relocation_info &RE) const;
-  unsigned getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const;
+  bool getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const;
   unsigned getAnyRelocationLength(const MachO::any_relocation_info &RE) const;
   unsigned getAnyRelocationType(const MachO::any_relocation_info &RE) const;
   SectionRef getAnyRelocationSection(const MachO::any_relocation_info &RE) const;
 
   // MachO specific structures.
   MachO::section getSection(DataRefImpl DRI) const;
   MachO::section_64 getSection64(DataRefImpl DRI) const;
   MachO::section getSection(const LoadCommandInfo &L, unsigned Index) const;

lib/AST/Decl.cpp

 static bool usesTypeVisibility(const NamedDecl *D) {
   return isa<TypeDecl>(D) ||
          isa<ClassTemplateDecl>(D) ||
          isa<ObjCInterfaceDecl>(D);
 }
 
 /// Does the given declaration have member specialization information,
 /// and if so, is it an explicit specialization?
-template <class T> static typename
-std::enable_if<!std::is_base_of<RedeclarableTemplateDecl, T>::value, bool>::type
+template <class T> static bool
 isExplicitMemberSpecialization(const T *D) {
   if (const MemberSpecializationInfo *member =
         D->getMemberSpecializationInfo()) {
     return member->isExplicitSpecialization();
   }
   return false;
 }
 

lib/AST/DeclPrinter.cpp

   }
   
   Out << Ctx.getUnqualifiedObjCPointerType(T).getAsString(Policy);
   Out << ')';
 }
 
 void DeclPrinter::PrintObjCTypeParams(ObjCTypeParamList *Params) {
   Out << "<";
-  unsigned First = true;
+  unsigned First = 1;
   for (auto *Param : *Params) {
     if (First) {
-      First = false;
+      First = 0;
     } else {
       Out << ", ";
     }
 
     switch (Param->getVariance()) {
     case ObjCTypeParamVariance::Invariant:
       break;
 

lib/AST/DeclarationName.cpp

int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
   case DeclarationName::ObjCOneArgSelector:
   case DeclarationName::ObjCMultiArgSelector: {
     Selector LHSSelector = LHS.getObjCSelector();
     Selector RHSSelector = RHS.getObjCSelector();
     unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
     for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) {
       switch (LHSSelector.getNameForSlot(I).compare(
                                                RHSSelector.getNameForSlot(I))) {
-      case -1: return true;
-      case 1: return false;
+      case -1: return 1;
+      case 1: return 0;
       default: break;
       }
     }
 
     return compareInt(LN, RN);
   }
   
   case DeclarationName::CXXConstructorName:

lib/AsmParser/LLParser.cpp

     return TokError("found end of file when expecting more instructions");
   LocTy Loc = Lex.getLoc();
   unsigned KeywordVal = Lex.getUIntVal();
   Lex.Lex();  // Eat the keyword.
 
   switch (Token) {
   default:                    return Error(Loc, "expected instruction opcode");
   // Terminator Instructions.
-  case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
+  case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return 0;
   case lltok::kw_ret:         return ParseRet(Inst, BB, PFS);
   case lltok::kw_br:          return ParseBr(Inst, PFS);
   case lltok::kw_switch:      return ParseSwitch(Inst, PFS);
   case lltok::kw_indirectbr:  return ParseIndirectBr(Inst, PFS);
   case lltok::kw_invoke:      return ParseInvoke(Inst, PFS);
   case lltok::kw_resume:      return ParseResume(Inst, PFS);
   case lltok::kw_cleanupret:  return ParseCleanupRet(Inst, PFS);
   case lltok::kw_catchret:    return ParseCatchRet(Inst, PFS);
   case lltok::kw_catchswitch: return ParseCatchSwitch(Inst, PFS);
   case lltok::kw_catchpad:    return ParseCatchPad(Inst, PFS);
   case lltok::kw_cleanuppad:  return ParseCleanupPad(Inst, PFS);
   // Binary Operators.
   case lltok::kw_add:
   case lltok::kw_sub:
   case lltok::kw_mul:
   case lltok::kw_shl: {
     bool NUW = EatIfPresent(lltok::kw_nuw);
     bool NSW = EatIfPresent(lltok::kw_nsw);
     if (!NUW) NUW = EatIfPresent(lltok::kw_nuw);
 
-    if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
+    if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return 1;
 
     if (NUW) cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
     if (NSW) cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
-    return false;
+    return 0;
   }
   case lltok::kw_fadd:
   case lltok::kw_fsub:
   case lltok::kw_fmul:
   case lltok::kw_fdiv:
   case lltok::kw_frem: {
     FastMathFlags FMF = EatFastMathFlagsIfPresent();
     int Res = ParseArithmetic(Inst, PFS, KeywordVal, 2);
     if (Res != 0)
       return Res;
     if (FMF.any())
       Inst->setFastMathFlags(FMF);
     return 0;
   }
 
   case lltok::kw_sdiv:
   case lltok::kw_udiv:
   case lltok::kw_lshr:
   case lltok::kw_ashr: {
     bool Exact = EatIfPresent(lltok::kw_exact);
 
-    if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return true;
+    if (ParseArithmetic(Inst, PFS, KeywordVal, 1)) return 1;
     if (Exact) cast<BinaryOperator>(Inst)->setIsExact(true);
-    return false;
+    return 0;
   }
 
   case lltok::kw_urem:
   case lltok::kw_srem:   return ParseArithmetic(Inst, PFS, KeywordVal, 1);
   case lltok::kw_and:
   case lltok::kw_or:
   case lltok::kw_xor:    return ParseLogical(Inst, PFS, KeywordVal);
   case lltok::kw_icmp:   return ParseCompare(Inst, PFS, KeywordVal);

   Value *Op0, *Op1;
 
   if (ParseType(Ty, TypeLoc) ||
       ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
       ParseValue(Ty, Op0, PFS) ||
       ParseToken(lltok::comma, "expected ',' after insertelement value") ||
       ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
       ParseToken(lltok::rsquare, "expected ']' in phi value list"))
-    return true;
+    return 1;
 
   bool AteExtraComma = false;
   SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals;
   while (1) {
     PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1)));
 
     if (!EatIfPresent(lltok::comma))
       break;
 
     if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
       break;
     }
 
     if (ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
         ParseValue(Ty, Op0, PFS) ||
         ParseToken(lltok::comma, "expected ',' after insertelement value") ||
         ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
         ParseToken(lltok::rsquare, "expected ']' in phi value list"))
-      return true;
+      return 1;
   }
 
   if (!Ty->isFirstClassType())
     return Error(TypeLoc, "phi node must have first class type");
 
   PHINode *PN = PHINode::Create(Ty, PHIVals.size());
   for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
     PN->addIncoming(PHIVals[i].first, PHIVals[i].second);

   Value *Size = nullptr;
   LocTy SizeLoc, TyLoc;
   unsigned Alignment = 0;
   Type *Ty = nullptr;
 
   bool IsInAlloca = EatIfPresent(lltok::kw_inalloca);
   bool IsSwiftError = EatIfPresent(lltok::kw_swifterror);
 
-  if (ParseType(Ty, TyLoc)) return true;
+  if (ParseType(Ty, TyLoc)) return 1;
 
   if (Ty->isFunctionTy() || !PointerType::isValidElementType(Ty))
     return Error(TyLoc, "invalid type for alloca");
 
   bool AteExtraComma = false;
   if (EatIfPresent(lltok::comma)) {
     if (Lex.getKind() == lltok::kw_align) {
-      if (ParseOptionalAlignment(Alignment)) return true;
+      if (ParseOptionalAlignment(Alignment)) return 1;
     } else if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
     } else {
       if (ParseTypeAndValue(Size, SizeLoc, PFS) ||
           ParseOptionalCommaAlign(Alignment, AteExtraComma))
-        return true;
+        return 1;
     }
   }
 
   if (Size && !Size->getType()->isIntegerTy())
     return Error(SizeLoc, "element count must have integer type");
 
   AllocaInst *AI = new AllocaInst(Ty, Size, Alignment);
   AI->setUsedWithInAlloca(IsInAlloca);

 
   Type *Ty;
   LocTy ExplicitTypeLoc = Lex.getLoc();
   if (ParseType(Ty) ||
       ParseToken(lltok::comma, "expected comma after load's type") ||
       ParseTypeAndValue(Val, Loc, PFS) ||
       ParseScopeAndOrdering(isAtomic, Scope, Ordering) ||
       ParseOptionalCommaAlign(Alignment, AteExtraComma))
-    return true;
+    return 1;
 
   if (!Val->getType()->isPointerTy() || !Ty->isFirstClassType())
     return Error(Loc, "load operand must be a pointer to a first class type");
   if (isAtomic && !Alignment)
     return Error(Loc, "atomic load must have explicit non-zero alignment");
   if (Ordering == AtomicOrdering::Release ||
       Ordering == AtomicOrdering::AcquireRelease)
     return Error(Loc, "atomic load cannot use Release ordering");

     Lex.Lex();
   }
 
   if (ParseTypeAndValue(Val, Loc, PFS) ||
       ParseToken(lltok::comma, "expected ',' after store operand") ||
       ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
       ParseScopeAndOrdering(isAtomic, Scope, Ordering) ||
       ParseOptionalCommaAlign(Alignment, AteExtraComma))
-    return true;
+    return 1;
 
   if (!Ptr->getType()->isPointerTy())
     return Error(PtrLoc, "store operand must be a pointer");
   if (!Val->getType()->isFirstClassType())
     return Error(Loc, "store operand must be a first class value");
   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
     return Error(Loc, "stored value and pointer type do not match");
   if (isAtomic && !Alignment)

 
   if (ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
       ParseToken(lltok::comma, "expected ',' after cmpxchg address") ||
       ParseTypeAndValue(Cmp, CmpLoc, PFS) ||
       ParseToken(lltok::comma, "expected ',' after cmpxchg cmp operand") ||
       ParseTypeAndValue(New, NewLoc, PFS) ||
       ParseScopeAndOrdering(true /*Always atomic*/, Scope, SuccessOrdering) ||
       ParseOrdering(FailureOrdering))
-    return true;
+    return 1;
 
   if (SuccessOrdering == AtomicOrdering::Unordered ||
       FailureOrdering == AtomicOrdering::Unordered)
     return TokError("cmpxchg cannot be unordered");
   if (isStrongerThan(FailureOrdering, SuccessOrdering))
     return TokError("cmpxchg failure argument shall be no stronger than the "
                     "success argument");
   if (FailureOrdering == AtomicOrdering::Release ||

   case lltok::kw_umin: Operation = AtomicRMWInst::UMin; break;
   }
   Lex.Lex();  // Eat the operation.
 
   if (ParseTypeAndValue(Ptr, PtrLoc, PFS) ||
       ParseToken(lltok::comma, "expected ',' after atomicrmw address") ||
       ParseTypeAndValue(Val, ValLoc, PFS) ||
       ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
-    return true;
+    return 1;
 
   if (Ordering == AtomicOrdering::Unordered)
     return TokError("atomicrmw cannot be unordered");
   if (!Ptr->getType()->isPointerTy())
     return Error(PtrLoc, "atomicrmw operand must be a pointer");
   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
     return Error(ValLoc, "atomicrmw value and pointer type do not match");
   if (!Val->getType()->isIntegerTy())

 }
 
 /// ParseFence
 ///   ::= 'fence' 'singlethread'? AtomicOrdering
 int LLParser::ParseFence(Instruction *&Inst, PerFunctionState &PFS) {
   AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
   SynchronizationScope Scope = CrossThread;
   if (ParseScopeAndOrdering(true /*Always atomic*/, Scope, Ordering))
-    return true;
+    return 1;
 
   if (Ordering == AtomicOrdering::Unordered)
     return TokError("fence cannot be unordered");
   if (Ordering == AtomicOrdering::Monotonic)
     return TokError("fence cannot be monotonic");
 
   Inst = new FenceInst(Context, Ordering, Scope);
   return InstNormal;
 }
 
 /// ParseGetElementPtr
 ///   ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
 int LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Ptr = nullptr;
   Value *Val = nullptr;
   LocTy Loc, EltLoc;
 
   bool InBounds = EatIfPresent(lltok::kw_inbounds);
 
   Type *Ty = nullptr;
   LocTy ExplicitTypeLoc = Lex.getLoc();
   if (ParseType(Ty) ||
       ParseToken(lltok::comma, "expected comma after getelementptr's type") ||
       ParseTypeAndValue(Ptr, Loc, PFS))
-    return true;
+    return 1;
 
   Type *BaseType = Ptr->getType();
   PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());
   if (!BasePointerType)
     return Error(Loc, "base of getelementptr must be a pointer");
 
   if (Ty != BasePointerType->getElementType())
     return Error(ExplicitTypeLoc,
                  "explicit pointee type doesn't match operand's pointee type");
 
   SmallVector<Value*, 16> Indices;
   bool AteExtraComma = false;
   // GEP returns a vector of pointers if at least one of parameters is a vector.
   // All vector parameters should have the same vector width.
   unsigned GEPWidth = BaseType->isVectorTy() ?
     BaseType->getVectorNumElements() : 0;
 
   while (EatIfPresent(lltok::comma)) {
     if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
       break;
     }
-    if (ParseTypeAndValue(Val, EltLoc, PFS)) return true;
+    if (ParseTypeAndValue(Val, EltLoc, PFS)) return 1;
     if (!Val->getType()->getScalarType()->isIntegerTy())
       return Error(EltLoc, "getelementptr index must be an integer");
 
     if (Val->getType()->isVectorTy()) {
       unsigned ValNumEl = Val->getType()->getVectorNumElements();
       if (GEPWidth && GEPWidth != ValNumEl)
         return Error(EltLoc,
           "getelementptr vector index has a wrong number of elements");

 /// ParseExtractValue
 ///   ::= 'extractvalue' TypeAndValue (',' uint32)+
 int LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Val; LocTy Loc;
   SmallVector<unsigned, 4> Indices;
   bool AteExtraComma;
   if (ParseTypeAndValue(Val, Loc, PFS) ||
       ParseIndexList(Indices, AteExtraComma))
-    return true;
+    return 1;
 
   if (!Val->getType()->isAggregateType())
     return Error(Loc, "extractvalue operand must be aggregate type");
 
   if (!ExtractValueInst::getIndexedType(Val->getType(), Indices))
     return Error(Loc, "invalid indices for extractvalue");
   Inst = ExtractValueInst::Create(Val, Indices);
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
 /// ParseInsertValue
 ///   ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
 int LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Val0, *Val1; LocTy Loc0, Loc1;
   SmallVector<unsigned, 4> Indices;
   bool AteExtraComma;
   if (ParseTypeAndValue(Val0, Loc0, PFS) ||
       ParseToken(lltok::comma, "expected comma after insertvalue operand") ||
       ParseTypeAndValue(Val1, Loc1, PFS) ||
       ParseIndexList(Indices, AteExtraComma))
-    return true;
+    return 1;
 
   if (!Val0->getType()->isAggregateType())
     return Error(Loc0, "insertvalue operand must be aggregate type");
 
   Type *IndexedType = ExtractValueInst::getIndexedType(Val0->getType(), Indices);
   if (!IndexedType)
     return Error(Loc0, "invalid indices for insertvalue");
   if (IndexedType != Val1->getType())

lib/Bitcode/Writer/BitWriter.cpp

int LLVMWriteBitcodeToFD(LLVMModuleRef M, int FD, int ShouldClose,
                          int Unbuffered) {
   raw_fd_ostream OS(FD, ShouldClose, Unbuffered);
 
   WriteBitcodeToFile(unwrap(M), OS);
   return 0;
 }
 
 int LLVMWriteBitcodeToFileHandle(LLVMModuleRef M, int FileHandle) {
-  return LLVMWriteBitcodeToFD(M, FileHandle, true, false);
+  return LLVMWriteBitcodeToFD(M, FileHandle, 1, 0);
 }
 
 LLVMMemoryBufferRef LLVMWriteBitcodeToMemoryBuffer(LLVMModuleRef M) {
   std::string Data;
   raw_string_ostream OS(Data);
 
   WriteBitcodeToFile(unwrap(M), OS);
   return wrap(MemoryBuffer::getMemBufferCopy(OS.str()).release());
 }

lib/Bitcode/Writer/BitcodeWriter.cpp

   return Stream.EmitAbbrev(Abbv);
 }
 
 void ModuleBitcodeWriter::writeDILocation(const DILocation *N,
                                           SmallVectorImpl<uint64_t> &Record,
                                           unsigned &Abbrev) {
   if (!Abbrev)
     Abbrev = createDILocationAbbrev();
 
   Record.push_back(N->isDistinct());
   Record.push_back(N->getLine());
   Record.push_back(N->getColumn());
   Record.push_back(VE.getMetadataID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getInlinedAt()));
 
   Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev);
   Record.clear();

   Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
                                              SmallVectorImpl<uint64_t> &Record,
                                              unsigned Abbrev) {
   assert(N->isDistinct() && "Expected distinct compile units");
-  Record.push_back(/* IsDistinct */ true);
+  Record.push_back(/* IsDistinct */ 1);
   Record.push_back(N->getSourceLanguage());
   Record.push_back(VE.getMetadataOrNullID(N->getFile()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawProducer()));
   Record.push_back(N->isOptimized());
   Record.push_back(VE.getMetadataOrNullID(N->getRawFlags()));
   Record.push_back(N->getRuntimeVersion());
   Record.push_back(VE.getMetadataOrNullID(N->getRawSplitDebugFilename()));
   Record.push_back(N->getEmissionKind());

lib/CodeGen/CGAtomic.cpp

 AddDirectArgument(CodeGenFunction &CGF, CallArgList &Args,
                   bool UseOptimizedLibcall, llvm::Value *Val, QualType ValTy,
                   SourceLocation Loc, CharUnits SizeInChars) {
   if (UseOptimizedLibcall) {
     // Load value and pass it to the function directly.
     CharUnits Align = CGF.getContext().getTypeAlignInChars(ValTy);
     int64_t SizeInBits = CGF.getContext().toBits(SizeInChars);
     ValTy =
-        CGF.getContext().getIntTypeForBitwidth(SizeInBits, /*Signed=*/false);
+        CGF.getContext().getIntTypeForBitwidth(SizeInBits, /*Signed=*/0);
     llvm::Type *IPtrTy = llvm::IntegerType::get(CGF.getLLVMContext(),
                                                 SizeInBits)->getPointerTo();
     Address Ptr = Address(CGF.Builder.CreateBitCast(Val, IPtrTy), Align);
     Val = CGF.EmitLoadOfScalar(Ptr, false,
                                CGF.getContext().getPointerType(ValTy),
                                Loc);
     // Coerce the value into an appropriately sized integer type.
     Args.add(RValue::get(Val), ValTy);
if (UseLibcall) {
     if (UseOptimizedLibcall)
       LibCallName += "_" + llvm::utostr(Size);
     // By default, assume we return a value of the atomic type.
     if (!HaveRetTy) {
       if (UseOptimizedLibcall) {
         // Value is returned directly.
         // The function returns an appropriately sized integer type.
         RetTy = getContext().getIntTypeForBitwidth(
-            getContext().toBits(sizeChars), /*Signed=*/false);
+            getContext().toBits(sizeChars), /*Signed=*/0);
       } else {
         // Value is returned through parameter before the order.
         RetTy = getContext().VoidTy;
         Args.add(RValue::get(EmitCastToVoidPtr(Dest.getPointer())),
                  getContext().VoidPtrTy);
       }
     }
     // order is always the last parameter

lib/CodeGen/CGBuiltin.cpp

   }
   // Count leading zeros
   case PPC::BI__builtin_altivec_vclzb:
   case PPC::BI__builtin_altivec_vclzh:
   case PPC::BI__builtin_altivec_vclzw:
   case PPC::BI__builtin_altivec_vclzd: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
-    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
+    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), 0);
     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
     return Builder.CreateCall(F, {X, Undef});
   }
   // Copy sign
   case PPC::BI__builtin_vsx_xvcpsgnsp:
   case PPC::BI__builtin_vsx_xvcpsgndp: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));

   }
 
   case SystemZ::BI__builtin_s390_vclzb:
   case SystemZ::BI__builtin_s390_vclzh:
   case SystemZ::BI__builtin_s390_vclzf:
   case SystemZ::BI__builtin_s390_vclzg: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
-    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
+    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), 0);
     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
     return Builder.CreateCall(F, {X, Undef});
   }
 
   case SystemZ::BI__builtin_s390_vctzb:
   case SystemZ::BI__builtin_s390_vctzh:
   case SystemZ::BI__builtin_s390_vctzf:
   case SystemZ::BI__builtin_s390_vctzg: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
-    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
+    Value *Undef = ConstantInt::get(Builder.getInt1Ty(), 0);
     Function *F = CGM.getIntrinsic(Intrinsic::cttz, ResultType);
     return Builder.CreateCall(F, {X, Undef});
   }
 
   case SystemZ::BI__builtin_s390_vfsqdb: {
     llvm::Type *ResultType = ConvertType(E->getType());
     Value *X = EmitScalarExpr(E->getArg(0));
     Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);

lib/CodeGen/CGOpenMPRuntime.cpp

                                              SourceLocation Loc) {
   if (auto *OMPRegionInfo =
           dyn_cast_or_null<CGOpenMPRegionInfo>(CGF.CapturedStmtInfo))
     if (OMPRegionInfo->getThreadIDVariable())
       return OMPRegionInfo->getThreadIDVariableLValue(CGF).getAddress();
 
   auto ThreadID = getThreadID(CGF, Loc);
   auto Int32Ty =
-      CGF.getContext().getIntTypeForBitwidth(/*DestWidth*/ 32, /*Signed*/ true);
+      CGF.getContext().getIntTypeForBitwidth(/*DestWidth*/ 32, /*Signed*/ 1);
   auto ThreadIDTemp = CGF.CreateMemTemp(Int32Ty, /*Name*/ ".threadid_temp.");
   CGF.EmitStoreOfScalar(ThreadID,
                         CGF.MakeAddrLValue(ThreadIDTemp, Int32Ty));
 
   return ThreadIDTemp;
 }
 
 llvm::Constant *

       IL.getPointer(), // &isLastIter
       LB.getPointer(), // &Lower
       UB.getPointer(), // &Upper
       ST.getPointer()  // &Stride
   };
   llvm::Value *Call =
       CGF.EmitRuntimeCall(createDispatchNextFunction(IVSize, IVSigned), Args);
   return CGF.EmitScalarConversion(
-      Call, CGF.getContext().getIntTypeForBitwidth(32, /* Signed */ true),
+      Call, CGF.getContext().getIntTypeForBitwidth(32, /* Signed */ 1),
       CGF.getContext().BoolTy, Loc);
 }
 
 void CGOpenMPRuntime::emitNumThreadsClause(CodeGenFunction &CGF,
                                            llvm::Value *NumThreads,
                                            SourceLocation Loc) {
   if (!CGF.HaveInsertPoint())
     return;

   //   __tgt_offload_entry  *EntriesEnd;     // End of the table with all the
   //                                         // entries (non inclusive).
   // };
   if (TgtBinaryDescriptorQTy.isNull()) {
     ASTContext &C = CGM.getContext();
     auto *RD = C.buildImplicitRecord("__tgt_bin_desc");
     RD->startDefinition();
     addFieldToRecordDecl(
-        C, RD, C.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/true));
+        C, RD, C.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1));
     addFieldToRecordDecl(C, RD, C.getPointerType(getTgtDeviceImageQTy()));
     addFieldToRecordDecl(C, RD, C.getPointerType(getTgtOffloadEntryQTy()));
     addFieldToRecordDecl(C, RD, C.getPointerType(getTgtOffloadEntryQTy()));
     RD->completeDefinition();
     TgtBinaryDescriptorQTy = C.getRecordType(RD);
   }
   return TgtBinaryDescriptorQTy;
 }

   Address DependenciesArray = Address::invalid();
   unsigned NumDependencies = Data.Dependences.size();
   if (NumDependencies) {
     // Dependence kind for RTL.
     enum RTLDependenceKindTy { DepIn = 0x01, DepInOut = 0x3 };
     enum RTLDependInfoFieldsTy { BaseAddr, Len, Flags };
     RecordDecl *KmpDependInfoRD;
     QualType FlagsTy =
-        C.getIntTypeForBitwidth(C.getTypeSize(C.BoolTy), /*Signed=*/false);
+        C.getIntTypeForBitwidth(C.getTypeSize(C.BoolTy), /*Signed=*/0);
     llvm::Type *LLVMFlagsTy = CGF.ConvertTypeForMem(FlagsTy);
     if (KmpDependInfoTy.isNull()) {
       KmpDependInfoRD = C.buildImplicitRecord("kmp_depend_info");
       KmpDependInfoRD->startDefinition();
       addFieldToRecordDecl(C, KmpDependInfoRD, C.getIntPtrType());
       addFieldToRecordDecl(C, KmpDependInfoRD, C.getSizeType());
       addFieldToRecordDecl(C, KmpDependInfoRD, FlagsTy);
       KmpDependInfoRD->completeDefinition();

     BasePointers.append(CurBasePointers.begin(), CurBasePointers.end());
     Pointers.append(CurPointers.begin(), CurPointers.end());
     Sizes.append(CurSizes.begin(), CurSizes.end());
     MapTypes.append(CurMapTypes.begin(), CurMapTypes.end());
   }
 
   // Keep track on whether the host function has to be executed.
   auto OffloadErrorQType =
-      Ctx.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/true);
+      Ctx.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1);
   auto OffloadError = CGF.MakeAddrLValue(
       CGF.CreateMemTemp(OffloadErrorQType, ".run_host_version"),
       OffloadErrorQType);
   CGF.EmitStoreOfScalar(llvm::Constant::getNullValue(CGM.Int32Ty),
                         OffloadError);
 
   // Fill up the pointer arrays and transfer execution to the device.
   auto &&ThenGen = [&Ctx, &BasePointers, &Pointers, &Sizes, &MapTypes, Device,

lib/CodeGen/SelectionDAG/DAGCombiner.cpp

static char isNegatibleForFree(SDValue Op, bool LegalOperations,
 
   // Don't allow anything with multiple uses.
   if (!Op.hasOneUse()) return 0;
 
   // Don't recurse exponentially.
   if (Depth > 6) return 0;
 
   switch (Op.getOpcode()) {
-  default: return false;
+  default: return 0;
   case ISD::ConstantFP:
     // Don't invert constant FP values after legalize.  The negated constant
     // isn't necessarily legal.
     return LegalOperations ? 0 : 1;
   case ISD::FADD:
     // FIXME: determine better conditions for this xform.
     if (!Options->UnsafeFPMath) return 0;
 

lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp

   }
 };
 #endif // NDEBUG
 
 /// bu_ls_rr_sort - Priority function for bottom up register pressure
 // reduction scheduler.
 struct bu_ls_rr_sort : public queue_sort {
   enum {
-    IsBottomUp = true,
-    HasReadyFilter = false
+    IsBottomUp = 1,
+    HasReadyFilter = 0
   };
 
   RegReductionPQBase *SPQ;
   bu_ls_rr_sort(RegReductionPQBase *spq) : SPQ(spq) {}
 
   bool operator()(SUnit* left, SUnit* right) const;
 };
 
 // src_ls_rr_sort - Priority function for source order scheduler.
 struct src_ls_rr_sort : public queue_sort {
   enum {
-    IsBottomUp = true,
-    HasReadyFilter = false
+    IsBottomUp = 1,
+    HasReadyFilter = 0
   };
 
   RegReductionPQBase *SPQ;
   src_ls_rr_sort(RegReductionPQBase *spq)
     : SPQ(spq) {}
 
   bool operator()(SUnit* left, SUnit* right) const;
 };
 
 // hybrid_ls_rr_sort - Priority function for hybrid scheduler.
 struct hybrid_ls_rr_sort : public queue_sort {
   enum {
-    IsBottomUp = true,
-    HasReadyFilter = false
+    IsBottomUp = 1,
+    HasReadyFilter = 0
   };
 
   RegReductionPQBase *SPQ;
   hybrid_ls_rr_sort(RegReductionPQBase *spq)
     : SPQ(spq) {}
 
   bool isReady(SUnit *SU, unsigned CurCycle) const;
 
   bool operator()(SUnit* left, SUnit* right) const;
 };
 
 // ilp_ls_rr_sort - Priority function for ILP (instruction level parallelism)
 // scheduler.
 struct ilp_ls_rr_sort : public queue_sort {
   enum {
-    IsBottomUp = true,
-    HasReadyFilter = false
+    IsBottomUp = 1,
+    HasReadyFilter = 0
   };
 
   RegReductionPQBase *SPQ;
   ilp_ls_rr_sort(RegReductionPQBase *spq)
     : SPQ(spq) {}
 
   bool isReady(SUnit *SU, unsigned CurCycle) const;
 

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

         "Invalid chain type");
   EVT VT = Val.getValueType();
   SDVTList VTs = getVTList(MVT::Other);
   SDValue Undef = getUNDEF(Ptr.getValueType());
   SDValue Ops[] = { Chain, Val, Ptr, Undef };
   FoldingSetNodeID ID;
   AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
   ID.AddInteger(VT.getRawBits());
-  ID.AddInteger(encodeMemSDNodeFlags(false, ISD::UNINDEXED, MMO->isVolatile(),
+  ID.AddInteger(encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(),
                                      MMO->isNonTemporal(), MMO->isInvariant()));
   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
   void *IP = nullptr;
   if (SDNode *E = FindNodeOrInsertPos(ID, dl, IP)) {
     cast<StoreSDNode>(E)->refineAlignment(MMO);
     return SDValue(E, 0);
   }
   auto *N = newSDNode<StoreSDNode>(dl.getIROrder(), dl.getDebugLoc(), VTs,

          "Cannot use trunc store to change the number of vector elements!");
 
   SDVTList VTs = getVTList(MVT::Other);
   SDValue Undef = getUNDEF(Ptr.getValueType());
   SDValue Ops[] = { Chain, Val, Ptr, Undef };
   FoldingSetNodeID ID;
   AddNodeIDNode(ID, ISD::STORE, VTs, Ops);
   ID.AddInteger(SVT.getRawBits());
-  ID.AddInteger(encodeMemSDNodeFlags(true, ISD::UNINDEXED, MMO->isVolatile(),
+  ID.AddInteger(encodeMemSDNodeFlags(1, ISD::UNINDEXED, MMO->isVolatile(),
                                      MMO->isNonTemporal(), MMO->isInvariant()));
   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
   void *IP = nullptr;
   if (SDNode *E = FindNodeOrInsertPos(ID, dl, IP)) {
     cast<StoreSDNode>(E)->refineAlignment(MMO);
     return SDValue(E, 0);
   }
   auto *N = newSDNode<StoreSDNode>(dl.getIROrder(), dl.getDebugLoc(), VTs,

   assert(Chain.getValueType() == MVT::Other &&
         "Invalid chain type");
   EVT VT = Val.getValueType();
   SDVTList VTs = getVTList(MVT::Other);
   SDValue Ops[] = { Chain, Ptr, Mask, Val };
   FoldingSetNodeID ID;
   AddNodeIDNode(ID, ISD::MSTORE, VTs, Ops);
   ID.AddInteger(VT.getRawBits());
-  ID.AddInteger(encodeMemSDNodeFlags(false, ISD::UNINDEXED, MMO->isVolatile(),
+  ID.AddInteger(encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(),
                                      MMO->isNonTemporal(), MMO->isInvariant()));
   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
   void *IP = nullptr;
   if (SDNode *E = FindNodeOrInsertPos(ID, dl, IP)) {
     cast<MaskedStoreSDNode>(E)->refineAlignment(MMO);
     return SDValue(E, 0);
   }
   auto *N = newSDNode<MaskedStoreSDNode>(dl.getIROrder(), dl.getDebugLoc(), VTs,

 SDValue SelectionDAG::getMaskedScatter(SDVTList VTs, EVT VT, SDLoc dl,
                                        ArrayRef<SDValue> Ops,
                                        MachineMemOperand *MMO) {
   assert(Ops.size() == 5 && "Incompatible number of operands");
 
   FoldingSetNodeID ID;
   AddNodeIDNode(ID, ISD::MSCATTER, VTs, Ops);
   ID.AddInteger(VT.getRawBits());
-  ID.AddInteger(encodeMemSDNodeFlags(false, ISD::UNINDEXED, MMO->isVolatile(),
+  ID.AddInteger(encodeMemSDNodeFlags(0, ISD::UNINDEXED, MMO->isVolatile(),
                                      MMO->isNonTemporal(),
                                      MMO->isInvariant()));
   ID.AddInteger(MMO->getPointerInfo().getAddrSpace());
   void *IP = nullptr;
   if (SDNode *E = FindNodeOrInsertPos(ID, dl, IP)) {
     cast<MaskedScatterSDNode>(E)->refineAlignment(MMO);
     return SDValue(E, 0);
   }

lib/CodeGen/SplitKit.h

private:
   /// SlotIndexes and LiveIntervals.
   RegAssignMap::Allocator Allocator;
 
   /// RegAssign - Map of the assigned register indexes.
   /// Edit.get(RegAssign.lookup(Idx)) is the register that should be live at
   /// Idx.
   RegAssignMap RegAssign;
 
-  typedef PointerIntPair<VNInfo*, 1> ValueForcePair;
+  typedef PointerIntPair<VNInfo*, 1, bool> ValueForcePair;
   typedef DenseMap<std::pair<unsigned, unsigned>, ValueForcePair> ValueMap;
 
   /// Values - keep track of the mapping from parent values to values in the new
   /// intervals. Given a pair (RegIdx, ParentVNI->id), Values contains:
   ///
   /// 1. No entry - the value is not mapped to Edit.get(RegIdx).
   /// 2. (Null, false) - the value is mapped to multiple values in
   ///    Edit.get(RegIdx).  Each value is represented by a minimal live range at

lib/ExecutionEngine/Interpreter/Execution.cpp

switch (Ty->getTypeID()) {
     IMPLEMENT_VECTOR_FCMP(!=);
     default:
       dbgs() << "Unhandled type for FCmp NE instruction: " << *Ty << "\n";
       llvm_unreachable(nullptr);
   }
   // in vector case mask out NaN elements
   if (Ty->isVectorTy())
     for( size_t _i=0; _i<Src1.AggregateVal.size(); _i++)
-      if (DestMask.AggregateVal[_i].IntVal == false)
-        Dest.AggregateVal[_i].IntVal = APInt(1,false);
+      if (DestMask.AggregateVal[_i].IntVal == 0)
+        Dest.AggregateVal[_i].IntVal = APInt(1,0);
 
   return Dest;
 }
 
 static GenericValue executeFCMP_OLE(GenericValue Src1, GenericValue Src2,
                                    Type *Ty) {
   GenericValue Dest;
   switch (Ty->getTypeID()) {

lib/IR/Core.cpp

 void LLVMSetTarget(LLVMModuleRef M, const char *Triple) {
   unwrap(M)->setTargetTriple(Triple);
 }
 
 void LLVMDumpModule(LLVMModuleRef M) {
   unwrap(M)->dump();
 }
 
-LLVMBool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
+bool LLVMPrintModuleToFile(LLVMModuleRef M, const char *Filename,
                                char **ErrorMessage) {
   std::error_code EC;
   raw_fd_ostream dest(Filename, EC, sys::fs::F_Text);
   if (EC) {
     *ErrorMessage = strdup(EC.message().c_str());
     return true;
   }
 
   unwrap(M)->print(dest, nullptr);
 
   dest.close();
 
   if (dest.has_error()) {
     *ErrorMessage = strdup("Error printing to file");
LLVMTypeKind LLVMGetTypeKind(LLVMTypeRef Ty) {
   case Type::X86_MMXTyID:
     return LLVMX86_MMXTypeKind;
   case Type::TokenTyID:
     return LLVMTokenTypeKind;
   }
   llvm_unreachable("Unhandled TypeID.");
 }
 
-LLVMBool LLVMTypeIsSized(LLVMTypeRef Ty)
+bool LLVMTypeIsSized(LLVMTypeRef Ty)
 {
     return unwrap(Ty)->isSized();
 }
 
 LLVMContextRef LLVMGetTypeContext(LLVMTypeRef Ty) {
   return wrap(&unwrap(Ty)->getContext());
 }
 

 
 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
                              LLVMBool IsVarArg) {
   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
   return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
 }
 
-LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
+bool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
   return unwrap<FunctionType>(FunctionTy)->isVarArg();
 }
 
 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) {
   return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
 }
 
 unsigned LLVMCountParamTypes(LLVMTypeRef FunctionTy) {
for (StructType::element_iterator I = Ty->element_begin(),
     *Dest++ = wrap(*I);
 }
 
 LLVMTypeRef LLVMStructGetTypeAtIndex(LLVMTypeRef StructTy, unsigned i) {
   StructType *Ty = unwrap<StructType>(StructTy);
   return wrap(Ty->getTypeAtIndex(i));
 }
 
-LLVMBool LLVMIsPackedStruct(LLVMTypeRef StructTy) {
+bool LLVMIsPackedStruct(LLVMTypeRef StructTy) {
   return unwrap<StructType>(StructTy)->isPacked();
 }
 
-LLVMBool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) {
+bool LLVMIsOpaqueStruct(LLVMTypeRef StructTy) {
   return unwrap<StructType>(StructTy)->isOpaque();
 }
 
 LLVMTypeRef LLVMGetTypeByName(LLVMModuleRef M, const char *Name) {
   return wrap(unwrap(M)->getTypeByName(Name));
 }
 
 /*--.. Operations on array, pointer, and vector types (sequence types) .....--*/
char* LLVMPrintValueToString(LLVMValueRef Val) {
 
   return strdup(buf.c_str());
 }
 
 void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) {
   unwrap(OldVal)->replaceAllUsesWith(unwrap(NewVal));
 }
 
-int LLVMHasMetadata(LLVMValueRef Inst) {
+bool LLVMHasMetadata(LLVMValueRef Inst) {
   return unwrap<Instruction>(Inst)->hasMetadata();
 }
 
 LLVMValueRef LLVMGetMetadata(LLVMValueRef Inst, unsigned KindID) {
   auto *I = unwrap<Instruction>(Inst);
   assert(I && "Expected instruction");
   if (auto *MD = I->getMetadata(KindID))
     return wrap(MetadataAsValue::get(I->getContext(), MD));

 LLVMValueRef LLVMConstAllOnes(LLVMTypeRef Ty) {
   return wrap(Constant::getAllOnesValue(unwrap(Ty)));
 }
 
 LLVMValueRef LLVMGetUndef(LLVMTypeRef Ty) {
   return wrap(UndefValue::get(unwrap(Ty)));
 }
 
-LLVMBool LLVMIsConstant(LLVMValueRef Ty) {
+bool LLVMIsConstant(LLVMValueRef Ty) {
   return isa<Constant>(unwrap(Ty));
 }
 
-LLVMBool LLVMIsNull(LLVMValueRef Val) {
+bool LLVMIsNull(LLVMValueRef Val) {
   if (Constant *C = dyn_cast<Constant>(unwrap(Val)))
     return C->isNullValue();
   return false;
 }
 
-LLVMBool LLVMIsUndef(LLVMValueRef Val) {
+bool LLVMIsUndef(LLVMValueRef Val) {
   return isa<UndefValue>(unwrap(Val));
 }
 
 LLVMValueRef LLVMConstPointerNull(LLVMTypeRef Ty) {
   return wrap(ConstantPointerNull::get(unwrap<PointerType>(Ty)));
 }
 
 /*--.. Operations on metadata nodes ........................................--*/
long long LLVMConstIntGetSExtValue(LLVMValueRef ConstantVal) {
   return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
 }
 
 double LLVMConstRealGetDouble(LLVMValueRef ConstantVal, LLVMBool *LosesInfo) {
   ConstantFP *cFP = unwrap<ConstantFP>(ConstantVal) ;
   Type *Ty = cFP->getType();
 
   if (Ty->isFloatTy()) {
-    *LosesInfo = false;
+    *LosesInfo = 0;
     return cFP->getValueAPF().convertToFloat();
   }
 
   if (Ty->isDoubleTy()) {
-    *LosesInfo = false;
+    *LosesInfo = 0;
     return cFP->getValueAPF().convertToDouble();
   }
 
   bool APFLosesInfo;
   APFloat APF = cFP->getValueAPF();
   APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &APFLosesInfo);
   *LosesInfo = APFLosesInfo;
   return APF.convertToDouble();
LLVMValueRef LLVMConstString(const char *Str, unsigned Length,
   return LLVMConstStringInContext(LLVMGetGlobalContext(), Str, Length,
                                   DontNullTerminate);
 }
 
 LLVMValueRef LLVMGetElementAsConstant(LLVMValueRef C, unsigned idx) {
   return wrap(unwrap<ConstantDataSequential>(C)->getElementAsConstant(idx));
 }
 
-LLVMBool LLVMIsConstantString(LLVMValueRef C) {
+bool LLVMIsConstantString(LLVMValueRef C) {
   return unwrap<ConstantDataSequential>(C)->isString();
 }
 
 const char *LLVMGetAsString(LLVMValueRef C, size_t *Length) {
   StringRef Str = unwrap<ConstantDataSequential>(C)->getAsString();
   *Length = Str.size();
   return Str.data();
 }

 }
 
 /*--.. Operations on global variables, functions, and aliases (globals) ....--*/
 
 LLVMModuleRef LLVMGetGlobalParent(LLVMValueRef Global) {
   return wrap(unwrap<GlobalValue>(Global)->getParent());
 }
 
-LLVMBool LLVMIsDeclaration(LLVMValueRef Global) {
+bool LLVMIsDeclaration(LLVMValueRef Global) {
   return unwrap<GlobalValue>(Global)->isDeclaration();
 }
 
 LLVMLinkage LLVMGetLinkage(LLVMValueRef Global) {
   switch (unwrap<GlobalValue>(Global)->getLinkage()) {
   case GlobalValue::ExternalLinkage:
     return LLVMExternalLinkage;
   case GlobalValue::AvailableExternallyLinkage:
return static_cast<LLVMDLLStorageClass>(
       unwrap<GlobalValue>(Global)->getDLLStorageClass());
 }
 
 void LLVMSetDLLStorageClass(LLVMValueRef Global, LLVMDLLStorageClass Class) {
   unwrap<GlobalValue>(Global)->setDLLStorageClass(
       static_cast<GlobalValue::DLLStorageClassTypes>(Class));
 }
 
-LLVMBool LLVMHasUnnamedAddr(LLVMValueRef Global) {
+bool LLVMHasUnnamedAddr(LLVMValueRef Global) {
   return unwrap<GlobalValue>(Global)->hasUnnamedAddr();
 }
 
 void LLVMSetUnnamedAddr(LLVMValueRef Global, LLVMBool HasUnnamedAddr) {
   unwrap<GlobalValue>(Global)->setUnnamedAddr(HasUnnamedAddr);
 }
 
 /*--.. Operations on global variables, load and store instructions .........--*/
LLVMValueRef LLVMGetInitializer(LLVMValueRef GlobalVar) {
   return wrap(GV->getInitializer());
 }
 
 void LLVMSetInitializer(LLVMValueRef GlobalVar, LLVMValueRef ConstantVal) {
   unwrap<GlobalVariable>(GlobalVar)
     ->setInitializer(unwrap<Constant>(ConstantVal));
 }
 
-LLVMBool LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
+bool LLVMIsThreadLocal(LLVMValueRef GlobalVar) {
   return unwrap<GlobalVariable>(GlobalVar)->isThreadLocal();
 }
 
 void LLVMSetThreadLocal(LLVMValueRef GlobalVar, LLVMBool IsThreadLocal) {
   unwrap<GlobalVariable>(GlobalVar)->setThreadLocal(IsThreadLocal != 0);
 }
 
-LLVMBool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) {
+bool LLVMIsGlobalConstant(LLVMValueRef GlobalVar) {
   return unwrap<GlobalVariable>(GlobalVar)->isConstant();
 }
 
 void LLVMSetGlobalConstant(LLVMValueRef GlobalVar, LLVMBool IsConstant) {
   unwrap<GlobalVariable>(GlobalVar)->setConstant(IsConstant != 0);
 }
 
 LLVMThreadLocalMode LLVMGetThreadLocalMode(LLVMValueRef GlobalVar) {
case LLVMInitialExecTLSModel:
     GV->setThreadLocalMode(GlobalVariable::InitialExecTLSModel);
     break;
   case LLVMLocalExecTLSModel:
     GV->setThreadLocalMode(GlobalVariable::LocalExecTLSModel);
     break;
   }
 }
 
-LLVMBool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar) {
+bool LLVMIsExternallyInitialized(LLVMValueRef GlobalVar) {
   return unwrap<GlobalVariable>(GlobalVar)->isExternallyInitialized();
 }
 
 void LLVMSetExternallyInitialized(LLVMValueRef GlobalVar, LLVMBool IsExtInit) {
   unwrap<GlobalVariable>(GlobalVar)->setExternallyInitialized(IsExtInit);
 }
 
 /*--.. Operations on aliases ......................................--*/
if (I == Func->getParent()->begin())
     return nullptr;
   return wrap(&*--I);
 }
 
 void LLVMDeleteFunction(LLVMValueRef Fn) {
   unwrap<Function>(Fn)->eraseFromParent();
 }
 
-LLVMBool LLVMHasPersonalityFn(LLVMValueRef Fn) {
+bool LLVMHasPersonalityFn(LLVMValueRef Fn) {
   return unwrap<Function>(Fn)->hasPersonalityFn();
 }
 
 LLVMValueRef LLVMGetPersonalityFn(LLVMValueRef Fn) {
   return wrap(unwrap<Function>(Fn)->getPersonalityFn());
 }
 
 void LLVMSetPersonalityFn(LLVMValueRef Fn, LLVMValueRef PersonalityFn) {

 }
 
 /*--.. Operations on basic blocks ..........................................--*/
 
 LLVMValueRef LLVMBasicBlockAsValue(LLVMBasicBlockRef BB) {
   return wrap(static_cast<Value*>(unwrap(BB)));
 }
 
-LLVMBool LLVMValueIsBasicBlock(LLVMValueRef Val) {
+bool LLVMValueIsBasicBlock(LLVMValueRef Val) {
   return isa<BasicBlock>(unwrap(Val));
 }
 
 LLVMBasicBlockRef LLVMValueAsBasicBlock(LLVMValueRef Val) {
   return wrap(unwrap<BasicBlock>(Val));
 }
 
 const char *LLVMGetBasicBlockName(LLVMBasicBlockRef BB) {

 }
 
 LLVMValueRef LLVMGetCalledValue(LLVMValueRef Instr) {
   return wrap(CallSite(unwrap<Instruction>(Instr)).getCalledValue());
 }
 
 /*--.. Operations on call instructions (only) ..............................--*/
 
-LLVMBool LLVMIsTailCall(LLVMValueRef Call) {
+bool LLVMIsTailCall(LLVMValueRef Call) {
   return unwrap<CallInst>(Call)->isTailCall();
 }
 
 void LLVMSetTailCall(LLVMValueRef Call, LLVMBool isTailCall) {
   unwrap<CallInst>(Call)->setTailCall(isTailCall);
 }
 
 /*--.. Operations on invoke instructions (only) ............................--*/

 }
 
 void LLVMSetSuccessor(LLVMValueRef Term, unsigned i, LLVMBasicBlockRef block) {
   return unwrap<TerminatorInst>(Term)->setSuccessor(i,unwrap(block));
 }
 
 /*--.. Operations on branch instructions (only) ............................--*/
 
-LLVMBool LLVMIsConditional(LLVMValueRef Branch) {
+bool LLVMIsConditional(LLVMValueRef Branch) {
   return unwrap<BranchInst>(Branch)->isConditional();
 }
 
 LLVMValueRef LLVMGetCondition(LLVMValueRef Branch) {
   return wrap(unwrap<BranchInst>(Branch)->getCondition());
 }
 
 void LLVMSetCondition(LLVMValueRef Branch, LLVMValueRef Cond) {

 /*--.. Operations on alloca instructions (only) ............................--*/
 
 LLVMTypeRef LLVMGetAllocatedType(LLVMValueRef Alloca) {
   return wrap(unwrap<AllocaInst>(Alloca)->getAllocatedType());
 }
 
 /*--.. Operations on gep instructions (only) ...............................--*/
 
-LLVMBool LLVMIsInBounds(LLVMValueRef GEP) {
+bool LLVMIsInBounds(LLVMValueRef GEP) {
   return unwrap<GetElementPtrInst>(GEP)->isInBounds();
 }
 
 void LLVMSetIsInBounds(LLVMValueRef GEP, LLVMBool InBounds) {
   return unwrap<GetElementPtrInst>(GEP)->setIsInBounds(InBounds);
 }
 
 /*--.. Operations on phi nodes .............................................--*/
LLVMValueRef LLVMGetClause(LLVMValueRef LandingPad, unsigned Idx) {
   return wrap(unwrap<LandingPadInst>(LandingPad)->getClause(Idx));
 }
 
 void LLVMAddClause(LLVMValueRef LandingPad, LLVMValueRef ClauseVal) {
   unwrap<LandingPadInst>(LandingPad)->
     addClause(cast<Constant>(unwrap(ClauseVal)));
 }
 
-LLVMBool LLVMIsCleanup(LLVMValueRef LandingPad) {
+bool LLVMIsCleanup(LLVMValueRef LandingPad) {
   return unwrap<LandingPadInst>(LandingPad)->isCleanup();
 }
 
 void LLVMSetCleanup(LLVMValueRef LandingPad, LLVMBool Val) {
   unwrap<LandingPadInst>(LandingPad)->setCleanup(Val);
 }
 
 /*--.. Arithmetic ..........................................................--*/
LLVMValueRef LLVMBuildGlobalString(LLVMBuilderRef B, const char *Str,
   return wrap(unwrap(B)->CreateGlobalString(Str, Name));
 }
 
 LLVMValueRef LLVMBuildGlobalStringPtr(LLVMBuilderRef B, const char *Str,
                                       const char *Name) {
   return wrap(unwrap(B)->CreateGlobalStringPtr(Str, Name));
 }
 
-LLVMBool LLVMGetVolatile(LLVMValueRef MemAccessInst) {
+bool LLVMGetVolatile(LLVMValueRef MemAccessInst) {
   Value *P = unwrap<Value>(MemAccessInst);
   if (LoadInst *LI = dyn_cast<LoadInst>(P))
     return LI->isVolatile();
   return cast<StoreInst>(P)->isVolatile();
 }
 
 void LLVMSetVolatile(LLVMValueRef MemAccessInst, LLVMBool isVolatile) {
   Value *P = unwrap<Value>(MemAccessInst);
LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Ptr,
 
   return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(Ptr), unwrap(Cmp),
                 unwrap(New), mapFromLLVMOrdering(SuccessOrdering),
                 mapFromLLVMOrdering(FailureOrdering),
                 singleThread ? SingleThread : CrossThread));
 }
 
 
-LLVMBool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
+bool LLVMIsAtomicSingleThread(LLVMValueRef AtomicInst) {
   Value *P = unwrap<Value>(AtomicInst);
 
   if (AtomicRMWInst *I = dyn_cast<AtomicRMWInst>(P))
     return I->getSynchScope() == SingleThread;
   return cast<AtomicCmpXchgInst>(P)->getSynchScope() == SingleThread;
 }
 
 void LLVMSetAtomicSingleThread(LLVMValueRef AtomicInst, LLVMBool NewValue) {
LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) {
   return wrap(new legacy::FunctionPassManager(unwrap(M)));
 }
 
 LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) {
   return LLVMCreateFunctionPassManagerForModule(
                                             reinterpret_cast<LLVMModuleRef>(P));
 }
 
-LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) {
+bool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) {
   return unwrap<legacy::PassManager>(PM)->run(*unwrap(M));
 }
 
-LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) {
+bool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) {
   return unwrap<legacy::FunctionPassManager>(FPM)->doInitialization();
 }
 
-LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) {
+bool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) {
   return unwrap<legacy::FunctionPassManager>(FPM)->run(*unwrap<Function>(F));
 }
 
-LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) {
+bool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) {
   return unwrap<legacy::FunctionPassManager>(FPM)->doFinalization();
 }
 
 void LLVMDisposePassManager(LLVMPassManagerRef PM) {
   delete unwrap(PM);
 }
 
 /*===-- Threading ------------------------------------------------------===*/
 
 LLVMBool LLVMStartMultithreaded() {
   return LLVMIsMultithreaded();
 }
 
 void LLVMStopMultithreaded() {
 }
 
-LLVMBool LLVMIsMultithreaded() {
+bool LLVMIsMultithreaded() {
   return llvm_is_multithreaded();
 }

lib/Lex/PPMacroExpansion.cpp

                                            diag::err_feature_check_malformed);
         return II && HasExtension(*this, II->getName());
       });
   } else if (II == Ident__has_builtin) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         if (!II)
           return false;
         else if (II->getBuiltinID() != 0)
           return true;
         else {
           const LangOptions &LangOpts = getLangOpts();
           return llvm::StringSwitch<bool>(II->getName())
                       .Case("__make_integer_seq", LangOpts.CPlusPlus)
                       .Default(false);

       });
   } else if (II == Ident__has_cpp_attribute) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *ScopeII = nullptr;
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         if (!II)
-          return false;
+          return 0;
 
         // It is possible to receive a scope token.  Read the "::", if it is
         // available, and the subsequent identifier.
         LexUnexpandedToken(Tok);
         if (Tok.isNot(tok::coloncolon))
           HasLexedNextToken = true;
         else {
           ScopeII = II;

     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         std::string WarningName;
         SourceLocation StrStartLoc = Tok.getLocation();
 
         HasLexedNextToken = Tok.is(tok::string_literal);
         if (!FinishLexStringLiteral(Tok, WarningName, "'__has_warning'",
                                     /*MacroExpansion=*/false))
-          return false;
+          return 0;
 
         // FIXME: Should we accept "-R..." flags here, or should that be
         // handled by a separate __has_remark?
         if (WarningName.size() < 3 || WarningName[0] != '-' ||
             WarningName[1] != 'W') {
           Diag(StrStartLoc, diag::warn_has_warning_invalid_option);
-          return false;
+          return 0;
         }
 
         // Finally, check if the warning flags maps to a diagnostic group.
         // We construct a SmallVector here to talk to getDiagnosticIDs().
         // Although we don't use the result, this isn't a hot path, and not
         // worth special casing.
         SmallVector<diag::kind, 10> Diags;
         return !getDiagnostics().getDiagnosticIDs()->

lib/MC/MCContext.cpp

MCSectionELF *MCContext::createELFRelSection(StringRef Name, unsigned Type,
                                              const MCSymbolELF *Group,
                                              const MCSectionELF *Associated) {
   StringMap<bool>::iterator I;
   bool Inserted;
   std::tie(I, Inserted) = ELFRelSecNames.insert(std::make_pair(Name, true));
 
   return new (ELFAllocator.Allocate())
       MCSectionELF(I->getKey(), Type, Flags, SectionKind::getReadOnly(),
-                   EntrySize, Group, true, nullptr, Associated);
+                   EntrySize, Group, 1, nullptr, Associated);
 }
 
 MCSectionELF *MCContext::getELFSection(StringRef Section, unsigned Type,
                                        unsigned Flags, unsigned EntrySize,
                                        StringRef Group, unsigned UniqueID,
                                        const char *BeginSymName) {
   MCSymbolELF *GroupSym = nullptr;
   if (!Group.empty())

lib/MC/MCDisassembler/Disassembler.cpp

size_t LLVMDisasmInstruction(LLVMDisasmContextRef DCR, uint8_t *Bytes,
   }
   llvm_unreachable("Invalid DecodeStatus!");
 }
 
 //
 // LLVMSetDisasmOptions() sets the disassembler's options.  It returns 1 if it
 // can set all the Options and 0 otherwise.
 //
-int LLVMSetDisasmOptions(LLVMDisasmContextRef DCR, uint64_t Options){
+bool LLVMSetDisasmOptions(LLVMDisasmContextRef DCR, uint64_t Options){
   if (Options & LLVMDisassembler_Option_UseMarkup){
       LLVMDisasmContext *DC = (LLVMDisasmContext *)DCR;
       MCInstPrinter *IP = DC->getIP();
       IP->setUseMarkup(1);
       DC->addOptions(LLVMDisassembler_Option_UseMarkup);
       Options &= ~LLVMDisassembler_Option_UseMarkup;
   }
   if (Options & LLVMDisassembler_Option_PrintImmHex){

lib/MC/MCDisassembler/MCExternalSymbolizer.cpp

if (IsBranch)
        ReferenceType = LLVMDisassembler_ReferenceType_In_Branch;
     else
        ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
     const char *ReferenceName;
     const char *Name = SymbolLookUp(DisInfo, Value, &ReferenceType, Address,
                                     &ReferenceName);
     if (Name) {
       SymbolicOp.AddSymbol.Name = Name;
-      SymbolicOp.AddSymbol.Present = true;
+      SymbolicOp.AddSymbol.Present = 1;
       // If Name is a C++ symbol name put the human readable name in a comment.
       if(ReferenceType == LLVMDisassembler_ReferenceType_DeMangled_Name)
         cStream << ReferenceName;
     }
     // For branches always create an MCExpr so it gets printed as hex address.
     else if (IsBranch) {
       SymbolicOp.Value = Value;
     }

lib/Object/MachOObjectFile.cpp

 
 unsigned MachOObjectFile::getAnyRelocationAddress(
     const MachO::any_relocation_info &RE) const {
   if (isRelocationScattered(RE))
     return getScatteredRelocationAddress(RE);
   return getPlainRelocationAddress(RE);
 }
 
-unsigned MachOObjectFile::getAnyRelocationPCRel(
+bool MachOObjectFile::getAnyRelocationPCRel(
     const MachO::any_relocation_info &RE) const {
   if (isRelocationScattered(RE))
     return getScatteredRelocationPCRel(this, RE);
   return getPlainRelocationPCRel(this, RE);
 }
 
 unsigned MachOObjectFile::getAnyRelocationLength(
     const MachO::any_relocation_info &RE) const {

lib/Object/Object.cpp

if (std::error_code ec = (*unwrap(SI))->getContents(ret))
     report_fatal_error(ec.message());
   return ret.data();
 }
 
 uint64_t LLVMGetSectionAddress(LLVMSectionIteratorRef SI) {
   return (*unwrap(SI))->getAddress();
 }
 
-LLVMBool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
+bool LLVMGetSectionContainsSymbol(LLVMSectionIteratorRef SI,
                                  LLVMSymbolIteratorRef Sym) {
   return (*unwrap(SI))->containsSymbol(**unwrap(Sym));
 }
 
 // Section Relocation iterators
 LLVMRelocationIteratorRef LLVMGetRelocations(LLVMSectionIteratorRef Section) {
   relocation_iterator SI = (*unwrap(Section))->relocation_begin();
   return wrap(new relocation_iterator(SI));

lib/Sema/Sema.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/Sema/SemaInternal.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclObjC.h"
-#include "clang/AST/Expr.h"
+#include "clang/AST/Expr.h"`
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
for (TentativeDefinitionsType::iterator
     // return value is false.
     if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
       continue;
 
     if (const IncompleteArrayType *ArrayT
         = Context.getAsIncompleteArrayType(VD->getType())) {
       // Set the length of the array to 1 (C99 6.9.2p5).
       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
-      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
+      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), 1);
       QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
                                                 One, ArrayType::Normal, 0);
       VD->setType(T);
     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
                                    diag::err_tentative_def_incomplete_type))
       VD->setInvalidDecl();
 
     CheckCompleteVariableDeclaration(VD);

lib/Sema/SemaChecking.cpp

     const Expr *Ex = getDataArg(argIndex);
     const analyze_printf::ArgType &AT =
       (CS.getKind() == ConversionSpecifier::FreeBSDbArg) ?
         ArgType(S.Context.IntTy) : ArgType::CPointerTy;
     if (AT.isValid() && !AT.matchesType(S.Context, Ex->getType()))
       EmitFormatDiagnostic(
         S.PDiag(diag::warn_format_conversion_argument_type_mismatch)
         << AT.getRepresentativeTypeName(S.Context) << Ex->getType()
-        << false << Ex->getSourceRange(),
+        << 0 << Ex->getSourceRange(),
         Ex->getLocStart(), /*IsStringLocation*/false,
         getSpecifierRange(startSpecifier, specifierLen));
 
     // Type check the second argument (char * for both %b and %D)
     Ex = getDataArg(argIndex + 1);
     const analyze_printf::ArgType &AT2 = ArgType::CStrTy;
     if (AT2.isValid() && !AT2.matchesType(S.Context, Ex->getType()))
       EmitFormatDiagnostic(
         S.PDiag(diag::warn_format_conversion_argument_type_mismatch)
         << AT2.getRepresentativeTypeName(S.Context) << Ex->getType()
-        << false << Ex->getSourceRange(),
+        << 0 << Ex->getSourceRange(),
         Ex->getLocStart(), /*IsStringLocation*/false,
         getSpecifierRange(startSpecifier, specifierLen));
 
      return true;
   }
 
   // Check for using an Objective-C specific conversion specifier
   // in a non-ObjC literal.

   if (success) {
     // Get the fix string from the fixed format specifier.
     SmallString<128> buf;
     llvm::raw_svector_ostream os(buf);
     fixedFS.toString(os);
 
     EmitFormatDiagnostic(
         S.PDiag(diag) << AT.getRepresentativeTypeName(S.Context)
-                      << Ex->getType() << false << Ex->getSourceRange(),
+                      << Ex->getType() << 0 << Ex->getSourceRange(),
         Ex->getLocStart(),
         /*IsStringLocation*/ false,
         getSpecifierRange(startSpecifier, specifierLen),
         FixItHint::CreateReplacement(
             getSpecifierRange(startSpecifier, specifierLen), os.str()));
   } else {
     EmitFormatDiagnostic(S.PDiag(diag)
                              << AT.getRepresentativeTypeName(S.Context)
-                             << Ex->getType() << false << Ex->getSourceRange(),
+                             << Ex->getType() << 0 << Ex->getSourceRange(),
                          Ex->getLocStart(),
                          /*IsStringLocation*/ false,
                          getSpecifierRange(startSpecifier, specifierLen));
   }
 
   return true;
 }
 

lib/Sema/SemaDecl.cpp

 
     // Special cases for arrays:
     //   - if it's const, use __unsafe_unretained
     //   - otherwise, it's an error
     if (T->isArrayType()) {
       if (!T.isConstQualified()) {
         DelayedDiagnostics.add(
             sema::DelayedDiagnostic::makeForbiddenType(
-            NameLoc, diag::err_arc_array_param_no_ownership, T, false));
+            NameLoc, diag::err_arc_array_param_no_ownership, T, 0));
       }
       lifetime = Qualifiers::OCL_ExplicitNone;
     } else {
       lifetime = T->getObjCARCImplicitLifetime();
     }
     T = Context.getLifetimeQualifiedType(T, lifetime);
   }
 

lib/Sema/SemaDeclAttr.cpp

   if (NumParams == 2 &&
       (!getFunctionOrMethodParamType(D, 1)->isUnsignedIntegerType() ||
        S.Context.getTypeSize(getFunctionOrMethodParamType(D, 1)) != TypeSize)) {
     S.Diag(getFunctionOrMethodParamRange(D, 1).getBegin(),
            diag::err_anyx86_interrupt_attribute)
         << (S.Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86
                 ? 0
                 : 1)
-        << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/false);
+        << 3 << S.Context.getIntTypeForBitwidth(TypeSize, /*Signed=*/0);
     return;
   }
   D->addAttr(::new (S.Context) AnyX86InterruptAttr(
       Attr.getLoc(), S.Context, Attr.getAttributeSpellingListIndex()));
   D->addAttr(UsedAttr::CreateImplicit(S.Context));
 }
 
 static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &Attr) {

lib/Sema/SemaDeclCXX.cpp

                llvm::make_unique<MemInitializerValidatorCCC>(ClassDecl),
                CTK_ErrorRecovery, ClassDecl))) {
         if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {
           // We have found a non-static data member with a similar
           // name to what was typed; complain and initialize that
           // member.
           diagnoseTypo(Corr,
                        PDiag(diag::err_mem_init_not_member_or_class_suggest)
-                         << MemberOrBase << true);
+                         << MemberOrBase << 1);
           return BuildMemberInitializer(Member, Init, IdLoc);
         } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {
           const CXXBaseSpecifier *DirectBaseSpec;
           const CXXBaseSpecifier *VirtualBaseSpec;
           if (FindBaseInitializer(*this, ClassDecl, 
                                   Context.getTypeDeclType(Type),
                                   DirectBaseSpec, VirtualBaseSpec)) {
             // We have found a direct or virtual base class with a
             // similar name to what was typed; complain and initialize
             // that base class.
             diagnoseTypo(Corr,
                          PDiag(diag::err_mem_init_not_member_or_class_suggest)
-                           << MemberOrBase << false,
+                           << MemberOrBase << 0,
                          PDiag() /*Suppress note, we provide our own.*/);
 
             const CXXBaseSpecifier *BaseSpec = DirectBaseSpec ? DirectBaseSpec
                                                               : VirtualBaseSpec;
             Diag(BaseSpec->getLocStart(),
                  diag::note_base_class_specified_here)
               << BaseSpec->getType()
               << BaseSpec->getSourceRange();

lib/Sema/SemaDeclObjC.cpp

         ++numTypeDeclsResolved;
         continue;
       }
 
       // Did we find an Objective-C class?
       if (auto objcClass = corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
         diagnoseTypo(corrected,
                      PDiag(diag::err_unknown_type_or_class_name_suggest)
-                       << identifiers[i] << true);
+                       << identifiers[i] << 1);
         lookupKind = LookupOrdinaryName;
         typeDecls[i] = objcClass;
         ++numTypeDeclsResolved;
         continue;
       }
     }
 
     // We couldn't find anything.

lib/Sema/SemaOpenMP.cpp

     if (!Update.isUsable())
       return ExprError();
 
     if (!SemaRef.Context.hasSameType(Update.get()->getType(),
                                      VarRef.get()->getType())) {
       Update = SemaRef.PerformImplicitConversion(
           Update.get(), VarRef.get()->getType(), Sema::AA_Converting, true);
       if (!Update.isUsable())
         return ExprError();
     }
 
     Update = SemaRef.BuildBinOp(S, Loc, BO_Assign, VarRef.get(), Update.get());
   }
   return Update;
 }
 
 /// \brief Convert integer expression \a E to make it have at least \a Bits
 /// bits.
 static ExprResult WidenIterationCount(unsigned Bits, Expr *E,
                                       Sema &SemaRef) {
   if (E == nullptr)
     return ExprError();
   auto &C = SemaRef.Context;
   QualType OldType = E->getType();
   unsigned HasBits = C.getTypeSize(OldType);
   if (HasBits >= Bits)
     return ExprResult(E);
   // OK to convert to signed, because new type has more bits than old.
-  QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ true);
+  QualType NewType = C.getIntTypeForBitwidth(Bits, /* Signed */ 1);
   return SemaRef.PerformImplicitConversion(E, NewType, Sema::AA_Converting,
                                            true);
 }
 
 /// \brief Check if the given expression \a E is a constant integer that fits
 /// into \a Bits bits.
 static bool FitsInto(unsigned Bits, bool Signed, Expr *E, Sema &SemaRef) {
   if (E == nullptr)

     VarDecl *UBDecl = buildVarDecl(SemaRef, InitLoc, VType, ".omp.ub");
     UB = buildDeclRefExpr(SemaRef, UBDecl, VType, InitLoc);
     SemaRef.AddInitializerToDecl(UBDecl, LastIteration.get(),
                                  /*DirectInit*/ false,
                                  /*TypeMayContainAuto*/ false);
 
     // A 32-bit variable-flag where runtime returns 1 for the last iteration.
     // This will be used to implement clause 'lastprivate'.
-    QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, true);
+    QualType Int32Ty = SemaRef.Context.getIntTypeForBitwidth(32, 1);
     VarDecl *ILDecl = buildVarDecl(SemaRef, InitLoc, Int32Ty, ".omp.is_last");
     IL = buildDeclRefExpr(SemaRef, ILDecl, Int32Ty, InitLoc);
     SemaRef.AddInitializerToDecl(
         ILDecl, SemaRef.ActOnIntegerConstant(InitLoc, 0).get(),
         /*DirectInit*/ false, /*TypeMayContainAuto*/ false);
 
     // Stride variable returned by runtime (we initialize it to 1 by default).
     VarDecl *STDecl =

lib/Serialization/ASTReader.cpp

 
   case TYPE_UNARY_TRANSFORM: {
     QualType BaseType = readType(*Loc.F, Record, Idx);
     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
     UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
     return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
   }
 
   case TYPE_AUTO: {
     QualType Deduced = readType(*Loc.F, Record, Idx);
     AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
-    bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
+    bool IsDependent = Deduced.isNull() ? Record[Idx++] : 0;
     return Context.getAutoType(Deduced, Keyword, IsDependent);
   }
 
   case TYPE_RECORD: {
     if (Record.size() != 2) {
       Error("incorrect encoding of record type");
       return QualType();
     }

lib/Serialization/ASTWriter.cpp

           Record.push_back(Spec->getTemplateSpecializationKind());
           Record.AddSourceLocation(Spec->getPointOfInstantiation());
 
           // The instantiation might have been resolved to a partial
           // specialization. If so, record which one.
           auto From = Spec->getInstantiatedFrom();
           if (auto PartialSpec =
                 From.dyn_cast<ClassTemplatePartialSpecializationDecl*>()) {
-            Record.push_back(true);
+            Record.push_back(1);
             Record.AddDeclRef(PartialSpec);
             Record.AddTemplateArgumentList(
                 &Spec->getTemplateInstantiationArgs());
           } else {
-            Record.push_back(false);
+            Record.push_back(0);
           }
         }
         Record.push_back(RD->getTagKind());
         Record.AddSourceLocation(RD->getLocation());
         Record.AddSourceLocation(RD->getLocStart());
         Record.AddSourceLocation(RD->getRBraceLoc());
 
         // Instantiation may change attributes; write them all out afresh.

lib/Support/APInt.cpp

   for (i = 0; i < parts; i++)
     if (src[i])
       return false;
 
   return true;
 }
 
 /* Extract the given bit of a bignum; returns 0 or 1.  */
-int
+bool
 APInt::tcExtractBit(const integerPart *parts, unsigned int bit)
 {
   return (parts[bit / integerPartWidth] &
           ((integerPart) 1 << bit % integerPartWidth)) != 0;
 }
 
 /* Set the given bit of a bignum. */
 void

    set REMAINDER to the remainder, return zero.  i.e.
 
    OLD_LHS = RHS * LHS + REMAINDER
 
    SCRATCH is a bignum of the same size as the operands and result for
    use by the routine; its contents need not be initialized and are
    destroyed.  LHS, REMAINDER and SCRATCH must be distinct.
 */
-int
+bool
 APInt::tcDivide(integerPart *lhs, const integerPart *rhs,
                 integerPart *remainder, integerPart *srhs,
                 unsigned int parts)
 {
   unsigned int n, shiftCount;
   integerPart mask;
 
   assert(lhs != remainder && lhs != srhs && remainder != srhs);

       else
         return -1;
     }
 
   return 0;
 }
 
 /* Increment a bignum in-place, return the carry flag.  */
-integerPart
+bool
 APInt::tcIncrement(integerPart *dst, unsigned int parts)
 {
   unsigned int i;
 
   for (i = 0; i < parts; i++)
     if (++dst[i] != 0)
       break;
 

lib/Support/DynamicLibrary.cpp

 }
 
 #endif // LLVM_ON_WIN32
 
 //===----------------------------------------------------------------------===//
 // C API.
 //===----------------------------------------------------------------------===//
 
-LLVMBool LLVMLoadLibraryPermanently(const char* Filename) {
+bool LLVMLoadLibraryPermanently(const char* Filename) {
   return llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename);
 }
 
 void *LLVMSearchForAddressOfSymbol(const char *symbolName) {
   return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(symbolName);
 }
 
 void LLVMAddSymbol(const char *symbolName, void *symbolValue) {
   return llvm::sys::DynamicLibrary::AddSymbol(symbolName, symbolValue);
 }
 

lib/Target/AArch64/AArch64ISelDAGToDAG.cpp

bool AArch64DAGToDAGISel::SelectAddrModeWRO(SDValue N, unsigned Size,
 
   // Remember if it is worth folding N when it produces extended register.
   bool IsExtendedRegisterWorthFolding = isWorthFolding(N);
 
   // Try to match a shifted extend on the RHS.
   if (IsExtendedRegisterWorthFolding && RHS.getOpcode() == ISD::SHL &&
       SelectExtendedSHL(RHS, Size, true, Offset, SignExtend)) {
     Base = LHS;
-    DoShift = CurDAG->getTargetConstant(true, dl, MVT::i32);
+    DoShift = CurDAG->getTargetConstant(1, dl, MVT::i32);
     return true;
   }
 
   // Try to match a shifted extend on the LHS.
   if (IsExtendedRegisterWorthFolding && LHS.getOpcode() == ISD::SHL &&
       SelectExtendedSHL(LHS, Size, true, Offset, SignExtend)) {
     Base = RHS;
-    DoShift = CurDAG->getTargetConstant(true, dl, MVT::i32);
+    DoShift = CurDAG->getTargetConstant(1, dl, MVT::i32);
     return true;
   }
 
   // There was no shift, whatever else we find.
-  DoShift = CurDAG->getTargetConstant(false, dl, MVT::i32);
+  DoShift = CurDAG->getTargetConstant(0, dl, MVT::i32);
 
   AArch64_AM::ShiftExtendType Ext = AArch64_AM::InvalidShiftExtend;
   // Try to match an unshifted extend on the LHS.
   if (IsExtendedRegisterWorthFolding &&
       (Ext = getExtendTypeForNode(LHS, true)) !=
           AArch64_AM::InvalidShiftExtend) {
     Base = RHS;
     Offset = narrowIfNeeded(CurDAG, LHS.getOperand(0));
bool AArch64DAGToDAGISel::SelectAddrModeXRO(SDValue N, unsigned Size,
 
   // Remember if it is worth folding N when it produces extended register.
   bool IsExtendedRegisterWorthFolding = isWorthFolding(N);
 
   // Try to match a shifted extend on the RHS.
   if (IsExtendedRegisterWorthFolding && RHS.getOpcode() == ISD::SHL &&
       SelectExtendedSHL(RHS, Size, false, Offset, SignExtend)) {
     Base = LHS;
-    DoShift = CurDAG->getTargetConstant(true, DL, MVT::i32);
+    DoShift = CurDAG->getTargetConstant(1, DL, MVT::i32);
     return true;
   }
 
   // Try to match a shifted extend on the LHS.
   if (IsExtendedRegisterWorthFolding && LHS.getOpcode() == ISD::SHL &&
       SelectExtendedSHL(LHS, Size, false, Offset, SignExtend)) {
     Base = RHS;
-    DoShift = CurDAG->getTargetConstant(true, DL, MVT::i32);
+    DoShift = CurDAG->getTargetConstant(1, DL, MVT::i32);
     return true;
   }
 
   // Match any non-shifted, non-extend, non-immediate add expression.
   Base = LHS;
   Offset = RHS;
-  SignExtend = CurDAG->getTargetConstant(false, DL, MVT::i32);
-  DoShift = CurDAG->getTargetConstant(false, DL, MVT::i32);
+  SignExtend = CurDAG->getTargetConstant(0, DL, MVT::i32);
+  DoShift = CurDAG->getTargetConstant(0, DL, MVT::i32);
   // Reg1 + Reg2 is free: no check needed.
   return true;
 }
 
 SDValue AArch64DAGToDAGISel::createDTuple(ArrayRef<SDValue> Regs) {
   static const unsigned RegClassIDs[] = {
       AArch64::DDRegClassID, AArch64::DDDRegClassID, AArch64::DDDDRegClassID};
   static const unsigned SubRegs[] = {AArch64::dsub0, AArch64::dsub1,

lib/Target/AArch64/AArch64LoadStoreOptimizer.cpp

static unsigned getMatchingPairOpcode(unsigned Opc) {
   case AArch64::LDURXi:
     return AArch64::LDPXi;
   case AArch64::LDRSWui:
   case AArch64::LDURSWi:
     return AArch64::LDPSWi;
   }
 }
 
-static unsigned isMatchingStore(MachineInstr *LoadInst,
+static bool isMatchingStore(MachineInstr *LoadInst,
                                 MachineInstr *StoreInst) {
   unsigned LdOpc = LoadInst->getOpcode();
   unsigned StOpc = StoreInst->getOpcode();
   switch (LdOpc) {
   default:
     llvm_unreachable("Unsupported load instruction!");
   case AArch64::LDRBBui:
     return StOpc == AArch64::STRBBui || StOpc == AArch64::STRHHui ||

lib/Target/AArch64/Disassembler/AArch64ExternalSymbolizer.cpp

bool AArch64ExternalSymbolizer::tryAddingSymbolicOperand(
   if (!GetOpInfo ||
       !GetOpInfo(DisInfo, Address, 0 /* Offset */, InstSize, 1, &SymbolicOp)) {
     if (IsBranch) {
       ReferenceType = LLVMDisassembler_ReferenceType_In_Branch;
       const char *Name = SymbolLookUp(DisInfo, Address + Value, &ReferenceType,
                                       Address, &ReferenceName);
       if (Name) {
         SymbolicOp.AddSymbol.Name = Name;
-        SymbolicOp.AddSymbol.Present = true;
+        SymbolicOp.AddSymbol.Present = 1;
         SymbolicOp.Value = 0;
       } else {
         SymbolicOp.Value = Address + Value;
       }
       if (ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub)
         CommentStream << "symbol stub for: " << ReferenceName;
       else if (ReferenceType ==
                LLVMDisassembler_ReferenceType_Out_Objc_Message)

lib/Target/AMDGPU/AMDILCFGStructurizer.cpp

 void AMDGPUCFGStructurizer::insertCondBranchBefore(
     MachineBasicBlock::iterator I, int NewOpcode, DebugLoc DL) {
   MachineInstr *OldMI = &(*I);
   MachineBasicBlock *MBB = OldMI->getParent();
   MachineFunction *MF = MBB->getParent();
   MachineInstr *NewMI = MF->CreateMachineInstr(TII->get(NewOpcode), DL);
   MBB->insert(I, NewMI);
   MachineInstrBuilder MIB(*MF, NewMI);
-  MIB.addReg(OldMI->getOperand(1).getReg(), false);
+  MIB.addReg(OldMI->getOperand(1).getReg(), 0);
   SHOWNEWINSTR(NewMI);
   //erase later oldInstr->eraseFromParent();
 }
 
 void AMDGPUCFGStructurizer::insertCondBranchBefore(MachineBasicBlock *blk,
     MachineBasicBlock::iterator I, int NewOpcode, int RegNum,
     DebugLoc DL) {
   MachineFunction *MF = blk->getParent();
   MachineInstr *NewInstr = MF->CreateMachineInstr(TII->get(NewOpcode), DL);
   //insert before
   blk->insert(I, NewInstr);
-  MachineInstrBuilder(*MF, NewInstr).addReg(RegNum, false);
+  MachineInstrBuilder(*MF, NewInstr).addReg(RegNum, 0);
   SHOWNEWINSTR(NewInstr);
 }
 
 void AMDGPUCFGStructurizer::insertCondBranchEnd(MachineBasicBlock *MBB,
     int NewOpcode, int RegNum) {
   MachineFunction *MF = MBB->getParent();
   MachineInstr *NewInstr =
     MF->CreateMachineInstr(TII->get(NewOpcode), DebugLoc());
   MBB->push_back(NewInstr);
-  MachineInstrBuilder(*MF, NewInstr).addReg(RegNum, false);
+  MachineInstrBuilder(*MF, NewInstr).addReg(RegNum, 0);
   SHOWNEWINSTR(NewInstr);
 }
 
 int AMDGPUCFGStructurizer::getBranchNzeroOpcode(int OldOpcode) {
   switch(OldOpcode) {
   case AMDGPU::JUMP_COND:
   case AMDGPU::JUMP: return AMDGPU::IF_PREDICATE_SET;
   case AMDGPU::BRANCH_COND_i32:

lib/Target/AMDGPU/R600InstrInfo.cpp

for (unsigned j = 0; j < 3; j++) {
       const std::pair<int, unsigned> &Src = Srcs[j];
       if (Src.first < 0 || Src.first == 255)
         continue;
       if (Src.first == GET_REG_INDEX(RI.getEncodingValue(AMDGPU::OQAP))) {
         if (Swz[i] != R600InstrInfo::ALU_VEC_012_SCL_210 &&
             Swz[i] != R600InstrInfo::ALU_VEC_021_SCL_122) {
             // The value from output queue A (denoted by register OQAP) can
             // only be fetched during the first cycle.
-            return false;
+            return 0;
         }
         // OQAP does not count towards the normal read port restrictions
         continue;
       }
       if (Vector[Src.second][j] < 0)
         Vector[Src.second][j] = Src.first;
       if (Vector[Src.second][j] != Src.first)
         return i;

lib/Target/AMDGPU/SIMachineScheduler.cpp

void SIScheduleBlockCreator::colorHighLatenciesGroups() {
   else if (NumHighLatencies <= 12)
     GroupSize = 3;
   else
     GroupSize = 4;
 
   for (unsigned i = 0, e = DAGSize; i != e; ++i) {
     SUnit *SU = &DAG->SUnits[i];
     if (DAG->IsHighLatencySU[SU->NodeNum]) {
-      unsigned CompatibleGroup = true;
+      unsigned CompatibleGroup = 1;
       unsigned ProposedColor = Color;
       for (unsigned j : FormingGroup) {
         // TODO: Currently CompatibleGroup will always be false,
         // because the graph enforces the load order. This
         // can be fixed, but as keeping the load order is often
         // good for performance that causes a performance hit (both
         // the default scheduler and this scheduler).
         // When this scheduler determines a good load order,
         // this can be fixed.
         if (!DAG->canAddEdge(SU, &DAG->SUnits[j]) ||
             !DAG->canAddEdge(&DAG->SUnits[j], SU))
-          CompatibleGroup = false;
+          CompatibleGroup = 0;
       }
       if (!CompatibleGroup || ++Count == GroupSize) {
         FormingGroup.clear();
         Color = ++NextReservedID;
         if (!CompatibleGroup) {
           ProposedColor = Color;
           FormingGroup.insert(SU->NodeNum);
         }

lib/Target/ARM/ARMBaseInstrInfo.h

public:
   /// GetInstSize - Returns the size of the specified MachineInstr.
   ///
   virtual unsigned GetInstSizeInBytes(const MachineInstr* MI) const;
 
   unsigned isLoadFromStackSlot(const MachineInstr *MI,
                                int &FrameIndex) const override;
   unsigned isStoreToStackSlot(const MachineInstr *MI,
                               int &FrameIndex) const override;
-  unsigned isLoadFromStackSlotPostFE(const MachineInstr *MI,
+  bool isLoadFromStackSlotPostFE(const MachineInstr *MI,
                                      int &FrameIndex) const override;
-  unsigned isStoreToStackSlotPostFE(const MachineInstr *MI,
+  bool isStoreToStackSlotPostFE(const MachineInstr *MI,
                                     int &FrameIndex) const override;
 
   void copyToCPSR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                   unsigned SrcReg, bool KillSrc,
                   const ARMSubtarget &Subtarget) const;
   void copyFromCPSR(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                     unsigned DestReg, bool KillSrc,
                     const ARMSubtarget &Subtarget) const;

lib/Target/ARM/ARMBaseInstrInfo.cpp

       return MI->getOperand(0).getReg();
     }
     break;
   }
 
   return 0;
 }
 
-unsigned ARMBaseInstrInfo::isStoreToStackSlotPostFE(const MachineInstr *MI,
+bool ARMBaseInstrInfo::isStoreToStackSlotPostFE(const MachineInstr *MI,
                                                     int &FrameIndex) const {
   const MachineMemOperand *Dummy;
   return MI->mayStore() && hasStoreToStackSlot(MI, Dummy, FrameIndex);
 }
 
 void ARMBaseInstrInfo::
 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
                      unsigned DestReg, int FI,

       return MI->getOperand(0).getReg();
     }
     break;
   }
 
   return 0;
 }
 
-unsigned ARMBaseInstrInfo::isLoadFromStackSlotPostFE(const MachineInstr *MI,
+bool ARMBaseInstrInfo::isLoadFromStackSlotPostFE(const MachineInstr *MI,
                                              int &FrameIndex) const {
   const MachineMemOperand *Dummy;
   return MI->mayLoad() && hasLoadFromStackSlot(MI, Dummy, FrameIndex);
 }
 
 /// \brief Expands MEMCPY to either LDMIA/STMIA or LDMIA_UPD/STMID_UPD
 /// depending on whether the result is used.
 void ARMBaseInstrInfo::expandMEMCPY(MachineBasicBlock::iterator MBBI) const {

lib/Target/ARM/ARMConstantIslandPass.cpp

   // shouldn't happen currently.
   assert(!BBIsJumpedOver(CPEBB) && "How did this happen?");
   // FIXME: remove the empty blocks after all the work is done?
 }
 
 /// removeUnusedCPEntries - Remove constant pool entries whose refcounts
 /// are zero.
 bool ARMConstantIslands::removeUnusedCPEntries() {
-  unsigned MadeChange = false;
+  unsigned MadeChange = 0;
   for (unsigned i = 0, e = CPEntries.size(); i != e; ++i) {
       std::vector<CPEntry> &CPEs = CPEntries[i];
       for (unsigned j = 0, ee = CPEs.size(); j != ee; ++j) {
         if (CPEs[j].RefCount == 0 && CPEs[j].CPEMI) {
           removeDeadCPEMI(CPEs[j].CPEMI);
           CPEs[j].CPEMI = nullptr;
-          MadeChange = true;
+          MadeChange = 1;
         }
       }
   }
   return MadeChange;
 }
 
 /// isBBInRange - Returns true if the distance between specific MI and
 /// specific BB can fit in MI's displacement field.

lib/Target/ARM/ARMFastISel.cpp

if (TLI.isFPImmLegal(Val, VT)) {
     }
     unsigned DestReg = createResultReg(TLI.getRegClassFor(VT));
     AddOptionalDefs(BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
                             TII.get(Opc), DestReg).addImm(Imm));
     return DestReg;
   }
 
   // Require VFP2 for loading fp constants.
-  if (!Subtarget->hasVFP2()) return false;
+  if (!Subtarget->hasVFP2()) return 0;
 
   // MachineConstantPool wants an explicit alignment.
   unsigned Align = DL.getPrefTypeAlignment(CFP->getType());
   if (Align == 0) {
     // TODO: Figure out if this is correct.
     Align = DL.getTypeAllocSize(CFP->getType());
   }
   unsigned Idx = MCP.getConstantPoolIndex(cast<Constant>(CFP), Align);

lib/Target/ARM/MCTargetDesc/ARMMCCodeEmitter.cpp

uint32_t getAddrMode5OpValue(const MCInst &MI, unsigned OpIdx,
                                const MCSubtargetInfo &STI) const;
 
   /// getAddrMode5FP16OpValue - Return encoding info for 'reg +/- (imm8 << 1)' operand.
   uint32_t getAddrMode5FP16OpValue(const MCInst &MI, unsigned OpIdx,
                                SmallVectorImpl<MCFixup> &Fixups,
                                const MCSubtargetInfo &STI) const;
 
   /// getCCOutOpValue - Return encoding of the 's' bit.
-  unsigned getCCOutOpValue(const MCInst &MI, unsigned Op,
+  bool getCCOutOpValue(const MCInst &MI, unsigned Op,
                            SmallVectorImpl<MCFixup> &Fixups,
                            const MCSubtargetInfo &STI) const {
     // The operand is either reg0 or CPSR. The 's' bit is encoded as '0' or
     // '1' respectively.
     return MI.getOperand(Op).getReg() == ARM::CPSR;
   }
 
   /// getSOImmOpValue - Return an encoded 12-bit shifted-immediate value.

lib/Target/Hexagon/HexagonOptAddrMode.cpp

bool HexagonOptAddrMode::changeAddAsl(NodeAddr<UseNode *> AddAslUN,
   return true;
 }
 
 bool HexagonOptAddrMode::xformUseMI(MachineInstr *TfrMI, MachineInstr *UseMI,
                                     NodeAddr<UseNode *> UseN,
                                     unsigned UseMOnum) {
   const MachineOperand ImmOp = TfrMI->getOperand(1);
   const MCInstrDesc &MID = UseMI->getDesc();
-  unsigned Changed = false;
+  unsigned Changed = 0;
   if (MID.mayLoad())
     Changed = changeLoad(UseMI, ImmOp, UseMOnum);
   else if (MID.mayStore())
     Changed = changeStore(UseMI, ImmOp, UseMOnum);
   else if (UseMI->getOpcode() == Hexagon::S2_addasl_rrri)
     Changed = changeAddAsl(UseN, UseMI, ImmOp, UseMOnum);
 
   if (Changed)

lib/Target/Hexagon/MCTargetDesc/HexagonMCCompound.cpp

unsigned getCompoundCandidateGroup(MCInst const &MI, bool IsExtended) {
   // "p0=cmp.eq(Rs16,Rt16); if (p0.new) jump:nt #r9:2"
   // "Rd16=#U6 ; jump #r9:2"
   // "Rd16=Rs16 ; jump #r9:2"
   //
   case Hexagon::C2_cmpeq:
   case Hexagon::C2_cmpgt:
   case Hexagon::C2_cmpgtu:
     if (IsExtended)
-      return false;
+      return 0;
     DstReg = MI.getOperand(0).getReg();
     Src1Reg = MI.getOperand(1).getReg();
     Src2Reg = MI.getOperand(2).getReg();
     if ((Hexagon::P0 == DstReg || Hexagon::P1 == DstReg) &&
         HexagonMCInstrInfo::isIntRegForSubInst(Src1Reg) &&
         HexagonMCInstrInfo::isIntRegForSubInst(Src2Reg))
       return HexagonII::HCG_A;
     break;
   case Hexagon::C2_cmpeqi:
   case Hexagon::C2_cmpgti:
   case Hexagon::C2_cmpgtui:
     if (IsExtended)
-      return false;
+      return 0;
     // P0 = cmp.eq(Rs,#u2)
     DstReg = MI.getOperand(0).getReg();
     SrcReg = MI.getOperand(1).getReg();
     if ((Hexagon::P0 == DstReg || Hexagon::P1 == DstReg) &&
         HexagonMCInstrInfo::isIntRegForSubInst(SrcReg) &&
         (HexagonMCInstrInfo::inRange<5>(MI, 2) ||
          HexagonMCInstrInfo::minConstant(MI, 2) == -1))
       return HexagonII::HCG_A;
     break;
   case Hexagon::A2_tfr:
     if (IsExtended)
-      return false;
+      return 0;
     // Rd = Rs
     DstReg = MI.getOperand(0).getReg();
     SrcReg = MI.getOperand(1).getReg();
     if (HexagonMCInstrInfo::isIntRegForSubInst(DstReg) &&
         HexagonMCInstrInfo::isIntRegForSubInst(SrcReg))
       return HexagonII::HCG_A;
     break;
   case Hexagon::A2_tfrsi:
     if (IsExtended)
-      return false;
+      return 0;
     // Rd = #u6
     DstReg = MI.getOperand(0).getReg();
     if (HexagonMCInstrInfo::minConstant(MI, 1) <= 63 &&
         HexagonMCInstrInfo::minConstant(MI, 1) >= 0 &&
         HexagonMCInstrInfo::isIntRegForSubInst(DstReg))
       return HexagonII::HCG_A;
     break;
   case Hexagon::S2_tstbit_i:
     if (IsExtended)
-      return false;
+      return 0;
     DstReg = MI.getOperand(0).getReg();
     Src1Reg = MI.getOperand(1).getReg();
     if ((Hexagon::P0 == DstReg || Hexagon::P1 == DstReg) &&
         HexagonMCInstrInfo::isIntRegForSubInst(Src1Reg) &&
         HexagonMCInstrInfo::minConstant(MI, 2) == 0)
       return HexagonII::HCG_A;
     break;
   // The fact that .new form is used pretty much guarantees

lib/Target/Mips/MipsConstantIslandPass.cpp

   // shouldn't happen currently.
   assert(!BBIsJumpedOver(CPEBB) && "How did this happen?");
   // FIXME: remove the empty blocks after all the work is done?
 }
 
 /// removeUnusedCPEntries - Remove constant pool entries whose refcounts
 /// are zero.
 bool MipsConstantIslands::removeUnusedCPEntries() {
-  unsigned MadeChange = false;
+  unsigned MadeChange = 0;
   for (unsigned i = 0, e = CPEntries.size(); i != e; ++i) {
       std::vector<CPEntry> &CPEs = CPEntries[i];
       for (unsigned j = 0, ee = CPEs.size(); j != ee; ++j) {
         if (CPEs[j].RefCount == 0 && CPEs[j].CPEMI) {
           removeDeadCPEMI(CPEs[j].CPEMI);
           CPEs[j].CPEMI = nullptr;
-          MadeChange = true;
+          MadeChange = 1;
         }
       }
   }
   return MadeChange;
 }
 
 /// isBBInRange - Returns true if the distance between specific MI and
 /// specific BB can fit in MI's displacement field.

lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp

if (Writer->doesSymbolRequireExternRelocation(*A)) {
       FixedValue += Writer->getSectionAddress(&Sec);
     }
     if (IsPCRel)
       FixedValue -= Writer->getSectionAddress(Fragment->getParent());
   }
 
   // struct relocation_info (8 bytes)
   MachO::any_relocation_info MRE;
-  makeRelocationInfo(MRE, FixupOffset, Index, IsPCRel, Log2Size, false, Type);
+  makeRelocationInfo(MRE, FixupOffset, Index, IsPCRel, Log2Size, 0, Type);
   Writer->addRelocation(RelSymbol, Fragment->getParent(), MRE);
 }
 
 MCObjectWriter *llvm::createPPCMachObjectWriter(raw_pwrite_stream &OS,
                                                 bool Is64Bit, uint32_t CPUType,
                                                 uint32_t CPUSubtype) {
   return createMachObjectWriter(
       new PPCMachObjectWriter(Is64Bit, CPUType, CPUSubtype), OS,
       /*IsLittleEndian=*/false);
 }

lib/Target/TargetMachineC.cpp

 const char * LLVMGetTargetName(LLVMTargetRef T) {
   return unwrap(T)->getName();
 }
 
 const char * LLVMGetTargetDescription(LLVMTargetRef T) {
   return unwrap(T)->getShortDescription();
 }
 
-LLVMBool LLVMTargetHasJIT(LLVMTargetRef T) {
+bool LLVMTargetHasJIT(LLVMTargetRef T) {
   return unwrap(T)->hasJIT();
 }
 
-LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T) {
+bool LLVMTargetHasTargetMachine(LLVMTargetRef T) {
   return unwrap(T)->hasTargetMachine();
 }
 
-LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T) {
+bool LLVMTargetHasAsmBackend(LLVMTargetRef T) {
   return unwrap(T)->hasMCAsmBackend();
 }
 
 LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
         const char* Triple, const char* CPU, const char* Features,
         LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
         LLVMCodeModel CodeModel) {
   Optional<Reloc::Model> RM;
void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
                                       LLVMBool VerboseAsm) {
   unwrap(T)->Options.MCOptions.AsmVerbose = VerboseAsm;
 }
 
 LLVMTargetDataRef LLVMCreateTargetDataLayout(LLVMTargetMachineRef T) {
   return wrap(new DataLayout(unwrap(T)->createDataLayout()));
 }
 
-static LLVMBool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
+static bool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
                                       raw_pwrite_stream &OS,
                                       LLVMCodeGenFileType codegen,
                                       char **ErrorMessage) {
   TargetMachine* TM = unwrap(T);
   Module* Mod = unwrap(M);
 
   legacy::PassManager pass;
 
static bool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
   }
 
   pass.run(*Mod);
 
   OS.flush();
   return false;
 }
 
-LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
+bool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
   char* Filename, LLVMCodeGenFileType codegen, char** ErrorMessage) {
   std::error_code EC;
   raw_fd_ostream dest(Filename, EC, sys::fs::F_None);
   if (EC) {
     *ErrorMessage = strdup(EC.message().c_str());
     return true;
   }
   bool Result = LLVMTargetMachineEmit(T, M, dest, codegen, ErrorMessage);
   dest.flush();
   return Result;
 }
 
-LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T,
+bool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T,
   LLVMModuleRef M, LLVMCodeGenFileType codegen, char** ErrorMessage,
   LLVMMemoryBufferRef *OutMemBuf) {
   SmallString<0> CodeString;
   raw_svector_ostream OStream(CodeString);
   bool Result = LLVMTargetMachineEmit(T, M, OStream, codegen, ErrorMessage);
 
   StringRef Data = OStream.str();
   *OutMemBuf =

lib/Target/X86/Disassembler/X86DisassemblerDecoder.cpp

  *
  * @param type        - The opcode type (i.e., how many bytes it has).
  * @param insnContext - The context for the instruction, as returned by
  *                      contextForAttrs.
  * @param opcode      - The last byte of the instruction's opcode, not counting
  *                      ModR/M extensions and escapes.
  * @return            - true if the ModR/M byte is required, false otherwise.
  */
-static int modRMRequired(OpcodeType type,
+static bool modRMRequired(OpcodeType type,
                          InstructionContext insnContext,
                          uint16_t opcode) {
   const struct ContextDecision* decision = nullptr;
 
   switch (type) {
   case ONEBYTE:
     decision = &ONEBYTE_SYM;
     break;

lib/Target/X86/X86FrameLowering.cpp

 
   unsigned UsedReg;
   int EHRegOffset = getFrameIndexReference(MF, FI, UsedReg);
   int EndOffset = -EHRegOffset - EHRegSize;
   FuncInfo.EHRegNodeEndOffset = EndOffset;
 
   if (UsedReg == FramePtr) {
     // ADD $offset, %ebp
-    unsigned ADDri = getADDriOpcode(false, EndOffset);
+    unsigned ADDri = getADDriOpcode(0, EndOffset);
     BuildMI(MBB, MBBI, DL, TII.get(ADDri), FramePtr)
         .addReg(FramePtr)
         .addImm(EndOffset)
         .setMIFlag(MachineInstr::FrameSetup)
         ->getOperand(3)
         .setIsDead();
     assert(EndOffset >= 0 &&
            "end of registration object above normal EBP position!");

lib/Transforms/IPO/MergeFunctions.cpp

 /// is updated. If the symbols are weak, this would be incorrect. If they are
 /// strong, then one will be replaced at all references to the other, and so
 /// direct callsites will now see one or the other symbol, and no update is
 /// necessary. Note that if we were guaranteed unique names, we could just
 /// compare those, but this would not work for stripped bitcodes or for those
 /// few symbols without a name.
 class GlobalNumberState {
   struct Config : ValueMapConfig<GlobalValue*> {
-    enum { FollowRAUW = false };
+    enum { FollowRAUW = 0 };
   };
   // Each GlobalValue is mapped to an identifier. The Config ensures when RAUW
   // occurs, the mapping does not change. Tracking changes is unnecessary, and
   // also problematic for weak symbols (which may be overwritten).
   typedef ValueMap<GlobalValue *, uint64_t, Config> ValueNumberMap;
   ValueNumberMap GlobalNumbers;
   // The next unused serial number to assign to a global.
   uint64_t NextNumber;

lib/Transforms/Scalar/GVN.cpp

   assert(TmpBB);
   LoadBB = TmpBB;
 
   // Check to see how many predecessors have the loaded value fully
   // available.
   MapVector<BasicBlock *, Value *> PredLoads;
   DenseMap<BasicBlock*, char> FullyAvailableBlocks;
   for (const AvailableValueInBlock &AV : ValuesPerBlock)
-    FullyAvailableBlocks[AV.BB] = true;
+    FullyAvailableBlocks[AV.BB] = 1;
   for (BasicBlock *UnavailableBB : UnavailableBlocks)
-    FullyAvailableBlocks[UnavailableBB] = false;
+    FullyAvailableBlocks[UnavailableBB] = 0;
 
   SmallVector<BasicBlock *, 4> CriticalEdgePred;
   for (BasicBlock *Pred : predecessors(LoadBB)) {
     // If any predecessor block is an EH pad that does not allow non-PHI
     // instructions before the terminator, we can't PRE the load.
     if (Pred->getTerminator()->isEHPad()) {
       DEBUG(dbgs()
             << "COULD NOT PRE LOAD BECAUSE OF AN EH PAD PREDECESSOR '"

lib/Transforms/Scalar/LoopInstSimplify.cpp

bool LoopInstSimplify::runOnLoop(Loop *L, LPPassManager &LPM) {
   bool Changed = false;
   bool LocalChanged;
   do {
     LocalChanged = false;
 
     VisitStack.clear();
     Visited.clear();
 
-    VisitStack.push_back(WorklistItem(L->getHeader(), false));
+    VisitStack.push_back(WorklistItem(L->getHeader(), 0));
 
     while (!VisitStack.empty()) {
       WorklistItem Item = VisitStack.pop_back_val();
       BasicBlock *BB = Item.getPointer();
       bool IsSubloopHeader = Item.getInt();
       const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
 
       // Simplify instructions in the current basic block.
while (!VisitStack.empty()) {
            ++SI) {
         BasicBlock *SuccBB = *SI;
         if (!Visited.insert(SuccBB).second)
           continue;
 
         const Loop *SuccLoop = LI->getLoopFor(SuccBB);
         if (SuccLoop && SuccLoop->getHeader() == SuccBB
                      && L->contains(SuccLoop)) {
-          VisitStack.push_back(WorklistItem(SuccBB, true));
+          VisitStack.push_back(WorklistItem(SuccBB, 1));
 
           SmallVector<BasicBlock*, 8> SubLoopExitBlocks;
           SuccLoop->getExitBlocks(SubLoopExitBlocks);
 
           for (unsigned i = 0; i < SubLoopExitBlocks.size(); ++i) {
             BasicBlock *ExitBB = SubLoopExitBlocks[i];
             if (LI->getLoopFor(ExitBB) == L && Visited.insert(ExitBB).second)
-              VisitStack.push_back(WorklistItem(ExitBB, false));
+              VisitStack.push_back(WorklistItem(ExitBB, 0));
           }
 
           continue;
         }
 
         bool IsExitBlock = std::binary_search(ExitBlocks.begin(),
                                               ExitBlocks.end(), SuccBB);
         if (IsExitBlock)
           continue;
 
-        VisitStack.push_back(WorklistItem(SuccBB, false));
+        VisitStack.push_back(WorklistItem(SuccBB, 0));
       }
     }
 
     // Place the list of instructions to simplify on the next loop iteration
     // into ToSimplify.
     std::swap(ToSimplify, Next);
     Next->clear();
 
     Changed |= LocalChanged;
   } while (LocalChanged);
 
   return Changed;
 }

lib/Transforms/Scalar/LoopUnrollPass.cpp

for (unsigned Idx = 0; Idx != BBWorklist.size(); ++Idx) {
         RolledDynamicCost += TTI.getUserCost(&I);
 
         // Visit the instruction to analyze its loop cost after unrolling,
         // and if the visitor returns true, mark the instruction as free after
         // unrolling and continue.
         bool IsFree = Analyzer.visit(I);
         bool Inserted = InstCostMap.insert({&I, (int)Iteration,
                                            (unsigned)IsFree,
-                                           /*IsCounted*/ false}).second;
+                                           /*IsCounted*/ 0}).second;
         (void)Inserted;
         assert(Inserted && "Cannot have a state for an unvisited instruction!");
 
         if (IsFree)
           continue;
 
         // If the instruction might have a side-effect recursively account for
         // the cost of it and all the instructions leading up to it.

tools/libclang/CIndex.cpp

       return MDR->getName();
   } else if (C.kind == CXCursor_MacroExpansion) {
     MacroExpansionCursor ME = getCursorMacroExpansion(C);
     return ME.getName();
   }
   return nullptr;
 }
 
-unsigned clang_Cursor_isMacroFunctionLike(CXCursor C) {
+bool clang_Cursor_isMacroFunctionLike(CXCursor C) {
   const IdentifierInfo *II = getMacroIdentifier(C);
   if (!II) {
     return false;
   }
   ASTUnit *ASTU = getCursorASTUnit(C);
   Preprocessor &PP = ASTU->getPreprocessor();
   if (const MacroInfo *MI = PP.getMacroInfo(II))
     return MI->isFunctionLike();
   return false;
 }
 
-unsigned clang_Cursor_isMacroBuiltin(CXCursor C) {
+bool clang_Cursor_isMacroBuiltin(CXCursor C) {
   const IdentifierInfo *II = getMacroIdentifier(C);
   if (!II) {
     return false;
   }
   ASTUnit *ASTU = getCursorASTUnit(C);
   Preprocessor &PP = ASTU->getPreprocessor();
   if (const MacroInfo *MI = PP.getMacroInfo(II))
     return MI->isBuiltinMacro();
   return false;
 }
 
-unsigned clang_Cursor_isFunctionInlined(CXCursor C) {
+bool clang_Cursor_isFunctionInlined(CXCursor C) {
   const Decl *D = getCursorDecl(C);
   const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D);
   if (!FD) {
     return false;
   }
   return FD->isInlined();
 }
 

   FileEntry *FEnt = static_cast<FileEntry *>(file);
   const llvm::sys::fs::UniqueID &ID = FEnt->getUniqueID();
   outID->data[0] = ID.getDevice();
   outID->data[1] = ID.getFile();
   outID->data[2] = FEnt->getModificationTime();
   return 0;
 }
 
-int clang_File_isEqual(CXFile file1, CXFile file2) {
+bool clang_File_isEqual(CXFile file1, CXFile file2) {
   if (file1 == file2)
     return true;
 
   if (!file1 || !file2)
     return false;
 
   FileEntry *FEnt1 = static_cast<FileEntry *>(file1);
   FileEntry *FEnt2 = static_cast<FileEntry *>(file2);

   if (const ObjCPropertyRefExpr *PropRef = dyn_cast<ObjCPropertyRefExpr>(E))
     return PropRef->getLocation();
   
   return E->getLocStart();
 }
 
 extern "C" {
 
-unsigned clang_visitChildren(CXCursor parent,
+bool clang_visitChildren(CXCursor parent,
                              CXCursorVisitor visitor,
                              CXClientData client_data) {
   CursorVisitor CursorVis(getCursorTU(parent), visitor, client_data,
                           /*VisitPreprocessorLast=*/false);
   return CursorVis.VisitChildren(parent);
 }
 
 #ifndef __has_feature

 
   return Result;
 }
 
 CXCursor clang_getNullCursor(void) {
   return MakeCXCursorInvalid(CXCursor_InvalidFile);
 }
 
-unsigned clang_equalCursors(CXCursor X, CXCursor Y) {
+bool clang_equalCursors(CXCursor X, CXCursor Y) {
   // Clear out the "FirstInDeclGroup" part in a declaration cursor, since we
   // can't set consistently. For example, when visiting a DeclStmt we will set
   // it but we don't set it on the result of clang_getCursorDefinition for
   // a reference of the same declaration.
   // FIXME: Setting "FirstInDeclGroup" in CXCursors is a hack that only works
   // when visiting a DeclStmt currently, the AST should be enhanced to be able
   // to provide that kind of info.
   if (clang_isDeclaration(X.kind))
     X.data[1] = nullptr;
   if (clang_isDeclaration(Y.kind))
     Y.data[1] = nullptr;
 
   return X == Y;
 }
 
 unsigned clang_hashCursor(CXCursor C) {
   unsigned Index = 0;
   if (clang_isExpression(C.kind) || clang_isStatement(C.kind))
     Index = 1;
   
   return llvm::DenseMapInfo<std::pair<unsigned, const void*> >::getHashValue(
                                         std::make_pair(C.kind, C.data[Index]));
 }
 
-unsigned clang_isInvalid(enum CXCursorKind K) {
+bool clang_isInvalid(enum CXCursorKind K) {
   return K >= CXCursor_FirstInvalid && K <= CXCursor_LastInvalid;
 }
 
-unsigned clang_isDeclaration(enum CXCursorKind K) {
+bool clang_isDeclaration(enum CXCursorKind K) {
   return (K >= CXCursor_FirstDecl && K <= CXCursor_LastDecl) ||
          (K >= CXCursor_FirstExtraDecl && K <= CXCursor_LastExtraDecl);
 }
 
-unsigned clang_isReference(enum CXCursorKind K) {
+bool clang_isReference(enum CXCursorKind K) {
   return K >= CXCursor_FirstRef && K <= CXCursor_LastRef;
 }
 
-unsigned clang_isExpression(enum CXCursorKind K) {
+bool clang_isExpression(enum CXCursorKind K) {
   return K >= CXCursor_FirstExpr && K <= CXCursor_LastExpr;
 }
 
-unsigned clang_isStatement(enum CXCursorKind K) {
+bool clang_isStatement(enum CXCursorKind K) {
   return K >= CXCursor_FirstStmt && K <= CXCursor_LastStmt;
 }
 
-unsigned clang_isAttribute(enum CXCursorKind K) {
+bool clang_isAttribute(enum CXCursorKind K) {
     return K >= CXCursor_FirstAttr && K <= CXCursor_LastAttr;
 }
 
-unsigned clang_isTranslationUnit(enum CXCursorKind K) {
+bool clang_isTranslationUnit(enum CXCursorKind K) {
   return K == CXCursor_TranslationUnit;
 }
 
-unsigned clang_isPreprocessing(enum CXCursorKind K) {
+bool clang_isPreprocessing(enum CXCursorKind K) {
   return K >= CXCursor_FirstPreprocessing && K <= CXCursor_LastPreprocessing;
 }
   
-unsigned clang_isUnexposed(enum CXCursorKind K) {
+bool clang_isUnexposed(enum CXCursorKind K) {
   switch (K) {
     case CXCursor_UnexposedDecl:
     case CXCursor_UnexposedExpr:
     case CXCursor_UnexposedStmt:
     case CXCursor_UnexposedAttr:
       return true;
     default:
       return false;

tools/libclang/CXComment.cpp

 CXComment clang_Comment_getChild(CXComment CXC, unsigned ChildIdx) {
   const Comment *C = getASTNode(CXC);
   if (!C || ChildIdx >= C->child_count())
     return createCXComment(nullptr, nullptr);
 
   return createCXComment(*(C->child_begin() + ChildIdx), CXC.TranslationUnit);
 }
 
-unsigned clang_Comment_isWhitespace(CXComment CXC) {
+bool clang_Comment_isWhitespace(CXComment CXC) {
   const Comment *C = getASTNode(CXC);
   if (!C)
     return false;
 
   if (const TextComment *TC = dyn_cast<TextComment>(C))
     return TC->isWhitespace();
 
   if (const ParagraphComment *PC = dyn_cast<ParagraphComment>(C))
     return PC->isWhitespace();
 
   return false;
 }
 
-unsigned clang_InlineContentComment_hasTrailingNewline(CXComment CXC) {
+bool clang_InlineContentComment_hasTrailingNewline(CXComment CXC) {
   const InlineContentComment *ICC = getASTNodeAs<InlineContentComment>(CXC);
   if (!ICC)
     return false;
 
   return ICC->hasTrailingNewline();
 }
 
 CXString clang_TextComment_getText(CXComment CXC) {

 CXString clang_HTMLTagComment_getTagName(CXComment CXC) {
   const HTMLTagComment *HTC = getASTNodeAs<HTMLTagComment>(CXC);
   if (!HTC)
     return cxstring::createNull();
 
   return cxstring::createRef(HTC->getTagName());
 }
 
-unsigned clang_HTMLStartTagComment_isSelfClosing(CXComment CXC) {
+bool clang_HTMLStartTagComment_isSelfClosing(CXComment CXC) {
   const HTMLStartTagComment *HST = getASTNodeAs<HTMLStartTagComment>(CXC);
   if (!HST)
     return false;
 
   return HST->isSelfClosing();
 }
 
 unsigned clang_HTMLStartTag_getNumAttrs(CXComment CXC) {

 CXString clang_ParamCommandComment_getParamName(CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC || !PCC->hasParamName())
     return cxstring::createNull();
 
   return cxstring::createRef(PCC->getParamNameAsWritten());
 }
 
-unsigned clang_ParamCommandComment_isParamIndexValid(CXComment CXC) {
+bool clang_ParamCommandComment_isParamIndexValid(CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC)
     return false;
 
   return PCC->isParamIndexValid();
 }
 
 unsigned clang_ParamCommandComment_getParamIndex(CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC || !PCC->isParamIndexValid() || PCC->isVarArgParam())
     return ParamCommandComment::InvalidParamIndex;
 
   return PCC->getParamIndex();
 }
 
-unsigned clang_ParamCommandComment_isDirectionExplicit(CXComment CXC) {
+bool clang_ParamCommandComment_isDirectionExplicit(CXComment CXC) {
   const ParamCommandComment *PCC = getASTNodeAs<ParamCommandComment>(CXC);
   if (!PCC)
     return false;
 
   return PCC->isDirectionExplicit();
 }
 
 enum CXCommentParamPassDirection clang_ParamCommandComment_getDirection(

 CXString clang_TParamCommandComment_getParamName(CXComment CXC) {
   const TParamCommandComment *TPCC = getASTNodeAs<TParamCommandComment>(CXC);
   if (!TPCC || !TPCC->hasParamName())
     return cxstring::createNull();
 
   return cxstring::createRef(TPCC->getParamNameAsWritten());
 }
 
-unsigned clang_TParamCommandComment_isParamPositionValid(CXComment CXC) {
+bool clang_TParamCommandComment_isParamPositionValid(CXComment CXC) {
   const TParamCommandComment *TPCC = getASTNodeAs<TParamCommandComment>(CXC);
   if (!TPCC)
     return false;
 
   return TPCC->isPositionValid();
 }
 
 unsigned clang_TParamCommandComment_getDepth(CXComment CXC) {

tools/libclang/CXCursor.cpp

   const Expr *E = nullptr;
   if (clang_isExpression(C.kind))
     E = getCursorExpr(C);
   if (!E)
     return 0;
 
   if (const ObjCMessageExpr *MsgE = dyn_cast<ObjCMessageExpr>(E)) {
     if (MsgE->getReceiverKind() != ObjCMessageExpr::Instance)
-      return false;
+      return 0;
     if (auto *RecE = dyn_cast<ObjCMessageExpr>(
             MsgE->getInstanceReceiver()->IgnoreParenCasts())) {
       if (RecE->getMethodFamily() == OMF_alloc)
-        return false;
+        return 0;
     }
-    return true;
+    return 1;
   }
 
   const MemberExpr *ME = nullptr;
   if (isa<MemberExpr>(E))
     ME = cast<MemberExpr>(E);
   else if (const CallExpr *CE = dyn_cast<CallExpr>(E))
     ME = dyn_cast_or_null<MemberExpr>(CE->getCallee());
 

tools/libclang/CXIndexDataConsumer.cpp

void CXIndexDataConsumer::importedPCH(const FileEntry *File) {
   if (!CB.importedASTFile)
     return;
 
   CXIdxImportedASTFileInfo Info = {
                                     static_cast<CXFile>(
                                       const_cast<FileEntry *>(File)),
                                     /*module=*/nullptr,
                                     getIndexLoc(SourceLocation()),
-                                    /*isImplicit=*/false
+                                    /*isImplicit=*/0
                                   };
   CXIdxClientASTFile astFile = CB.importedASTFile(ClientData, &Info);
   (void)astFile;
 }
 
 void CXIndexDataConsumer::startedTranslationUnit() {
   CXIdxClientContainer idxCont = nullptr;
   if (CB.startedTranslationUnit)

tools/libclang/CXSourceLocation.cpp

 
 extern "C" {
   
 CXSourceLocation clang_getNullLocation() {
   CXSourceLocation Result = { { nullptr, nullptr }, 0 };
   return Result;
 }
 
-unsigned clang_equalLocations(CXSourceLocation loc1, CXSourceLocation loc2) {
+bool clang_equalLocations(CXSourceLocation loc1, CXSourceLocation loc2) {
   return (loc1.ptr_data[0] == loc2.ptr_data[0] &&
           loc1.ptr_data[1] == loc2.ptr_data[1] &&
           loc1.int_data == loc2.int_data);
 }
 
 CXSourceRange clang_getNullRange() {
   CXSourceRange Result = { { nullptr, nullptr }, 0, 0 };
   return Result;
if (begin.ptr_data[0] != end.ptr_data[0] ||
     return clang_getNullRange();
   
   CXSourceRange Result = { { begin.ptr_data[0], begin.ptr_data[1] },
                            begin.int_data, end.int_data };
 
   return Result;
 }
 
-unsigned clang_equalRanges(CXSourceRange range1, CXSourceRange range2) {
+bool clang_equalRanges(CXSourceRange range1, CXSourceRange range2) {
   return range1.ptr_data[0] == range2.ptr_data[0]
     && range1.ptr_data[1] == range2.ptr_data[1]
     && range1.begin_int_data == range2.begin_int_data
     && range1.end_int_data == range2.end_int_data;
 }
 
 int clang_Range_isNull(CXSourceRange range) {
   return clang_equalRanges(range, clang_getNullRange());

tools/libclang/CXType.cpp

CXType clang_getCanonicalType(CXType CT) {
   if (T.isNull())
     return MakeCXType(QualType(), GetTU(CT));
 
   return MakeCXType(cxtu::getASTUnit(TU)->getASTContext()
                         .getCanonicalType(T),
                     TU);
 }
 
-unsigned clang_isConstQualifiedType(CXType CT) {
+bool clang_isConstQualifiedType(CXType CT) {
   QualType T = GetQualType(CT);
   return T.isLocalConstQualified();
 }
 
-unsigned clang_isVolatileQualifiedType(CXType CT) {
+bool clang_isVolatileQualifiedType(CXType CT) {
   QualType T = GetQualType(CT);
   return T.isLocalVolatileQualified();
 }
 
-unsigned clang_isRestrictQualifiedType(CXType CT) {
+bool clang_isRestrictQualifiedType(CXType CT) {
   QualType T = GetQualType(CT);
   return T.isLocalRestrictQualified();
 }
 
 CXType clang_getPointeeType(CXType CT) {
   QualType T = GetQualType(CT);
   const Type *TP = T.getTypePtrOrNull();
 
switch (K) {
     TKIND(MemberPointer);
     TKIND(Auto);
     TKIND(Elaborated);
   }
 #undef TKIND
   return cxstring::createRef(s);
 }
 
-unsigned clang_equalTypes(CXType A, CXType B) {
+bool clang_equalTypes(CXType A, CXType B) {
   return A.data[0] == B.data[0] && A.data[1] == B.data[1];
 }
 
 unsigned clang_isFunctionTypeVariadic(CXType X) {
   QualType T = GetQualType(X);
   if (T.isNull())
     return 0;
 
CXType clang_Type_getTemplateArgumentAsType(CXType CT, unsigned i) {
   if (TA.size() <= i)
     return MakeCXType(QualType(), GetTU(CT));
   const TemplateArgument &A = TA.get(i);
   if (A.getKind() != TemplateArgument::Type)
     return MakeCXType(QualType(), GetTU(CT));
   return MakeCXType(A.getAsType(), GetTU(CT));
 }
 
-unsigned clang_Type_visitFields(CXType PT,
+bool clang_Type_visitFields(CXType PT,
                                 CXFieldVisitor visitor,
                                 CXClientData client_data){
   CXCursor PC = clang_getTypeDeclaration(PT);
   if (clang_isInvalid(PC.kind))
     return false;
   const RecordDecl *RD =
         dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC));
   if (!RD || RD->isInvalidDecl())

tools/libclang/Indexing.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // libclang public APIs.
 //===----------------------------------------------------------------------===//
 
 extern "C" {
 
-int clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
+bool clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
   return CXIdxEntity_ObjCClass <= K && K <= CXIdxEntity_ObjCCategory;
 }
 
 const CXIdxObjCContainerDeclInfo *
 clang_index_getObjCContainerDeclInfo(const CXIdxDeclInfo *DInfo) {
   if (!DInfo)
     return nullptr;
 

tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

 /// AnalyzeBitcode - Analyze the bitcode file specified by InputFilename.
 static int AnalyzeBitcode() {
   std::unique_ptr<MemoryBuffer> StreamBuffer;
   BitstreamReader StreamFile;
   BitstreamCursor Stream;
   CurStreamTypeType CurStreamType;
   if (openBitcodeFile(InputFilename, StreamBuffer, StreamFile, Stream,
                       CurStreamType))
-    return true;
+    return 1;
 
   // Read block info from BlockInfoFilename, if specified.
   // The block info must be a top-level block.
   if (!BlockInfoFilename.empty()) {
     std::unique_ptr<MemoryBuffer> BlockInfoBuffer;
     BitstreamReader BlockInfoFile;
     BitstreamCursor BlockInfoCursor;
     CurStreamTypeType BlockInfoStreamType;
     if (openBitcodeFile(BlockInfoFilename, BlockInfoBuffer, BlockInfoFile,
                         BlockInfoCursor, BlockInfoStreamType))
-      return true;
+      return 1;
 
     while (!BlockInfoCursor.AtEndOfStream()) {
       unsigned Code = BlockInfoCursor.ReadCode();
       if (Code != bitc::ENTER_SUBBLOCK)
         return Error("Invalid record at top-level in block info file");
 
       unsigned BlockID = BlockInfoCursor.ReadSubBlockID();
       if (BlockID == bitc::BLOCKINFO_BLOCK_ID) {
static int AnalyzeBitcode() {
   while (!Stream.AtEndOfStream()) {
     unsigned Code = Stream.ReadCode();
     if (Code != bitc::ENTER_SUBBLOCK)
       return Error("Invalid record at top-level");
 
     unsigned BlockID = Stream.ReadSubBlockID();
 
     if (ParseBlock(Stream, BlockID, 0, CurStreamType))
-      return true;
+      return 1;
     ++NumTopBlocks;
   }
 
   if (Dump) outs() << "\n\n";
 
   uint64_t BufferSizeBits = StreamFile.getBitcodeBytes().getExtent() * CHAR_BIT;
   // Print a summary of the read file.
   outs() << "Summary of " << InputFilename << ":\n";

tools/llvm-c-test/echo.cpp

if (LLVMIsAGlobalValue(Cst)) {
     fprintf(stderr, "Could not find @%s\n", Name);
     exit(-1);
   }
 
   // Try integer literal
   if (LLVMIsAConstantInt(Cst)) {
     check_value_kind(Cst, LLVMConstantIntValueKind);
     return LLVMConstInt(TypeCloner(M).Clone(Cst),
-                        LLVMConstIntGetZExtValue(Cst), false);
+                        LLVMConstIntGetZExtValue(Cst), 0);
   }
 
   // Try zeroinitializer
   if (LLVMIsAConstantAggregateZero(Cst)) {
     check_value_kind(Cst, LLVMConstantAggregateZeroValueKind);
     return LLVMConstNull(TypeCloner(M).Clone(Cst));
   }
 

tools/llvm-mc/llvm-mc.cpp

 
 static std::string DwarfDebugProducer;
 static void setDwarfDebugProducer() {
   if(!getenv("DEBUG_PRODUCER"))
     return;
   DwarfDebugProducer += getenv("DEBUG_PRODUCER");
 }
 
-static int AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI,
+static bool AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI,
                       raw_ostream &OS) {
 
   AsmLexer Lexer(MAI);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(SrcMgr.getMainFileID())->getBuffer());
 
   bool Error = false;
   while (Lexer.Lex().isNot(AsmToken::Eof)) {
     AsmToken Tok = Lexer.getTok();

tools/llvm-nm/llvm-nm.cpp

return std::make_tuple(A.Size, A.Name, A.Address) <
          std::make_tuple(B.Size, B.Name, B.Address);
 }
 
 static bool compareSymbolName(const NMSymbol &A, const NMSymbol &B) {
   return std::make_tuple(A.Name, A.Size, A.Address) <
          std::make_tuple(B.Name, B.Size, B.Address);
 }
 
-static char isSymbolList64Bit(SymbolicFile &Obj) {
+static bool isSymbolList64Bit(SymbolicFile &Obj) {
   if (isa<IRObjectFile>(Obj)) {
     IRObjectFile *IRobj = dyn_cast<IRObjectFile>(&Obj);
     Module &M = IRobj->getModule();
     if (M.getTargetTriple().empty())
       return false;
     Triple T(M.getTargetTriple());
     return T.isArch64Bit();
   }

tools/llvm-pdbdump/llvm-pdbdump.cpp

static void dumpInput(StringRef Path) {
 
   if (opts::Symbols) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---SYMBOLS---";
     Printer.Indent();
     auto Compilands = GlobalScope->findAllChildren<PDBSymbolCompiland>();
     CompilandDumper Dumper(Printer);
     while (auto Compiland = Compilands->getNext())
-      Dumper.start(*Compiland, true);
+      Dumper.start(*Compiland, 1);
     Printer.Unindent();
   }
 
   if (opts::Globals) {
     Printer.NewLine();
     WithColor(Printer, PDB_ColorItem::SectionHeader).get() << "---GLOBALS---";
     Printer.Indent();
     {

unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

void buildModuleWithCodeAndData() {
     }
   }
   
   void buildMCJITOptions() {
     LLVMInitializeMCJITCompilerOptions(&Options, sizeof(Options));
     Options.OptLevel = 2;
     
     // Just ensure that this field still exists.
-    Options.NoFramePointerElim = false;
+    Options.NoFramePointerElim = 0;
   }
   
   void useRoundTripSectionMemoryManager() {
     Options.MCJMM = LLVMCreateSimpleMCJITMemoryManager(
       new SectionMemoryManager(),
       roundTripAllocateCodeSection,
       roundTripAllocateDataSection,
       roundTripFinalizeMemory,

unittests/IR/ValueMapTest.cpp

TYPED_TEST(ValueMapTest, LocksMutex) {
   this->AddV.reset();
   EXPECT_TRUE(CalledRAUW);
   EXPECT_TRUE(CalledDeleted);
 }
 #endif
 
 template<typename KeyT>
 struct NoFollow : ValueMapConfig<KeyT> {
-  enum { FollowRAUW = false };
+  enum { FollowRAUW = 0 };
 };
 
 TYPED_TEST(ValueMapTest, NoFollowRAUW) {
   ValueMap<TypeParam*, int, NoFollow<TypeParam*> > VM;
   VM[this->BitcastV.get()] = 7;
   EXPECT_EQ(7, VM.lookup(this->BitcastV.get()));
   EXPECT_EQ(0u, VM.count(this->AddV.get()));
   this->BitcastV->replaceAllUsesWith(this->AddV.get());

unittests/Support/CommandLineTest.cpp

 
 class TempEnvVar {
  public:
   TempEnvVar(const char *name, const char *value)
       : name(name) {
     const char *old_value = getenv(name);
     EXPECT_EQ(nullptr, old_value) << old_value;
 #if HAVE_SETENV
-    setenv(name, value, true);
+    setenv(name, value, 1);
 #else
 #   define SKIP_ENVIRONMENT_TESTS
 #endif
   }
 
   ~TempEnvVar() {
 #if HAVE_SETENV
     // Assume setenv and unsetenv come together.

unittests/libclang/LibclangTest.cpp

const char *contents =
       "          'external-contents': \"/real/foo.h\"\n"
       "        }\n"
       "      ]\n"
       "    }\n"
       "  ]\n"
       "}\n";
   TestVFO T(contents);
   T.map("/path/virtual/foo.h", "/real/foo.h");
-  clang_VirtualFileOverlay_setCaseSensitivity(T.VFO, false);
+  clang_VirtualFileOverlay_setCaseSensitivity(T.VFO, 0);
 }
 
 TEST(libclang, VirtualFileOverlay_SharedPrefix) {
   const char *contents =
       "{\n"
       "  'version': 0,\n"
       "  'roots': [\n"
       "    {\n"

utils/TableGen/CTagsEmitter.cpp

 
 class Tag {
 private:
   const std::string *Id;
   SMLoc Loc;
 public:
   Tag(const std::string &Name, const SMLoc Location)
       : Id(&Name), Loc(Location) {}
-  int operator<(const Tag &B) const { return *Id < *B.Id; }
+  bool operator<(const Tag &B) const { return *Id < *B.Id; }
   void emit(raw_ostream &OS) const {
     const MemoryBuffer *CurMB =
         SrcMgr.getMemoryBuffer(SrcMgr.FindBufferContainingLoc(Loc));
     const char *BufferName = CurMB->getBufferIdentifier();
     std::pair<unsigned, unsigned> LineAndColumn = SrcMgr.getLineAndColumn(Loc);
     OS << *Id << "\t" << BufferName << "\t" << LineAndColumn.first << "\n";
   }
 };