<div dir="ltr">Hi David,<div><br></div><div>I hope I didn't miss anything. Please feel free to just file bug reports. That makes tracking and fixing these issues much easier.</div><div><br></div><div>Cheers,<br>Daniel<br>
<div class="gmail_extra"><br><br><div class="gmail_quote">On Mon, Feb 25, 2013 at 5:38 PM, David Blaikie <span dir="ltr"><<a href="mailto:dblaikie@gmail.com" target="_blank" class="cremed">dblaikie@gmail.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex">Hi Daniel,<br>
<br>
There's a few curious cases in here:<br>
<br>
On Mon, Feb 25, 2013 at 2:54 AM, Duncan Sands <<a href="mailto:baldrick@free.fr" class="cremed">baldrick@free.fr</a>> wrote:<br>
> Author: baldrick<br>
> Date: Mon Feb 25 04:54:25 2013<br>
> New Revision: 176016<br>
><br>
> URL: <a href="http://llvm.org/viewvc/llvm-project?rev=176016&view=rev" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project?rev=176016&view=rev</a><br>
> Log:<br>
> Format with clang-format.<br>
><br>
> Modified:<br>
> dragonegg/trunk/include/arm/dragonegg/Target.h<br>
> dragonegg/trunk/include/dragonegg/ABI.h<br>
> dragonegg/trunk/include/dragonegg/ADT/IntervalList.h<br>
> dragonegg/trunk/include/dragonegg/Debug.h<br>
> dragonegg/trunk/include/dragonegg/Internals.h<br>
> dragonegg/trunk/include/dragonegg/TypeConversion.h<br>
> dragonegg/trunk/include/x86/dragonegg/Target.h<br>
> dragonegg/trunk/src/Aliasing.cpp<br>
> dragonegg/trunk/src/Backend.cpp<br>
> dragonegg/trunk/src/Cache.cpp<br>
> dragonegg/trunk/src/ConstantConversion.cpp<br>
> dragonegg/trunk/src/Convert.cpp<br>
> dragonegg/trunk/src/Debug.cpp<br>
> dragonegg/trunk/src/DefaultABI.cpp<br>
> dragonegg/trunk/src/Trees.cpp<br>
> dragonegg/trunk/src/TypeConversion.cpp<br>
> dragonegg/trunk/src/arm/Target.cpp<br>
> dragonegg/trunk/src/x86/Target.cpp<br>
><br>
> Modified: dragonegg/trunk/include/arm/dragonegg/Target.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/arm/dragonegg/Target.h?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/arm/dragonegg/Target.h?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/include/arm/dragonegg/Target.h (original)<br>
> +++ dragonegg/trunk/include/arm/dragonegg/Target.h Mon Feb 25 04:54:25 2013<br>
> @@ -70,8 +70,8 @@ extern bool llvm_arm_aggregate_partially<br>
> #define LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(E, SE, ISR, CC) \<br>
> llvm_arm_aggregate_partially_passed_in_regs((E), (SE), (CC))<br>
><br>
> -extern Type *llvm_arm_aggr_type_for_struct_return(tree_node *type,<br>
> - CallingConv::ID CC);<br>
> +extern Type *<br>
> +llvm_arm_aggr_type_for_struct_return(tree_node *type, CallingConv::ID CC);<br>
><br>
> /* LLVM_AGGR_TYPE_FOR_STRUCT_RETURN - Return LLVM Type if X can be<br>
> returned as an aggregate, otherwise return NULL. */<br>
> @@ -263,21 +263,35 @@ extern bool llvm_arm_should_pass_or_retu<br>
> * with function notes.<br>
> */<br>
> #define LLVM_OVERRIDE_TARGET_ARCH() \<br>
> - (TARGET_THUMB ? \<br>
> - (arm_arch7 ? "thumbv7" : \<br>
> - (arm_arch_thumb2 ? "thumbv6t2" : \<br>
> - (arm_tune == cortexm0 ? "thumbv6m" : \<br>
> - (arm_arch6 ? "thumbv6" : \<br>
> - (arm_arch5e ? "thumbv5e" : \<br>
> - (arm_arch5 ? "thumbv5" : \<br>
> - (arm_arch4t ? "thumbv4t" : ""))))))) : \<br>
> - (arm_arch7 ? "armv7" : \<br>
> - (arm_arch_thumb2 ? "armv6t2" : \<br>
> - (arm_arch6 ? "armv6" : \<br>
> - (arm_arch5e ? "armv5e" : \<br>
> - (arm_arch5 ? "armv5" : \<br>
> - (arm_arch4t ? "armv4t" : \<br>
> - (arm_arch4 ? "armv4" : ""))))))))<br>
> + (TARGET_THUMB \<br>
> + ? (arm_arch7 \<br>
> + ? "thumbv7" \<br>
> + : (arm_arch_thumb2 \<br>
> + ? "thumbv6t2" \<br>
> + : (arm_tune == cortexm0 \<br>
> + ? "thumbv6m" \<br>
> + : (arm_arch6 \<br>
> + ? "thumbv6" \<br>
> + : (arm_arch5e \<br>
> + ? "thumbv5e" \<br>
> + : (arm_arch5 \<br>
> + ? "thumbv5" \<br>
> + : (arm_arch4t ? "thumbv4t" \<br>
> + : ""))))))) \<br>
> + : (arm_arch7 \<br>
> + ? "armv7" \<br>
> + : (arm_arch_thumb2 \<br>
> + ? "armv6t2" \<br>
> + : (arm_arch6 \<br>
> + ? "armv6" \<br>
> + : (arm_arch5e \<br>
> + ? "armv5e" \<br>
> + : (arm_arch5 \<br>
> + ? "armv5" \<br>
> + : (arm_arch4t \<br>
> + ? "armv4t" \<br>
> + : (arm_arch4 ? "armv4" \<br>
> + : ""))))))))<br>
><br>
> #if 0<br>
> // Dragonegg should make flag_mkernel and flag_apple_kext option later on.<br>
> @@ -322,9 +336,10 @@ extern bool llvm_arm_should_pass_or_retu<br>
> so use the incoming register name if it exists. Otherwise, use the default<br>
> register names to match the backend. */<br>
> #define LLVM_GET_REG_NAME(REG_NAME, REG_NUM) \<br>
> - ((REG_NUM) == 10 ? "r10" : (REG_NUM) == 11 ? "r11" : (REG_NUM) == 12 ? \<br>
> - "r12" : (REG_NUM) >= FIRST_VFP_REGNUM && REG_NAME != 0 ? REG_NAME : \<br>
> - reg_names[REG_NUM])<br>
> + ((REG_NUM) == 10 ? "r10" : (REG_NUM) == \<br>
> + 11 ? "r11" : (REG_NUM) == \<br>
> + 12 ? "r12" : (REG_NUM) >= FIRST_VFP_REGNUM && \<br>
> + REG_NAME != 0 ? REG_NAME : reg_names[REG_NUM])<br>
<br>
Probably fine, but not sure how I feel about splitting inside the<br>
third subexpression to the conditional operator rather than splitting<br>
out at a '?' or ':' boundary. I'm assuming the alternatives that split<br>
at those spots would be worse due to line length issues.<br></blockquote><div><br></div><div style>I can't reproduce this. I get:</div><div>#define LLVM_GET_REG_NAME(REG_NAME, REG_NUM) \</div>
<div> ((REG_NUM) == 10 ? "r10" \</div><div> : (REG_NUM) == 11 \</div><div> ? "r11" \</div>
<div> : (REG_NUM) == 12 \</div><div> ? "r12" \</div><div> : (REG_NUM) >= FIRST_VFP_REGNUM && REG_NAME != 0\</div>
<div> ? REG_NAME \</div><div> : reg_names[REG_NUM])</div><div style><br></div><div style>Which seems ok to me. It seems like a waste of space, but I personally find it much easier to understand and see that everything is correct.</div>
<div style> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex">
<br>
> /* Define a static enumeration of the NEON builtins to be used when<br>
> converting to LLVM intrinsics. These names are derived from the<br>
><br>
> Modified: dragonegg/trunk/include/dragonegg/ABI.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ABI.h?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ABI.h?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/include/dragonegg/ABI.h (original)<br>
> +++ dragonegg/trunk/include/dragonegg/ABI.h Mon Feb 25 04:54:25 2013<br>
> @@ -143,8 +143,8 @@ extern bool isZeroSizedStructOrUnion(tre<br>
> // getLLVMScalarTypeForStructReturn - Return LLVM Type if TY can be<br>
> // returned as a scalar, otherwise return NULL. This is the default<br>
> // target independent implementation.<br>
> -inline Type *getLLVMScalarTypeForStructReturn(tree_node *type,<br>
> - unsigned *Offset) {<br>
> +inline Type *<br>
> +getLLVMScalarTypeForStructReturn(tree_node *type, unsigned *Offset) {<br>
> Type *Ty = ConvertType(type);<br>
> uint64_t Size = getDataLayout().getTypeAllocSize(Ty);<br>
> *Offset = 0;<br>
><br>
> Modified: dragonegg/trunk/include/dragonegg/ADT/IntervalList.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ADT/IntervalList.h?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ADT/IntervalList.h?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/include/dragonegg/ADT/IntervalList.h (original)<br>
> +++ dragonegg/trunk/include/dragonegg/ADT/IntervalList.h Mon Feb 25 04:54:25 2013<br>
> @@ -61,8 +61,8 @@ template <class T, typename U, unsigned<br>
> for (unsigned i = 0, e = (unsigned) Intervals.size(); i < e; ++i) {<br>
> if (Intervals[i].getRange().empty())<br>
> return false;<br>
> - if (i && Intervals[i].getRange().getFirst() <<br>
> - Intervals[i - 1].getRange().getLast())<br>
> + if (i && Intervals[i].getRange().getFirst() < Intervals[i - 1]<br>
> + .getRange().getLast())<br>
<br>
This seems less than optimal - wouldn't it be better to split the<br>
whole RHS of the '<'?<br></blockquote><div><br></div><div style>Yeah, this is bad, looking into it.</div><div style> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left-width:1px;border-left-color:rgb(204,204,204);border-left-style:solid;padding-left:1ex">
<br>
> return false;<br>
> }<br>
> return true;<br>
> @@ -106,10 +106,10 @@ void IntervalList<T, U, N>::AddInterval(<br>
> }<br>
><br>
> // Check for overlap with existing intervals.<br>
> - iterator Lo = std::lower_bound(Intervals.begin(), Intervals.end(), Interval,<br>
> - CmpFirst);<br>
> - iterator Hi = std::upper_bound(Intervals.begin(), Intervals.end(), Interval,<br>
> - CmpLast);<br>
> + iterator Lo =<br>
> + std::lower_bound(Intervals.begin(), Intervals.end(), Interval, CmpFirst);<br>
> + iterator Hi =<br>
> + std::upper_bound(Intervals.begin(), Intervals.end(), Interval, CmpLast);<br>
> if (Lo < Hi) {<br>
> // Intervals with index in [Lo, Hi) are those completely covered by the new<br>
> // interval. Throw them away.<br>
><br>
> Modified: dragonegg/trunk/include/dragonegg/Debug.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Debug.h?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Debug.h?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/include/dragonegg/Debug.h (original)<br>
> +++ dragonegg/trunk/include/dragonegg/Debug.h Mon Feb 25 04:54:25 2013<br>
> @@ -80,10 +80,10 @@ public:<br>
><br>
> /// CreateCompileUnit - Create a new descriptor for the specified compile<br>
> /// unit.<br>
> - void CreateCompileUnit(<br>
> - unsigned LangID, StringRef Filename, StringRef Directory,<br>
> - StringRef Producer, bool isMain = false, bool isOptimized = false,<br>
> - StringRef Flags = "", unsigned RunTimeVer = 0);<br>
> + void CreateCompileUnit(unsigned LangID, StringRef Filename,<br>
> + StringRef Directory, StringRef Producer,<br>
> + bool isMain = false, bool isOptimized = false,<br>
> + StringRef Flags = "", unsigned RunTimeVer = 0);<br>
><br>
> /// CreateFile - Create a new descriptor for the specified file.<br>
> DIFile CreateFile(StringRef Filename, StringRef Directory);<br>
> @@ -115,7 +115,7 @@ public:<br>
> unsigned Tag, DIDescriptor Context, StringRef Name, DIFile F,<br>
> unsigned LineNumber, uint64_t SizeInBits, uint64_t AlignInBits,<br>
> uint64_t OffsetInBits, unsigned Flags, DIType DerivedFrom,<br>
> - DIArray Elements, unsigned RunTimeLang = 0, MDNode * ContainingType = 0);<br>
> + DIArray Elements, unsigned RunTimeLang = 0, MDNode *ContainingType = 0);<br>
><br>
> /// CreateTemporaryType - Create a temporary forward-declared type.<br>
> DIType CreateTemporaryType();<br>
> @@ -131,12 +131,12 @@ public:<br>
> StringRef LinkageName, DIFile F, unsigned LineNo, DIType Ty,<br>
> bool isLocalToUnit, bool isDefinition, unsigned VK = 0,<br>
> unsigned VIndex = 0, DIType ContainingType = DIType(), unsigned Flags = 0,<br>
> - bool isOptimized = false, Function * Fn = 0);<br>
> + bool isOptimized = false, Function *Fn = 0);<br>
><br>
> /// CreateSubprogramDefinition - Create new subprogram descriptor for the<br>
> /// given declaration.<br>
> - DISubprogram CreateSubprogramDefinition(DISubprogram& SPDeclaration,<br>
> - unsigned LineNo, Function* Fn);<br>
> + DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration,<br>
> + unsigned LineNo, Function *Fn);<br>
><br>
> /// CreateGlobalVariable - Create a new descriptor for the specified global.<br>
> DIGlobalVariable CreateGlobalVariable(<br>
> @@ -180,12 +180,12 @@ public:<br>
> MDNode *OrigLoc = 0);<br>
><br>
> /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.<br>
> - Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,<br>
> - BasicBlock *InsertAtEnd);<br>
> + Instruction *<br>
> + InsertDeclare(llvm::Value *Storage, DIVariable D, BasicBlock *InsertAtEnd);<br>
><br>
> /// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.<br>
> - Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,<br>
> - Instruction *InsertBefore);<br>
> + Instruction *<br>
> + InsertDeclare(llvm::Value *Storage, DIVariable D, Instruction *InsertBefore);<br>
><br>
> /// InsertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.<br>
> Instruction *InsertDbgValueIntrinsic(llvm::Value *V, uint64_t Offset,<br>
><br>
> Modified: dragonegg/trunk/include/dragonegg/Internals.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Internals.h?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Internals.h?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/include/dragonegg/Internals.h (original)<br>
> +++ dragonegg/trunk/include/dragonegg/Internals.h Mon Feb 25 04:54:25 2013<br>
> @@ -146,8 +146,8 @@ bool isPaddingElement(tree_node *, unsig<br>
> /// that has no value specified. For example in C like languages such variables<br>
> /// are initialized to zero, while in Ada they hold an undefined value.<br>
> inline Constant *getDefaultValue(Type *Ty) {<br>
> - return flag_default_initialize_globals ? Constant::getNullValue(Ty) :<br>
> - UndefValue::get(Ty);<br>
> + return flag_default_initialize_globals ? Constant::getNullValue(Ty)<br>
> + : UndefValue::get(Ty);<br>
> }<br>
><br>
> /// isPassedByInvisibleReference - Return true if the specified type should be<br>
> @@ -323,10 +323,10 @@ public:<br>
><br>
> /// CastToAnyType - Cast the specified value to the specified type regardless<br>
> /// of the types involved. This is an inferred cast.<br>
> - Value *CastToAnyType(Value *Src, bool SrcIsSigned, Type *DstTy,<br>
> - bool DstIsSigned);<br>
> - Constant *CastToAnyType(Constant *Src, bool SrcIsSigned, Type *DstTy,<br>
> - bool DstIsSigned);<br>
> + Value *<br>
> + CastToAnyType(Value *Src, bool SrcIsSigned, Type *DstTy, bool DstIsSigned);<br>
> + Constant *<br>
> + CastToAnyType(Constant *Src, bool SrcIsSigned, Type *DstTy, bool DstIsSigned);<br>
><br>
> /// CastFromSameSizeInteger - Cast an integer (or vector of integer) value to<br>
> /// the given scalar (resp. vector of scalar) type of the same bitwidth.<br>
> @@ -420,8 +420,8 @@ private : // Helper functions.<br>
> /// llvm.memset call with the specified operands. Returns DestPtr bitcast<br>
> /// to i8*.<br>
> Value *EmitMemCpy(Value *DestPtr, Value *SrcPtr, Value *Size, unsigned Align);<br>
> - Value *EmitMemMove(Value *DestPtr, Value *SrcPtr, Value *Size,<br>
> - unsigned Align);<br>
> + Value *<br>
> + EmitMemMove(Value *DestPtr, Value *SrcPtr, Value *Size, unsigned Align);<br>
> Value *EmitMemSet(Value *DestPtr, Value *SrcVal, Value *Size, unsigned Align);<br>
><br>
> /// EmitLandingPads - Emit EH landing pads.<br>
> @@ -568,14 +568,14 @@ private:<br>
> #endif<br>
> Value *EmitReg_VEC_PACK_FIX_TRUNC_EXPR(tree_node *type, tree_node *op0,<br>
> tree_node *op1);<br>
> - Value *EmitReg_VEC_PACK_TRUNC_EXPR(tree_node *type, tree_node *op0,<br>
> - tree_node *op1);<br>
> + Value *<br>
> + EmitReg_VEC_PACK_TRUNC_EXPR(tree_node *type, tree_node *op0, tree_node *op1);<br>
> Value *EmitReg_VEC_WIDEN_MULT_HI_EXPR(tree_node *type, tree_node *op0,<br>
> tree_node *op1);<br>
> Value *EmitReg_VEC_WIDEN_MULT_LO_EXPR(tree_node *type, tree_node *op0,<br>
> tree_node *op1);<br>
> - Value *EmitReg_WIDEN_MULT_EXPR(tree_node *type, tree_node *op0,<br>
> - tree_node *op1);<br>
> + Value *<br>
> + EmitReg_WIDEN_MULT_EXPR(tree_node *type, tree_node *op0, tree_node *op1);<br>
><br>
> // Ternary expressions.<br>
> Value *EmitReg_CondExpr(tree_node *op0, tree_node *op1, tree_node *op2);<br>
> @@ -592,8 +592,7 @@ private:<br>
> Value *EmitCallOf(Value *Callee, gimple_statement_d *stmt,<br>
> const MemRef *DestLoc, const AttributeSet &PAL);<br>
> CallInst *EmitSimpleCall(StringRef CalleeName, tree_node *ret_type,<br>
> - /* arguments */ ...)<br>
> - END_WITH_NULL;<br>
> + /* arguments */ ...) END_WITH_NULL;<br>
> Value *EmitFieldAnnotation(Value *FieldPtr, tree_node *FieldDecl);<br>
><br>
> // Inline Assembly and Register Variables.<br>
> @@ -606,8 +605,8 @@ private:<br>
> Value *BuildVectorShuffle(Value *InVec1, Value *InVec2, ...);<br>
> Value *BuildBinaryAtomic(gimple_statement_d *stmt, AtomicRMWInst::BinOp Kind,<br>
> unsigned PostOp = 0);<br>
> - Value *BuildCmpAndSwapAtomic(gimple_statement_d *stmt, unsigned Bits,<br>
> - bool isBool);<br>
> + Value *<br>
> + BuildCmpAndSwapAtomic(gimple_statement_d *stmt, unsigned Bits, bool isBool);<br>
><br>
> // Builtin Function Expansion.<br>
> bool EmitBuiltinCall(gimple_statement_d *stmt, tree_node *fndecl,<br>
> @@ -616,8 +615,8 @@ private:<br>
> tree_node *fndecl, const MemRef *DestLoc,<br>
> Value *&Result);<br>
> bool EmitBuiltinUnaryOp(Value *InVal, Value *&Result, Intrinsic::ID Id);<br>
> - Value *EmitBuiltinBitCountIntrinsic(gimple_statement_d *stmt,<br>
> - Intrinsic::ID Id);<br>
> + Value *<br>
> + EmitBuiltinBitCountIntrinsic(gimple_statement_d *stmt, Intrinsic::ID Id);<br>
> Value *EmitBuiltinSQRT(gimple_statement_d *stmt);<br>
> Value *EmitBuiltinPOWI(gimple_statement_d *stmt);<br>
> Value *EmitBuiltinPOW(gimple_statement_d *stmt);<br>
><br>
> Modified: dragonegg/trunk/include/dragonegg/TypeConversion.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/TypeConversion.h?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/TypeConversion.h?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/include/dragonegg/TypeConversion.h (original)<br>
> +++ dragonegg/trunk/include/dragonegg/TypeConversion.h Mon Feb 25 04:54:25 2013<br>
> @@ -62,8 +62,8 @@ extern llvm::Type *GetUnitType(llvm::LLV<br>
> /// GetUnitPointerType - Returns an LLVM pointer type which points to memory one<br>
> /// address unit wide. For example, on a machine which has 16 bit bytes returns<br>
> /// an i16*.<br>
> -extern llvm::Type *GetUnitPointerType(llvm::LLVMContext &C,<br>
> - unsigned AddrSpace = 0);<br>
> +extern llvm::Type *<br>
> +GetUnitPointerType(llvm::LLVMContext &C, unsigned AddrSpace = 0);<br>
><br>
> /// isSizeCompatible - Return true if the specified gcc type is guaranteed to be<br>
> /// turned by ConvertType into an LLVM type of the same size (i.e. TYPE_SIZE the<br>
> @@ -88,9 +88,9 @@ extern llvm::Type *ConvertType(tree_node<br>
> /// ConvertFunctionType - Convert the specified FUNCTION_TYPE or METHOD_TYPE<br>
> /// tree to an LLVM type. This does the same thing that ConvertType does, but<br>
> /// it also returns the function's LLVM calling convention and attributes.<br>
> -extern llvm::FunctionType *ConvertFunctionType(<br>
> - tree_node *type, tree_node *decl, tree_node *static_chain,<br>
> - llvm::CallingConv::ID &CC, llvm::AttributeSet &PAL);<br>
> +extern llvm::FunctionType *<br>
> +ConvertFunctionType(tree_node *type, tree_node *decl, tree_node *static_chain,<br>
> + llvm::CallingConv::ID &CC, llvm::AttributeSet &PAL);<br>
><br>
> /// ConvertArgListToFnType - Given a DECL_ARGUMENTS list on an GCC tree,<br>
> /// return the LLVM type corresponding to the function. This is useful for<br>
><br>
> Modified: dragonegg/trunk/include/x86/dragonegg/Target.h<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/x86/dragonegg/Target.h?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/x86/dragonegg/Target.h?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/include/x86/dragonegg/Target.h (original)<br>
> +++ dragonegg/trunk/include/x86/dragonegg/Target.h Mon Feb 25 04:54:25 2013<br>
> @@ -125,8 +125,8 @@ extern bool llvm_x86_should_pass_aggrega<br>
> #define LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS(X, Y, Z) \<br>
> llvm_x86_should_pass_aggregate_in_integer_regs((X), (Y), (Z))<br>
><br>
> -extern Type *llvm_x86_scalar_type_for_struct_return(tree_node *type,<br>
> - unsigned *Offset);<br>
> +extern Type *<br>
> +llvm_x86_scalar_type_for_struct_return(tree_node *type, unsigned *Offset);<br>
><br>
> /* LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN - Return LLVM Type if X can be<br>
> returned as a scalar, otherwise return NULL. */<br>
> @@ -205,9 +205,9 @@ extern bool llvm_x86_32_should_pass_aggr<br>
> tree_node *, Type *Ty, std::vector<Type *> &);<br>
><br>
> #define LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS(T, TY, CC, E) \<br>
> - (TARGET_64BIT ? \<br>
> - llvm_x86_64_should_pass_aggregate_in_mixed_regs((T), (TY), (E)) : \<br>
> - llvm_x86_32_should_pass_aggregate_in_mixed_regs((T), (TY), (E)))<br>
> + (TARGET_64BIT \<br>
> + ? llvm_x86_64_should_pass_aggregate_in_mixed_regs((T), (TY), (E)) \<br>
> + : llvm_x86_32_should_pass_aggregate_in_mixed_regs((T), (TY), (E)))<br>
><br>
> extern bool llvm_x86_64_aggregate_partially_passed_in_regs(<br>
> std::vector<Type *> &, std::vector<Type *> &, bool);<br>
><br>
> Modified: dragonegg/trunk/src/Aliasing.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Aliasing.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Aliasing.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/Aliasing.cpp (original)<br>
> +++ dragonegg/trunk/src/Aliasing.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -120,7 +120,7 @@ MDNode *describeAliasSet(tree t) {<br>
><br>
> // If there is a path from this node to any leaf node then it is not a leaf<br>
> // node and can be discarded.<br>
> - for (unsigned i = 0, e = (unsigned)LeafNodes.size(); i != e; ++i)<br>
> + for (unsigned i = 0, e = (unsigned) LeafNodes.size(); i != e; ++i)<br>
<br>
Space between a cast an its operands? I don't recall that being a<br>
'thing' we do in the LLVM codebase generally.<br>
<br>
> if (alias_set_subset_of(LeafNodes[i], alias_set)) {<br>
> NodeTags[alias_set] = 0;<br>
> return 0;<br>
> @@ -129,7 +129,7 @@ MDNode *describeAliasSet(tree t) {<br>
><br>
> // If there is a path from any leaf node to this one then no longer consider<br>
> // that node to be a leaf.<br>
> - for (unsigned i = (unsigned)LeafNodes.size(); i;) {<br>
> + for (unsigned i = (unsigned) LeafNodes.size(); i;) {<br>
> alias_set_type leaf_set = LeafNodes[--i];<br>
> if (alias_set_subset_of(alias_set, leaf_set)) {<br>
> LeafNodes.erase(LeafNodes.begin() + i);<br>
> @@ -143,8 +143,8 @@ MDNode *describeAliasSet(tree t) {<br>
><br>
> // Create metadata describing the new node hanging off root. The name doesn't<br>
> // matter much but needs to be unique for the compilation unit.<br>
> - tree type = TYPE_CANONICAL(<br>
> - TYPE_MAIN_VARIANT(isa<TYPE>(t) ? t : TREE_TYPE(t)));<br>
> + tree type =<br>
> + TYPE_CANONICAL(TYPE_MAIN_VARIANT(isa<TYPE>(t) ? t : TREE_TYPE(t)));<br>
> std::string TreeName =<br>
> ("alias set " + Twine(alias_set) + ": " + getDescriptiveName(type)).str();<br>
> MDBuilder MDHelper(Context);<br>
><br>
> Modified: dragonegg/trunk/src/Backend.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Backend.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Backend.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/Backend.cpp (original)<br>
> +++ dragonegg/trunk/src/Backend.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -214,8 +214,8 @@ void handleVisibility(tree decl, GlobalV<br>
><br>
> /// CodeGenOptLevel - The optimization level to be used by the code generators.<br>
> static CodeGenOpt::Level CodeGenOptLevel() {<br>
> - int OptLevel = LLVMCodeGenOptimizeArg >= 0 ? LLVMCodeGenOptimizeArg :<br>
> - optimize;<br>
> + int OptLevel =<br>
> + LLVMCodeGenOptimizeArg >= 0 ? LLVMCodeGenOptimizeArg : optimize;<br>
> if (OptLevel <= 0)<br>
> return CodeGenOpt::None;<br>
> if (OptLevel == 1)<br>
> @@ -608,8 +608,8 @@ static void InitializeBackend(void) {<br>
> // vectorizer using -fplugin-arg-dragonegg-llvm-option=-vectorize<br>
> PassBuilder.Vectorize = PassManagerBuilder().Vectorize;<br>
><br>
> - PassBuilder.LibraryInfo = new TargetLibraryInfo((Triple)<br>
> - TheModule->getTargetTriple());<br>
> + PassBuilder.LibraryInfo =<br>
> + new TargetLibraryInfo((Triple) TheModule->getTargetTriple());<br>
> if (flag_no_simplify_libcalls)<br>
> PassBuilder.LibraryInfo->disableAllFunctions();<br>
><br>
> @@ -732,8 +732,8 @@ static void createPerModuleOptimizationP<br>
> // FIXME: This is disabled right now until bugs can be worked out. Reenable<br>
> // this for fast -O0 compiles!<br>
> if (PerModulePasses || 1) {<br>
> - FunctionPassManager *PM = CodeGenPasses = new FunctionPassManager(<br>
> - TheModule);<br>
> + FunctionPassManager *PM = CodeGenPasses =<br>
> + new FunctionPassManager(TheModule);<br>
> PM->add(new DataLayout(*TheTarget->getDataLayout()));<br>
> TheTarget->addAnalysisPasses(*PM);<br>
><br>
> @@ -766,8 +766,8 @@ static void CreateStructorsList(std::vec<br>
><br>
> LLVMContext &Context = getGlobalContext();<br>
><br>
> - Type *FPTy = FunctionType::get(Type::getVoidTy(Context),<br>
> - std::vector<Type *>(), false);<br>
> + Type *FPTy =<br>
> + FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);<br>
> FPTy = FPTy->getPointerTo();<br>
><br>
> for (unsigned i = 0, e = Tors.size(); i != e; ++i) {<br>
> @@ -778,9 +778,8 @@ static void CreateStructorsList(std::vec<br>
> StructInit[1] = TheFolder->CreateBitCast(Tors[i].first, FPTy);<br>
> InitList.push_back(ConstantStruct::getAnon(Context, StructInit));<br>
> }<br>
> - Constant *Array = ConstantArray::get(ArrayType::get(InitList[0]->getType(),<br>
> - InitList.size()),<br>
> - InitList);<br>
> + Constant *Array = ConstantArray::get(<br>
> + ArrayType::get(InitList[0]->getType(), InitList.size()), InitList);<br>
> new GlobalVariable(*TheModule, Array->getType(), false,<br>
> GlobalValue::AppendingLinkage, Array, Name);<br>
> }<br>
> @@ -798,9 +797,9 @@ Constant *ConvertMetadataStringToGV(cons<br>
> return Slot;<br>
><br>
> // Create a new string global.<br>
> - GlobalVariable *GV = new GlobalVariable(*TheModule, Init->getType(), true,<br>
> - GlobalVariable::PrivateLinkage, Init,<br>
> - ".str");<br>
> + GlobalVariable *GV =<br>
> + new GlobalVariable(*TheModule, Init->getType(), true,<br>
> + GlobalVariable::PrivateLinkage, Init, ".str");<br>
> GV->setSection("llvm.metadata");<br>
> Slot = GV;<br>
> return GV;<br>
> @@ -818,8 +817,8 @@ void AddAnnotateAttrsToGlobal(GlobalValu<br>
> return;<br>
><br>
> // Get file and line number<br>
> - Constant *lineNo = ConstantInt::get(Type::getInt32Ty(Context),<br>
> - DECL_SOURCE_LINE(decl));<br>
> + Constant *lineNo =<br>
> + ConstantInt::get(Type::getInt32Ty(Context), DECL_SOURCE_LINE(decl));<br>
> Constant *file = ConvertMetadataStringToGV(DECL_SOURCE_FILE(decl));<br>
> Type *SBP = Type::getInt8PtrTy(Context);<br>
> file = TheFolder->CreateBitCast(file, SBP);<br>
> @@ -902,7 +901,8 @@ static void emit_alias(tree decl, tree t<br>
><br>
> GlobalValue *Aliasee = 0;<br>
> if (isa<IDENTIFIER_NODE>(target)) {<br>
> - StringRef AliaseeName(IDENTIFIER_POINTER(target), IDENTIFIER_LENGTH(target));<br>
> + StringRef AliaseeName(IDENTIFIER_POINTER(target),<br>
> + IDENTIFIER_LENGTH(target));<br>
> if (!lookup_attribute("weakref", DECL_ATTRIBUTES(decl))) {<br>
> Aliasee = TheModule->getNamedValue(AliaseeName);<br>
> if (!Aliasee)<br>
> @@ -916,13 +916,12 @@ static void emit_alias(tree decl, tree t<br>
> // weakref to external symbol.<br>
> if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))<br>
> Aliasee = new GlobalVariable(<br>
> - *TheModule, GV->getType()->getElementType(),<br>
> - GV->isConstant(), GlobalVariable::ExternalWeakLinkage,<br>
> - NULL, AliaseeName);<br>
> + *TheModule, GV->getType()->getElementType(), GV->isConstant(),<br>
> + GlobalVariable::ExternalWeakLinkage, NULL, AliaseeName);<br>
> else if (Function *F = dyn_cast<Function>(V))<br>
> Aliasee = Function::Create(F->getFunctionType(),<br>
> - Function::ExternalWeakLinkage,<br>
> - AliaseeName, TheModule);<br>
> + Function::ExternalWeakLinkage, AliaseeName,<br>
> + TheModule);<br>
> else<br>
> llvm_unreachable("Unsuported global value");<br>
> }<br>
> @@ -934,8 +933,8 @@ static void emit_alias(tree decl, tree t<br>
><br>
> if (Linkage != GlobalValue::InternalLinkage) {<br>
> // Create the LLVM alias.<br>
> - GlobalAlias *GA = new GlobalAlias(Aliasee->getType(), Linkage, "", Aliasee,<br>
> - TheModule);<br>
> + GlobalAlias *GA =<br>
> + new GlobalAlias(Aliasee->getType(), Linkage, "", Aliasee, TheModule);<br>
> handleVisibility(decl, GA);<br>
><br>
> // Associate it with decl instead of V.<br>
> @@ -1020,9 +1019,9 @@ static void emit_global(tree decl) {<br>
> // global union, and the LLVM type followed a union initializer that is<br>
> // different from the union element used for the type.<br>
> GV->removeFromParent();<br>
> - GlobalVariable *NGV = new GlobalVariable(<br>
> - *TheModule, Init->getType(), GV->isConstant(),<br>
> - GlobalValue::ExternalLinkage, 0, GV->getName());<br>
> + GlobalVariable *NGV =<br>
> + new GlobalVariable(*TheModule, Init->getType(), GV->isConstant(),<br>
> + GlobalValue::ExternalLinkage, 0, GV->getName());<br>
> NGV->setInitializer(Init);<br>
> GV->replaceAllUsesWith(TheFolder->CreateBitCast(NGV, GV->getType()));<br>
> changeLLVMConstant(GV, NGV);<br>
> @@ -1111,8 +1110,8 @@ static void emit_global(tree decl) {<br>
> if (DECL_SECTION_NAME(decl)) {<br>
> GV->setSection(TREE_STRING_POINTER(DECL_SECTION_NAME(decl)));<br>
> #ifdef LLVM_IMPLICIT_TARGET_GLOBAL_VAR_SECTION<br>
> - } else if (<br>
> - const char *Section = LLVM_IMPLICIT_TARGET_GLOBAL_VAR_SECTION(decl)) {<br>
> + } else if (const char *Section =<br>
> + LLVM_IMPLICIT_TARGET_GLOBAL_VAR_SECTION(decl)) {<br>
> GV->setSection(Section);<br>
> #endif<br>
> }<br>
> @@ -1296,10 +1295,10 @@ Value *make_decl_llvm(tree decl) {<br>
> if (FnEntry == 0) {<br>
> CallingConv::ID CC;<br>
> AttributeSet PAL;<br>
> - FunctionType *Ty = ConvertFunctionType(TREE_TYPE(decl), decl, NULL, CC,<br>
> - PAL);<br>
> - FnEntry = Function::Create(Ty, Function::ExternalLinkage, Name,<br>
> - TheModule);<br>
> + FunctionType *Ty =<br>
> + ConvertFunctionType(TREE_TYPE(decl), decl, NULL, CC, PAL);<br>
> + FnEntry =<br>
> + Function::Create(Ty, Function::ExternalLinkage, Name, TheModule);<br>
> FnEntry->setCallingConv(CC);<br>
> FnEntry->setAttributes(PAL);<br>
><br>
> @@ -1464,8 +1463,8 @@ Value *make_definition_llvm(tree decl) {<br>
> /// Fn is a 'void()' ctor/dtor function to be run, initprio is the init<br>
> /// priority, and isCtor indicates whether this is a ctor or dtor.<br>
> void register_ctor_dtor(Function *Fn, int InitPrio, bool isCtor) {<br>
> - (isCtor ? &StaticCtors : &StaticDtors)->push_back(std::make_pair(Fn,<br>
> - InitPrio));<br>
> + (isCtor ? &StaticCtors : &StaticDtors)<br>
> + ->push_back(std::make_pair(Fn, InitPrio));<br>
> }<br>
><br>
> /// extractRegisterName - Get a register name given its decl. In 4.2 unlike 4.0<br>
> @@ -1666,16 +1665,16 @@ static unsigned int rtl_emit_function(vo<br>
><br>
> /// pass_rtl_emit_function - RTL pass that converts a function to LLVM IR.<br>
> static struct rtl_opt_pass pass_rtl_emit_function = { {<br>
> - RTL_PASS, "rtl_emit_function", /* name */<br>
> - NULL, /* gate */<br>
> - rtl_emit_function, /* execute */<br>
> - NULL, /* sub */<br>
> - NULL, /* next */<br>
> - 0, /* static_pass_number */<br>
> - TV_NONE, /* tv_id */<br>
> + RTL_PASS, "rtl_emit_function", /* name */<br>
> + NULL, /* gate */<br>
> + rtl_emit_function, /* execute */<br>
> + NULL, /* sub */<br>
> + NULL, /* next */<br>
> + 0, /* static_pass_number */<br>
> + TV_NONE, /* tv_id */<br>
> PROP_ssa | PROP_gimple_leh | PROP_cfg, /* properties_required */<br>
> - 0, /* properties_provided */<br>
> - PROP_ssa | PROP_trees, /* properties_destroyed */<br>
> + 0, /* properties_provided */<br>
> + PROP_ssa | PROP_trees, /* properties_destroyed */<br>
> TODO_verify_ssa | TODO_verify_flow | TODO_verify_stmts, /* todo_flags_start */<br>
> TODO_ggc_collect /* todo_flags_finish */<br>
> } };<br>
> @@ -1705,8 +1704,8 @@ static void emit_cgraph_weakrefs() {<br>
> for (struct cgraph_node *node = cgraph_nodes; node; node = node->next)<br>
> if (node->alias && DECL_EXTERNAL(node->decl) &&<br>
> lookup_attribute("weakref", DECL_ATTRIBUTES(node->decl)))<br>
> - emit_alias(node->decl, node->thunk.alias ? node->thunk.alias :<br>
> - get_alias_symbol(node->decl));<br>
> + emit_alias(node->decl, node->thunk.alias ? node->thunk.alias<br>
> + : get_alias_symbol(node->decl));<br>
> }<br>
><br>
> /// emit_varpool_weakrefs - Output any varpool weak references to external<br>
> @@ -1715,8 +1714,8 @@ static void emit_varpool_weakrefs() {<br>
> for (struct varpool_node *vnode = varpool_nodes; vnode; vnode = vnode->next)<br>
> if (vnode->alias && DECL_EXTERNAL(vnode->decl) &&<br>
> lookup_attribute("weakref", DECL_ATTRIBUTES(vnode->decl)))<br>
> - emit_alias(vnode->decl, vnode->alias_of ? vnode->alias_of :<br>
> - get_alias_symbol(vnode->decl));<br>
> + emit_alias(vnode->decl, vnode->alias_of ? vnode->alias_of<br>
> + : get_alias_symbol(vnode->decl));<br>
> }<br>
> #endif<br>
><br>
> @@ -1835,8 +1834,8 @@ static void llvm_finish_unit(void */*gcc<br>
> if (!AttributeUsedGlobals.empty()) {<br>
> std::vector<Constant *> AUGs;<br>
> Type *SBP = Type::getInt8PtrTy(Context);<br>
> - for (SmallSetVector<Constant *, 32>::iterator AI = AttributeUsedGlobals<br>
> - .begin(), AE = AttributeUsedGlobals.end();<br>
> + for (SmallSetVector<Constant *, 32>::iterator AI =<br>
> + AttributeUsedGlobals.begin(), AE = AttributeUsedGlobals.end();<br>
> AI != AE; ++AI) {<br>
> Constant *C = *AI;<br>
> AUGs.push_back(TheFolder->CreateBitCast(C, SBP));<br>
> @@ -1844,9 +1843,9 @@ static void llvm_finish_unit(void */*gcc<br>
><br>
> ArrayType *AT = ArrayType::get(SBP, AUGs.size());<br>
> Constant *Init = ConstantArray::get(AT, AUGs);<br>
> - GlobalValue *gv = new GlobalVariable(*TheModule, AT, false,<br>
> - GlobalValue::AppendingLinkage, Init,<br>
> - "llvm.used");<br>
> + GlobalValue *gv =<br>
> + new GlobalVariable(*TheModule, AT, false, GlobalValue::AppendingLinkage,<br>
> + Init, "llvm.used");<br>
> gv->setSection("llvm.metadata");<br>
> AttributeUsedGlobals.clear();<br>
> }<br>
> @@ -1855,8 +1854,8 @@ static void llvm_finish_unit(void */*gcc<br>
> std::vector<Constant *> ACUGs;<br>
> Type *SBP = Type::getInt8PtrTy(Context);<br>
> for (SmallSetVector<Constant *, 32>::iterator AI =<br>
> - AttributeCompilerUsedGlobals.begin(), AE =<br>
> - AttributeCompilerUsedGlobals.end();<br>
> + AttributeCompilerUsedGlobals<br>
> + .begin(), AE = AttributeCompilerUsedGlobals.end();<br>
> AI != AE; ++AI) {<br>
> Constant *C = *AI;<br>
> ACUGs.push_back(TheFolder->CreateBitCast(C, SBP));<br>
> @@ -1864,9 +1863,9 @@ static void llvm_finish_unit(void */*gcc<br>
><br>
> ArrayType *AT = ArrayType::get(SBP, ACUGs.size());<br>
> Constant *Init = ConstantArray::get(AT, ACUGs);<br>
> - GlobalValue *gv = new GlobalVariable(*TheModule, AT, false,<br>
> - GlobalValue::AppendingLinkage, Init,<br>
> - "llvm.compiler.used");<br>
> + GlobalValue *gv =<br>
> + new GlobalVariable(*TheModule, AT, false, GlobalValue::AppendingLinkage,<br>
> + Init, "llvm.compiler.used");<br>
> gv->setSection("llvm.metadata");<br>
> AttributeCompilerUsedGlobals.clear();<br>
> }<br>
> @@ -1874,9 +1873,9 @@ static void llvm_finish_unit(void */*gcc<br>
> // Add llvm.global.annotations<br>
> if (!AttributeAnnotateGlobals.empty()) {<br>
> Constant *Array = ConstantArray::get(<br>
> - ArrayType::get(AttributeAnnotateGlobals[0]->getType(),<br>
> - AttributeAnnotateGlobals.size()),<br>
> - AttributeAnnotateGlobals);<br>
> + ArrayType::get(AttributeAnnotateGlobals[0]->getType(),<br>
> + AttributeAnnotateGlobals.size()),<br>
> + AttributeAnnotateGlobals);<br>
> GlobalValue *gv = new GlobalVariable(*TheModule, Array->getType(), false,<br>
> GlobalValue::AppendingLinkage, Array,<br>
> "llvm.global.annotations");<br>
> @@ -1931,17 +1930,17 @@ static bool gate_null(void) { return fal<br>
> /// pass_gimple_null - Gimple pass that does nothing.<br>
> static struct gimple_opt_pass pass_gimple_null = {<br>
> { GIMPLE_PASS, "*gimple_null", /* name */<br>
> - gate_null, /* gate */<br>
> - NULL, /* execute */<br>
> - NULL, /* sub */<br>
> - NULL, /* next */<br>
> - 0, /* static_pass_number */<br>
> - TV_NONE, /* tv_id */<br>
> - 0, /* properties_required */<br>
> - 0, /* properties_provided */<br>
> - 0, /* properties_destroyed */<br>
> - 0, /* todo_flags_start */<br>
> - 0 /* todo_flags_finish */<br>
> + gate_null, /* gate */<br>
> + NULL, /* execute */<br>
> + NULL, /* sub */<br>
> + NULL, /* next */<br>
> + 0, /* static_pass_number */<br>
> + TV_NONE, /* tv_id */<br>
> + 0, /* properties_required */<br>
> + 0, /* properties_provided */<br>
> + 0, /* properties_destroyed */<br>
> + 0, /* todo_flags_start */<br>
> + 0 /* todo_flags_finish */<br>
> }<br>
> };<br>
><br>
> @@ -1960,78 +1959,78 @@ static bool gate_correct_state(void) { r<br>
> /// newly inserted functions are processed before being converted to LLVM IR.<br>
> static struct gimple_opt_pass pass_gimple_correct_state = {<br>
> { GIMPLE_PASS, "*gimple_correct_state", /* name */<br>
> - gate_correct_state, /* gate */<br>
> - execute_correct_state, /* execute */<br>
> - NULL, /* sub */<br>
> - NULL, /* next */<br>
> - 0, /* static_pass_number */<br>
> - TV_NONE, /* tv_id */<br>
> - 0, /* properties_required */<br>
> - 0, /* properties_provided */<br>
> - 0, /* properties_destroyed */<br>
> - 0, /* todo_flags_start */<br>
> - 0 /* todo_flags_finish */<br>
> + gate_correct_state, /* gate */<br>
> + execute_correct_state, /* execute */<br>
> + NULL, /* sub */<br>
> + NULL, /* next */<br>
> + 0, /* static_pass_number */<br>
> + TV_NONE, /* tv_id */<br>
> + 0, /* properties_required */<br>
> + 0, /* properties_provided */<br>
> + 0, /* properties_destroyed */<br>
> + 0, /* todo_flags_start */<br>
> + 0 /* todo_flags_finish */<br>
> }<br>
> };<br>
><br>
> /// pass_ipa_null - IPA pass that does nothing.<br>
> static struct ipa_opt_pass_d pass_ipa_null = {<br>
> { IPA_PASS, "*ipa_null", /* name */<br>
> - gate_null, /* gate */<br>
> - NULL, /* execute */<br>
> - NULL, /* sub */<br>
> - NULL, /* next */<br>
> - 0, /* static_pass_number */<br>
> - TV_NONE, /* tv_id */<br>
> - 0, /* properties_required */<br>
> - 0, /* properties_provided */<br>
> - 0, /* properties_destroyed */<br>
> - 0, /* todo_flags_start */<br>
> - 0 /* todo_flags_finish */<br>
> -}, NULL, /* generate_summary */<br>
> - NULL, /* write_summary */<br>
> - NULL, /* read_summary */<br>
> + gate_null, /* gate */<br>
> + NULL, /* execute */<br>
> + NULL, /* sub */<br>
> + NULL, /* next */<br>
> + 0, /* static_pass_number */<br>
> + TV_NONE, /* tv_id */<br>
> + 0, /* properties_required */<br>
> + 0, /* properties_provided */<br>
> + 0, /* properties_destroyed */<br>
> + 0, /* todo_flags_start */<br>
> + 0 /* todo_flags_finish */<br>
> +}, NULL, /* generate_summary */<br>
> + NULL, /* write_summary */<br>
> + NULL, /* read_summary */<br>
> #if (GCC_MINOR > 5)<br>
> - NULL, /* write_optimization_summary */<br>
> - NULL, /* read_optimization_summary */<br>
> + NULL, /* write_optimization_summary */<br>
> + NULL, /* read_optimization_summary */<br>
> #else<br>
> - NULL, /* function_read_summary */<br>
> + NULL, /* function_read_summary */<br>
> #endif<br>
> - NULL, /* stmt_fixup */<br>
> - 0, /* function_transform_todo_flags_start */<br>
> - NULL, /* function_transform */<br>
> - NULL /* variable_transform */<br>
> + NULL, /* stmt_fixup */<br>
> + 0, /* function_transform_todo_flags_start */<br>
> + NULL, /* function_transform */<br>
> + NULL /* variable_transform */<br>
> };<br>
><br>
> /// pass_rtl_null - RTL pass that does nothing.<br>
> static struct rtl_opt_pass pass_rtl_null = { { RTL_PASS, "*rtl_null", /* name */<br>
> - gate_null, /* gate */<br>
> - NULL, /* execute */<br>
> - NULL, /* sub */<br>
> - NULL, /* next */<br>
> - 0, /* static_pass_number */<br>
> + gate_null, /* gate */<br>
> + NULL, /* execute */<br>
> + NULL, /* sub */<br>
> + NULL, /* next */<br>
> + 0, /* static_pass_number */<br>
> TV_NONE, /* tv_id */<br>
> 0, /* properties_required */<br>
> 0, /* properties_provided */<br>
> 0, /* properties_destroyed */<br>
> 0, /* todo_flags_start */<br>
> - 0 /* todo_flags_finish */<br>
> + 0 /* todo_flags_finish */<br>
> } };<br>
><br>
> /// pass_simple_ipa_null - Simple IPA pass that does nothing.<br>
> static struct simple_ipa_opt_pass pass_simple_ipa_null = {<br>
> { SIMPLE_IPA_PASS, "*simple_ipa_null", /* name */<br>
> - gate_null, /* gate */<br>
> - NULL, /* execute */<br>
> - NULL, /* sub */<br>
> - NULL, /* next */<br>
> - 0, /* static_pass_number */<br>
> - TV_NONE, /* tv_id */<br>
> - 0, /* properties_required */<br>
> - 0, /* properties_provided */<br>
> - 0, /* properties_destroyed */<br>
> - 0, /* todo_flags_start */<br>
> - 0 /* todo_flags_finish */<br>
> + gate_null, /* gate */<br>
> + NULL, /* execute */<br>
> + NULL, /* sub */<br>
> + NULL, /* next */<br>
> + 0, /* static_pass_number */<br>
> + TV_NONE, /* tv_id */<br>
> + 0, /* properties_required */<br>
> + 0, /* properties_provided */<br>
> + 0, /* properties_destroyed */<br>
> + 0, /* todo_flags_start */<br>
> + 0 /* todo_flags_finish */<br>
> }<br>
> };<br>
><br>
> @@ -2055,9 +2054,9 @@ static FlagDescriptor PluginFlags[] = {<br>
> /// llvm_plugin_info - Information about this plugin. Users can access this<br>
> /// using "gcc --help -v".<br>
> static struct plugin_info llvm_plugin_info = {<br>
> - LLVM_VERSION, // version<br>
> - // TODO provide something useful here<br>
> - NULL // help<br>
> + LLVM_VERSION, // version<br>
> + // TODO provide something useful here<br>
> + NULL // help<br>
> };<br>
><br>
> #ifndef DISABLE_VERSION_CHECK<br>
><br>
> Modified: dragonegg/trunk/src/Cache.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Cache.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Cache.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/Cache.cpp (original)<br>
> +++ dragonegg/trunk/src/Cache.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -139,7 +139,7 @@ void setCachedInteger(tree t, int Val) {<br>
> intCache = htab_create_ggc(1024, tree2int_hash, tree2int_eq, 0);<br>
><br>
> tree_map_base in = { t };<br>
> - tree2int **slot = (tree2int * *) htab_find_slot(intCache, &in, INSERT);<br>
> + tree2int **slot = (tree2int **)htab_find_slot(intCache, &in, INSERT);<br>
> assert(slot && "Failed to create hash table slot!");<br>
><br>
> if (!*slot) {<br>
> @@ -176,7 +176,7 @@ void setCachedType(tree t, Type *Ty) {<br>
> if (!TypeCache)<br>
> TypeCache = htab_create_ggc(1024, tree2Type_hash, tree2Type_eq, 0);<br>
><br>
> - tree2Type **slot = (tree2Type * *) htab_find_slot(TypeCache, &in, INSERT);<br>
> + tree2Type **slot = (tree2Type **)htab_find_slot(TypeCache, &in, INSERT);<br>
> assert(slot && "Failed to create hash table slot!");<br>
><br>
> if (!*slot) {<br>
> @@ -220,11 +220,10 @@ void setCachedValue(tree t, Value *V) {<br>
> }<br>
><br>
> if (!WeakVHCache)<br>
> - WeakVHCache = htab_create_ggc(1024, tree2WeakVH_hash, tree2WeakVH_eq,<br>
> - DestructWeakVH);<br>
> + WeakVHCache =<br>
> + htab_create_ggc(1024, tree2WeakVH_hash, tree2WeakVH_eq, DestructWeakVH);<br>
><br>
> - tree2WeakVH **slot = (tree2WeakVH * *)<br>
> - htab_find_slot(WeakVHCache, &in, INSERT);<br>
> + tree2WeakVH **slot = (tree2WeakVH **)htab_find_slot(WeakVHCache, &in, INSERT);<br>
> assert(slot && "Failed to create hash table slot!");<br>
><br>
> if (*slot) {<br>
><br>
> Modified: dragonegg/trunk/src/ConstantConversion.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/ConstantConversion.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/ConstantConversion.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/ConstantConversion.cpp (original)<br>
> +++ dragonegg/trunk/src/ConstantConversion.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -308,8 +308,8 @@ static BitSlice ViewAsBits(Constant *C,<br>
> // nothing to worry about: the bits occupy the range [0, StoreSize). But<br>
> // if not then endianness matters: on big-endian machines there are padding<br>
> // bits at the start, while on little-endian machines they are at the end.<br>
> - return BYTES_BIG_ENDIAN ? BitSlice(StoreSize - BitWidth, StoreSize, C) :<br>
> - BitSlice(0, BitWidth, C);<br>
> + return BYTES_BIG_ENDIAN ? BitSlice(StoreSize - BitWidth, StoreSize, C)<br>
> + : BitSlice(0, BitWidth, C);<br>
> }<br>
><br>
> case Type::ArrayTyID: {<br>
> @@ -344,8 +344,8 @@ static BitSlice ViewAsBits(Constant *C,<br>
> const StructLayout *SL = getDataLayout().getStructLayout(STy);<br>
> // Fields with indices in [FirstIdx, LastIdx) overlap the range.<br>
> unsigned FirstIdx = SL->getElementContainingOffset(R.getFirst() / 8);<br>
> - unsigned LastIdx = 1 +<br>
> - SL->getElementContainingOffset((R.getLast() - 1) / 8);<br>
> + unsigned LastIdx =<br>
> + 1 + SL->getElementContainingOffset((R.getLast() - 1) / 8);<br>
> // Visit all fields that overlap the requested range, accumulating their<br>
> // bits in Bits.<br>
> BitSlice Bits;<br>
> @@ -404,8 +404,8 @@ static BitSlice ViewAsBits(Constant *C,<br>
> /// same constant as you would get by storing the bits of 'C' to memory (with<br>
> /// the first bit stored being 'StartingBit') and then loading out a (constant)<br>
> /// value of type 'Ty' from the stored to memory location.<br>
> -static Constant *InterpretAsType(Constant *C, Type *Ty, int StartingBit,<br>
> - TargetFolder &Folder) {<br>
> +static Constant *<br>
> +InterpretAsType(Constant *C, Type *Ty, int StartingBit, TargetFolder &Folder) {<br>
> // Efficient handling for some common cases.<br>
> if (C->getType() == Ty)<br>
> return C;<br>
> @@ -426,16 +426,16 @@ static Constant *InterpretAsType(Constan<br>
> // Convert the constant into a bunch of bits. Only the bits to be "loaded"<br>
> // out are needed, so rather than converting the entire constant this only<br>
> // converts enough to get all of the required bits.<br>
> - BitSlice Bits = ViewAsBits(C, SignedRange(StartingBit,<br>
> - StartingBit + StoreSize), Folder);<br>
> + BitSlice Bits = ViewAsBits(<br>
> + C, SignedRange(StartingBit, StartingBit + StoreSize), Folder);<br>
> // Extract the bits used by the integer. If the integer width is a multiple<br>
> // of the address unit then the endianness of the target doesn't matter. If<br>
> // not then the padding bits come at the start on big-endian machines and at<br>
> // the end on little-endian machines.<br>
> Bits = Bits.Displace(-StartingBit);<br>
> - return BYTES_BIG_ENDIAN ?<br>
> - Bits.getBits(SignedRange(StoreSize - BitWidth, StoreSize), Folder) :<br>
> - Bits.getBits(SignedRange(0, BitWidth), Folder);<br>
> + return BYTES_BIG_ENDIAN<br>
> + ? Bits.getBits(SignedRange(StoreSize - BitWidth, StoreSize), Folder)<br>
> + : Bits.getBits(SignedRange(0, BitWidth), Folder);<br>
> }<br>
><br>
> case Type::PointerTyID: {<br>
> @@ -478,8 +478,9 @@ static Constant *InterpretAsType(Constan<br>
> unsigned NumElts = STy->getNumElements();<br>
> std::vector<Constant *> Vals(NumElts);<br>
> for (unsigned i = 0; i != NumElts; ++i)<br>
> - Vals[i] = InterpretAsType(C, STy->getElementType(i), StartingBit +<br>
> - SL->getElementOffsetInBits(i), Folder);<br>
> + Vals[i] =<br>
> + InterpretAsType(C, STy->getElementType(i),<br>
> + StartingBit + SL->getElementOffsetInBits(i), Folder);<br>
> return ConstantStruct::get(STy, Vals); // TODO: Use ArrayRef constructor.<br>
> }<br>
><br>
> @@ -556,8 +557,8 @@ static Constant *ExtractRegisterFromCons<br>
> unsigned Stride = GET_MODE_BITSIZE(TYPE_MODE(elt_type));<br>
> SmallVector<Constant *, 16> Vals(NumElts);<br>
> for (unsigned i = 0; i != NumElts; ++i)<br>
> - Vals[i] = ExtractRegisterFromConstantImpl(C, elt_type, StartingBit +<br>
> - i * Stride, Folder);<br>
> + Vals[i] = ExtractRegisterFromConstantImpl(<br>
> + C, elt_type, StartingBit + i * Stride, Folder);<br>
> return ConstantVector::get(Vals);<br>
> }<br>
><br>
> @@ -569,8 +570,8 @@ static Constant *ExtractRegisterFromCons<br>
> /// getRegType, and is what you would get by storing the constant to memory and<br>
> /// using LoadRegisterFromMemory to load a register value back out starting from<br>
> /// byte StartingByte.<br>
> -Constant *ExtractRegisterFromConstant(Constant *C, tree type,<br>
> - int StartingByte) {<br>
> +Constant *<br>
> +ExtractRegisterFromConstant(Constant *C, tree type, int StartingByte) {<br>
> TargetFolder Folder(&getDataLayout());<br>
> return ExtractRegisterFromConstantImpl(C, type, StartingByte, Folder);<br>
> }<br>
> @@ -590,8 +591,8 @@ static Constant *getAsRegister(tree exp,<br>
> /// to the given GCC type) into an in-memory constant. The result has the<br>
> /// property that applying ExtractRegisterFromConstant to it gives you the<br>
> /// original in-register constant back again.<br>
> -static Constant *RepresentAsMemory(Constant *C, tree type,<br>
> - TargetFolder &Folder) {<br>
> +static Constant *<br>
> +RepresentAsMemory(Constant *C, tree type, TargetFolder &Folder) {<br>
> // NOTE: Needs to be kept in sync with ExtractRegisterFromConstant.<br>
> assert(C->getType() == getRegType(type) && "Constant has wrong type!");<br>
> Constant *Result;<br>
> @@ -612,8 +613,8 @@ static Constant *RepresentAsMemory(Const<br>
> unsigned Size = GET_MODE_BITSIZE(TYPE_MODE(type));<br>
> Type *MemTy = IntegerType::get(Context, Size);<br>
> bool isSigned = !TYPE_UNSIGNED(type);<br>
> - Result = isSigned ? Folder.CreateSExtOrBitCast(C, MemTy) :<br>
> - Folder.CreateZExtOrBitCast(C, MemTy);<br>
> + Result = isSigned ? Folder.CreateSExtOrBitCast(C, MemTy)<br>
> + : Folder.CreateZExtOrBitCast(C, MemTy);<br>
> break;<br>
> }<br>
><br>
> @@ -679,8 +680,8 @@ static Constant *RepresentAsMemory(Const<br>
> /// and pointless type changes in the IR, and for making explicit the implicit<br>
> /// scalar casts that GCC allows in "assignments" such as initializing a record<br>
> /// field.<br>
> -static Constant *ConvertInitializerWithCast(tree exp, tree type,<br>
> - TargetFolder &Folder) {<br>
> +static Constant *<br>
> +ConvertInitializerWithCast(tree exp, tree type, TargetFolder &Folder) {<br>
> // Convert the initializer. Note that the type of the returned value may be<br>
> // pretty much anything.<br>
> Constant *C = ConvertInitializerImpl(exp, Folder);<br>
> @@ -709,8 +710,8 @@ static Constant *ConvertInitializerWithC<br>
> // Cast to the desired type.<br>
> bool SrcIsSigned = !TYPE_UNSIGNED(TREE_TYPE(exp));<br>
> bool DestIsSigned = !TYPE_UNSIGNED(type);<br>
> - Instruction::CastOps opcode = CastInst::getCastOpcode(C, SrcIsSigned, DestTy,<br>
> - DestIsSigned);<br>
> + Instruction::CastOps opcode =<br>
> + CastInst::getCastOpcode(C, SrcIsSigned, DestTy, DestIsSigned);<br>
> C = Folder.CreateCast(opcode, C, DestTy);<br>
><br>
> return RepresentAsMemory(C, type, Folder);<br>
> @@ -720,8 +721,8 @@ static Constant *ConvertInitializerWithC<br>
> /// moment only INTEGER_CST, REAL_CST, COMPLEX_CST and VECTOR_CST are supported.<br>
> static Constant *ConvertCST(tree exp, TargetFolder &) {<br>
> const tree type = main_type(exp);<br>
> - unsigned SizeInChars = (TREE_INT_CST_LOW(TYPE_SIZE(type)) + CHAR_BIT - 1) /<br>
> - CHAR_BIT;<br>
> + unsigned SizeInChars =<br>
> + (TREE_INT_CST_LOW(TYPE_SIZE(type)) + CHAR_BIT - 1) / CHAR_BIT;<br>
> // Encode the constant in Buffer in target format.<br>
> SmallVector<uint8_t, 16> Buffer(SizeInChars);<br>
> unsigned CharsWritten = native_encode_expr(exp, &Buffer[0], SizeInChars);<br>
> @@ -742,8 +743,8 @@ static Constant *ConvertSTRING_CST(tree<br>
><br>
> std::vector<Constant *> Elts;<br>
> if (ElTy->isIntegerTy(8)) {<br>
> - const unsigned char *InStr = (const unsigned char *)TREE_STRING_POINTER(<br>
> - exp);<br>
> + const unsigned char *InStr =<br>
> + (const unsigned char *)TREE_STRING_POINTER(exp);<br>
> for (unsigned i = 0; i != Len; ++i)<br>
> Elts.push_back(ConstantInt::get(Type::getInt8Ty(Context), InStr[i]));<br>
> } else if (ElTy->isIntegerTy(16)) {<br>
> @@ -757,8 +758,8 @@ static Constant *ConvertSTRING_CST(tree<br>
> if (llvm::sys::isBigEndianHost() == BYTES_BIG_ENDIAN)<br>
> Elts.push_back(ConstantInt::get(Type::getInt16Ty(Context), InStr[i]));<br>
> else<br>
> - Elts.push_back(ConstantInt::get(Type::getInt16Ty(Context),<br>
> - ByteSwap_16(InStr[i])));<br>
> + Elts.push_back(<br>
> + ConstantInt::get(Type::getInt16Ty(Context), ByteSwap_16(InStr[i])));<br>
> }<br>
> } else if (ElTy->isIntegerTy(32)) {<br>
> assert((Len & 3) == 0 &&<br>
> @@ -771,15 +772,15 @@ static Constant *ConvertSTRING_CST(tree<br>
> if (llvm::sys::isBigEndianHost() == BYTES_BIG_ENDIAN)<br>
> Elts.push_back(ConstantInt::get(Type::getInt32Ty(Context), InStr[i]));<br>
> else<br>
> - Elts.push_back(ConstantInt::get(Type::getInt32Ty(Context),<br>
> - ByteSwap_32(InStr[i])));<br>
> + Elts.push_back(<br>
> + ConstantInt::get(Type::getInt32Ty(Context), ByteSwap_32(InStr[i])));<br>
> }<br>
> } else {<br>
> llvm_unreachable("Unknown character type!");<br>
> }<br>
><br>
> - unsigned LenInElts = Len / TREE_INT_CST_LOW(<br>
> - TYPE_SIZE_UNIT(main_type(main_type(exp))));<br>
> + unsigned LenInElts =<br>
> + Len / TREE_INT_CST_LOW(TYPE_SIZE_UNIT(main_type(main_type(exp))));<br>
> unsigned ConstantSize = StrTy->getNumElements();<br>
><br>
> if (LenInElts != ConstantSize) {<br>
> @@ -830,8 +831,9 @@ static Constant *ConvertArrayCONSTRUCTOR<br>
> // Resize to the number of array elements if known. This ensures that every<br>
> // element will be at least default initialized even if no initial value is<br>
> // given for it.<br>
> - uint64_t TypeElts = isa<ARRAY_TYPE>(init_type) ? ArrayLengthOf(init_type) :<br>
> - TYPE_VECTOR_SUBPARTS(init_type);<br>
> + uint64_t TypeElts =<br>
> + isa<ARRAY_TYPE>(init_type) ? ArrayLengthOf(init_type)<br>
> + : TYPE_VECTOR_SUBPARTS(init_type);<br>
> if (TypeElts != NO_LENGTH)<br>
> Elts.resize(TypeElts);<br>
><br>
> @@ -961,9 +963,9 @@ static Constant *ConvertArrayCONSTRUCTOR<br>
> if (NumSameType == 1)<br>
> StructElt = Elts[First];<br>
> else<br>
> - StructElt = ConstantArray::get(ArrayType::get(Ty, NumSameType),<br>
> - ArrayRef<Constant *>(&Elts[First],<br>
> - NumSameType));<br>
> + StructElt =<br>
> + ConstantArray::get(ArrayType::get(Ty, NumSameType),<br>
> + ArrayRef<Constant *>(&Elts[First], NumSameType));<br>
> StructElts.push_back(StructElt);<br>
> First = Last;<br>
> }<br>
> @@ -1028,8 +1030,8 @@ class FieldContents {<br>
><br>
> public:<br>
> /// get - Fill the range [first, last) with the given constant.<br>
> - static FieldContents get(int first, int last, Constant *c,<br>
> - TargetFolder &folder) {<br>
> + static FieldContents<br>
> + get(int first, int last, Constant *c, TargetFolder &folder) {<br>
> return FieldContents(SignedRange(first, last), c, first, folder);<br>
> }<br>
><br>
> @@ -1077,8 +1079,8 @@ public:<br>
> if ((C->getType()->getPrimitiveSizeInBits() % BITS_PER_UNIT) != 0) {<br>
> Type *Ty = C->getType();<br>
> assert(Ty->isIntegerTy() && "Non-integer type with non-byte size!");<br>
> - unsigned BitWidth = RoundUpToAlignment(Ty->getPrimitiveSizeInBits(),<br>
> - BITS_PER_UNIT);<br>
> + unsigned BitWidth =<br>
> + RoundUpToAlignment(Ty->getPrimitiveSizeInBits(), BITS_PER_UNIT);<br>
> Ty = IntegerType::get(Context, BitWidth);<br>
> C = TheFolder->CreateZExtOrBitCast(C, Ty);<br>
> if (isSafeToReturnContentsDirectly(DL))<br>
> @@ -1206,16 +1208,16 @@ static Constant *ConvertRecordCONSTRUCTO<br>
> assert(isa<FIELD_DECL>(field) && "Initial value not for a field!");<br>
> assert(OffsetIsLLVMCompatible(field) && "Field position not known!");<br>
> // Turn the initial value for this field into an LLVM constant.<br>
> - Constant *Init = ConvertInitializerWithCast(value, main_type(field),<br>
> - Folder);<br>
> + Constant *Init =<br>
> + ConvertInitializerWithCast(value, main_type(field), Folder);<br>
> // Work out the range of bits occupied by the field.<br>
> uint64_t FirstBit = getFieldOffsetInBits(field);<br>
> assert(FirstBit <= TypeSize && "Field off end of type!");<br>
> // If a size was specified for the field then use it. Otherwise take the<br>
> // size from the initial value.<br>
> - uint64_t BitWidth = isInt64(DECL_SIZE(field), true) ?<br>
> - getInt64(DECL_SIZE(field), true) :<br>
> - DL.getTypeAllocSizeInBits(Init->getType());<br>
> + uint64_t BitWidth = isInt64(DECL_SIZE(field), true)<br>
> + ? getInt64(DECL_SIZE(field), true)<br>
> + : DL.getTypeAllocSizeInBits(Init->getType());<br>
> uint64_t LastBit = FirstBit + BitWidth;<br>
><br>
> // Set the bits occupied by the field to the initial value.<br>
> @@ -1364,9 +1366,9 @@ static Constant *ConvertPOINTER_PLUS_EXP<br>
><br>
> // Convert the pointer into an i8* and add the offset to it.<br>
> Ptr = Folder.CreateBitCast(Ptr, GetUnitPointerType(Context));<br>
> - Constant *Result = POINTER_TYPE_OVERFLOW_UNDEFINED ?<br>
> - Folder.CreateInBoundsGetElementPtr(Ptr, Idx) :<br>
> - Folder.CreateGetElementPtr(Ptr, Idx);<br>
> + Constant *Result = POINTER_TYPE_OVERFLOW_UNDEFINED<br>
> + ? Folder.CreateInBoundsGetElementPtr(Ptr, Idx)<br>
> + : Folder.CreateGetElementPtr(Ptr, Idx);<br>
><br>
> // The result may be of a different pointer type.<br>
> Result = Folder.CreateBitCast(Result, getRegType(TREE_TYPE(exp)));<br>
> @@ -1535,9 +1537,9 @@ static Constant *AddressOfARRAY_REF(tree<br>
> Type *EltTy = ConvertType(main_type(main_type(array)));<br>
> ArrayAddr = Folder.CreateBitCast(ArrayAddr, EltTy->getPointerTo());<br>
><br>
> - return POINTER_TYPE_OVERFLOW_UNDEFINED ?<br>
> - Folder.CreateInBoundsGetElementPtr(ArrayAddr, IndexVal) :<br>
> - Folder.CreateGetElementPtr(ArrayAddr, IndexVal);<br>
> + return POINTER_TYPE_OVERFLOW_UNDEFINED<br>
> + ? Folder.CreateInBoundsGetElementPtr(ArrayAddr, IndexVal)<br>
> + : Folder.CreateGetElementPtr(ArrayAddr, IndexVal);<br>
> }<br>
><br>
> /// AddressOfCOMPONENT_REF - Return the address of a field in a record.<br>
> @@ -1552,8 +1554,8 @@ static Constant *AddressOfCOMPONENT_REF(<br>
> // (DECL_OFFSET_ALIGN / BITS_PER_UNIT). Convert to units.<br>
> unsigned factor = DECL_OFFSET_ALIGN(field_decl) / BITS_PER_UNIT;<br>
> if (factor != 1)<br>
> - Offset = Folder.CreateMul(Offset,<br>
> - ConstantInt::get(Offset->getType(), factor));<br>
> + Offset =<br>
> + Folder.CreateMul(Offset, ConstantInt::get(Offset->getType(), factor));<br>
> } else {<br>
> assert(DECL_FIELD_OFFSET(field_decl) && "Field offset not available!");<br>
> Offset = getAsRegister(DECL_FIELD_OFFSET(field_decl), Folder);<br>
> @@ -1564,8 +1566,8 @@ static Constant *AddressOfCOMPONENT_REF(<br>
> // Incorporate as much of it as possible into the pointer computation.<br>
> uint64_t Units = BitStart / BITS_PER_UNIT;<br>
> if (Units > 0) {<br>
> - Offset = Folder.CreateAdd(Offset,<br>
> - ConstantInt::get(Offset->getType(), Units));<br>
> + Offset =<br>
> + Folder.CreateAdd(Offset, ConstantInt::get(Offset->getType(), Units));<br>
> BitStart -= Units * BITS_PER_UNIT;<br>
> (void) BitStart;<br>
> }<br>
> @@ -1581,8 +1583,8 @@ static Constant *AddressOfCOMPONENT_REF(<br>
> }<br>
><br>
> /// AddressOfCOMPOUND_LITERAL_EXPR - Return the address of a compound literal.<br>
> -static Constant *AddressOfCOMPOUND_LITERAL_EXPR(tree exp,<br>
> - TargetFolder &Folder) {<br>
> +static Constant *<br>
> +AddressOfCOMPOUND_LITERAL_EXPR(tree exp, TargetFolder &Folder) {<br>
> tree decl = DECL_EXPR_DECL(COMPOUND_LITERAL_EXPR_DECL_EXPR(exp));<br>
> return AddressOfImpl(decl, Folder);<br>
> }<br>
><br>
> Modified: dragonegg/trunk/src/Convert.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Convert.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Convert.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/Convert.cpp (original)<br>
> +++ dragonegg/trunk/src/Convert.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -161,8 +161,8 @@ static StringRef SelectFPName(tree type,<br>
> /// DisplaceLocationByUnits - Move a memory location by a fixed number of units.<br>
> /// This uses an "inbounds" getelementptr, so the displacement should remain<br>
> /// inside the original object.<br>
> -MemRef DisplaceLocationByUnits(MemRef Loc, int32_t Offset,<br>
> - LLVMBuilder &Builder) {<br>
> +MemRef<br>
> +DisplaceLocationByUnits(MemRef Loc, int32_t Offset, LLVMBuilder &Builder) {<br>
> // Convert to a byte pointer and displace by the offset.<br>
> unsigned AddrSpace = Loc.Ptr->getType()->getPointerAddressSpace();<br>
> Type *UnitPtrTy = GetUnitPointerType(Context, AddrSpace);<br>
> @@ -175,25 +175,25 @@ MemRef DisplaceLocationByUnits(MemRef Lo<br>
> }<br>
><br>
> /// LoadFromLocation - Load a value of the given type from a memory location.<br>
> -static LoadInst *LoadFromLocation(MemRef Loc, Type *Ty, MDNode *AliasTag,<br>
> - LLVMBuilder &Builder) {<br>
> +static LoadInst *<br>
> +LoadFromLocation(MemRef Loc, Type *Ty, MDNode *AliasTag, LLVMBuilder &Builder) {<br>
> unsigned AddrSpace = Loc.Ptr->getType()->getPointerAddressSpace();<br>
> Value *Ptr = Builder.CreateBitCast(Loc.Ptr, Ty->getPointerTo(AddrSpace));<br>
> - LoadInst *LI = Builder.CreateAlignedLoad(Ptr, Loc.getAlignment(),<br>
> - Loc.Volatile);<br>
> + LoadInst *LI =<br>
> + Builder.CreateAlignedLoad(Ptr, Loc.getAlignment(), Loc.Volatile);<br>
> if (AliasTag)<br>
> LI->setMetadata(LLVMContext::MD_tbaa, AliasTag);<br>
> return LI;<br>
> }<br>
><br>
> /// StoreToLocation - Store a value to the given memory location.<br>
> -static StoreInst *StoreToLocation(Value *V, MemRef Loc, MDNode *AliasTag,<br>
> - LLVMBuilder &Builder) {<br>
> +static StoreInst *<br>
> +StoreToLocation(Value *V, MemRef Loc, MDNode *AliasTag, LLVMBuilder &Builder) {<br>
> Type *Ty = V->getType();<br>
> unsigned AddrSpace = Loc.Ptr->getType()->getPointerAddressSpace();<br>
> Value *Ptr = Builder.CreateBitCast(Loc.Ptr, Ty->getPointerTo(AddrSpace));<br>
> - StoreInst *SI = Builder.CreateAlignedStore(V, Ptr, Loc.getAlignment(),<br>
> - Loc.Volatile);<br>
> + StoreInst *SI =<br>
> + Builder.CreateAlignedStore(V, Ptr, Loc.getAlignment(), Loc.Volatile);<br>
> if (AliasTag)<br>
> SI->setMetadata(LLVMContext::MD_tbaa, AliasTag);<br>
> return SI;<br>
> @@ -613,7 +613,7 @@ static bool isLocalDecl(tree decl) {<br>
> return<br>
> // GCC bug workaround: RESULT_DECL may not have DECL_CONTEXT set in thunks.<br>
> (!DECL_CONTEXT(decl) && isa<RESULT_DECL>(decl)) ||<br>
> - // Usual case.<br>
> + // Usual case.<br>
> (DECL_CONTEXT(decl) == current_function_decl &&<br>
> !DECL_EXTERNAL(decl) && // External variables are not local.<br>
> !TREE_STATIC(decl) && // Static variables not considered local.<br>
> @@ -951,8 +951,8 @@ void TreeToLLVM::StartFunctionBody() {<br>
> // If a previous proto existed with the wrong type, replace any uses of it<br>
> // with the actual function and delete the proto.<br>
> if (FnEntry) {<br>
> - FnEntry->replaceAllUsesWith(TheFolder->CreateBitCast(Fn,<br>
> - FnEntry->getType()));<br>
> + FnEntry->replaceAllUsesWith(<br>
> + TheFolder->CreateBitCast(Fn, FnEntry->getType()));<br>
> changeLLVMConstant(FnEntry, Fn);<br>
> FnEntry->eraseFromParent();<br>
> }<br>
> @@ -1130,10 +1130,10 @@ void TreeToLLVM::StartFunctionBody() {<br>
> // Loading the value of a PARM_DECL at this point yields its initial value.<br>
> // Remember this for use when materializing the reads implied by SSA default<br>
> // definitions.<br>
> - SSAInsertionPoint = Builder.Insert(CastInst::Create(<br>
> - Instruction::BitCast,<br>
> - Constant::getNullValue(Type::getInt32Ty(Context)),<br>
> - Type::getInt32Ty(Context)), "ssa point");<br>
> + SSAInsertionPoint = Builder.Insert(<br>
> + CastInst::Create(Instruction::BitCast,<br>
> + Constant::getNullValue(Type::getInt32Ty(Context)),<br>
> + Type::getInt32Ty(Context)), "ssa point");<br>
><br>
> // If this function has nested functions, we should handle a potential<br>
> // nonlocal_goto_save_area.<br>
> @@ -1314,14 +1314,14 @@ Function *TreeToLLVM::FinishFunctionBody<br>
> !isa<COMPLEX_TYPE>(TREE_TYPE(TreeRetVal))) {<br>
> // If the DECL_RESULT is a scalar type, just load out the return value<br>
> // and return it.<br>
> - LoadInst *Load = Builder.CreateAlignedLoad(ResultLV.Ptr,<br>
> - ResultLV.getAlignment());<br>
> + LoadInst *Load =<br>
> + Builder.CreateAlignedLoad(ResultLV.Ptr, ResultLV.getAlignment());<br>
> RetVals.push_back(Builder.CreateBitCast(Load, Fn->getReturnType()));<br>
> } else {<br>
> uint64_t ResultSize = getDataLayout().getTypeAllocSize(<br>
> - ConvertType(TREE_TYPE(TreeRetVal)));<br>
> - uint64_t ReturnSize = getDataLayout().getTypeAllocSize(<br>
> - Fn->getReturnType());<br>
> + ConvertType(TREE_TYPE(TreeRetVal)));<br>
> + uint64_t ReturnSize =<br>
> + getDataLayout().getTypeAllocSize(Fn->getReturnType());<br>
><br>
> // The load does not necessarily start at the beginning of the aggregate<br>
> // (x86-64).<br>
> @@ -1331,15 +1331,15 @@ Function *TreeToLLVM::FinishFunctionBody<br>
> } else {<br>
> // Advance to the point we want to load from.<br>
> if (ReturnOffset) {<br>
> - ResultLV.Ptr = Builder.CreateBitCast(ResultLV.Ptr,<br>
> - Type::getInt8PtrTy(Context));<br>
> - ResultLV.Ptr = Builder.CreateGEP(<br>
> - ResultLV.Ptr,<br>
> - ConstantInt::get(DL.getIntPtrType(Context, 0),<br>
> - ReturnOffset),<br>
> - flag_verbose_asm ? "rtvl" : "");<br>
> - ResultLV.setAlignment(MinAlign(ResultLV.getAlignment(),<br>
> - ReturnOffset));<br>
> + ResultLV.Ptr = Builder<br>
> + .CreateBitCast(ResultLV.Ptr, Type::getInt8PtrTy(Context));<br>
> + ResultLV.Ptr =<br>
> + Builder.CreateGEP(ResultLV.Ptr,<br>
> + ConstantInt::get(DL.getIntPtrType(Context, 0),<br>
> + ReturnOffset),<br>
> + flag_verbose_asm ? "rtvl" : "");<br>
> + ResultLV.setAlignment(<br>
> + MinAlign(ResultLV.getAlignment(), ReturnOffset));<br>
> ResultSize -= ReturnOffset;<br>
> }<br>
><br>
> @@ -1361,9 +1361,8 @@ Function *TreeToLLVM::FinishFunctionBody<br>
> Idxs[1] = Builder.getInt32(ri);<br>
> Value *GEP = Builder.CreateGEP(ReturnLoc.Ptr, Idxs,<br>
> flag_verbose_asm ? "mrv_gep" : "");<br>
> - Value *E = Builder.CreateAlignedLoad(GEP, /*Align*/ Packed,<br>
> - flag_verbose_asm ? "mrv" :<br>
> - "");<br>
> + Value *E = Builder.CreateAlignedLoad(<br>
> + GEP, /*Align*/ Packed, flag_verbose_asm ? "mrv" : "");<br>
> RetVals.push_back(E);<br>
> }<br>
> // If the return type specifies an empty struct then return one.<br>
> @@ -1433,8 +1432,8 @@ Function *TreeToLLVM::FinishFunctionBody<br>
> #else<br>
> // When checks are enabled, complain if an SSA name was used but not defined.<br>
> #endif<br>
> - for (DenseMap<tree, TrackingVH<Value> >::const_iterator I = SSANames<br>
> - .begin(), E = SSANames.end();<br>
> + for (DenseMap<tree, TrackingVH<Value> >::const_iterator I =<br>
> + SSANames.begin(), E = SSANames.end();<br>
> I != E; ++I) {<br>
> Value *NameDef = I->second;<br>
> // If this is not a placeholder then the SSA name was defined.<br>
> @@ -1657,9 +1656,8 @@ void TreeToLLVM::EmitAggregate(tree exp,<br>
> }<br>
> LValue LV = EmitLV(exp);<br>
> assert(!LV.isBitfield() && "Bitfields containing aggregates not supported!");<br>
> - EmitAggregateCopy(DestLoc,<br>
> - MemRef(LV.Ptr, LV.getAlignment(), TREE_THIS_VOLATILE(exp)),<br>
> - TREE_TYPE(exp));<br>
> + EmitAggregateCopy(DestLoc, MemRef(LV.Ptr, LV.getAlignment(),<br>
> + TREE_THIS_VOLATILE(exp)), TREE_TYPE(exp));<br>
> }<br>
><br>
> /// get_constant_alignment - Return the alignment of constant EXP in bits.<br>
> @@ -1799,8 +1797,8 @@ Value *TreeToLLVM::CastToAnyType(Value *<br>
><br>
> // The types are different so we must cast. Use getCastOpcode to create an<br>
> // inferred cast opcode.<br>
> - Instruction::CastOps opc = CastInst::getCastOpcode(Src, SrcIsSigned, DestTy,<br>
> - DestIsSigned);<br>
> + Instruction::CastOps opc =<br>
> + CastInst::getCastOpcode(Src, SrcIsSigned, DestTy, DestIsSigned);<br>
><br>
> // Generate the cast and return it.<br>
> return Builder.CreateCast(opc, Src, DestTy);<br>
> @@ -1834,8 +1832,8 @@ Constant *TreeToLLVM::CastToAnyType(Cons<br>
><br>
> // The types are different so we must cast. Use getCastOpcode to create an<br>
> // inferred cast opcode.<br>
> - Instruction::CastOps opc = CastInst::getCastOpcode(Src, SrcIsSigned, DestTy,<br>
> - DestIsSigned);<br>
> + Instruction::CastOps opc =<br>
> + CastInst::getCastOpcode(Src, SrcIsSigned, DestTy, DestIsSigned);<br>
><br>
> // Generate the cast and return it.<br>
> return TheFolder->CreateCast(opc, Src, DestTy);<br>
> @@ -1854,10 +1852,9 @@ Value *TreeToLLVM::CastFromSameSizeInteg<br>
> }<br>
> if (EltTy->isPointerTy()) {<br>
> // A pointer/vector of pointer - use inttoptr.<br>
> - assert(<br>
> - V->getType()->getScalarType()->getPrimitiveSizeInBits() ==<br>
> - DL.getPointerSizeInBits(cast<PointerType>(EltTy)->getAddressSpace()) &&<br>
> - "Pointer type not same size!");<br>
> + assert(V->getType()->getScalarType()->getPrimitiveSizeInBits() ==<br>
> + DL.getPointerSizeInBits(cast<PointerType>(<br>
> + EltTy)->getAddressSpace()) && "Pointer type not same size!");<br>
> return Builder.CreateIntToPtr(V, Ty);<br>
> }<br>
> // Everything else.<br>
> @@ -1895,8 +1892,8 @@ Value *TreeToLLVM::CastToFPType(Value *V<br>
> unsigned DstBits = Ty->getPrimitiveSizeInBits();<br>
> if (SrcBits == DstBits)<br>
> return V;<br>
> - Instruction::CastOps opcode = (SrcBits > DstBits ? Instruction::FPTrunc :<br>
> - Instruction::FPExt);<br>
> + Instruction::CastOps opcode =<br>
> + (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt);<br>
> return Builder.CreateCast(opcode, V, Ty);<br>
> }<br>
><br>
> @@ -1943,10 +1940,9 @@ AllocaInst *TreeToLLVM::CreateTemporary(<br>
> // alloc instructions before. It doesn't matter what this instruction is,<br>
> // it is dead. This allows us to insert allocas in order without having to<br>
> // scan for an insertion point. Use BitCast for int -> int<br>
> - AllocaInsertionPoint =<br>
> - CastInst::Create(Instruction::BitCast,<br>
> - Constant::getNullValue(Type::getInt32Ty(Context)),<br>
> - Type::getInt32Ty(Context), "alloca point");<br>
> + AllocaInsertionPoint = CastInst::Create(<br>
> + Instruction::BitCast, Constant::getNullValue(Type::getInt32Ty(Context)),<br>
> + Type::getInt32Ty(Context), "alloca point");<br>
> // Insert it as the first instruction in the entry block.<br>
> Fn->begin()->getInstList()<br>
> .insert(Fn->begin()->begin(), AllocaInsertionPoint);<br>
> @@ -2053,9 +2049,9 @@ void TreeToLLVM::CopyElementByElement(Me<br>
> if (!isa<AGGREGATE_TYPE>(type)) {<br>
> // Copy scalar.<br>
> MDNode *AliasTag = describeAliasSet(type);<br>
> - StoreRegisterToMemory(LoadRegisterFromMemory(SrcLoc, type, AliasTag,<br>
> - Builder),<br>
> - DestLoc, type, AliasTag, Builder);<br>
> + StoreRegisterToMemory(<br>
> + LoadRegisterFromMemory(SrcLoc, type, AliasTag, Builder), DestLoc, type,<br>
> + AliasTag, Builder);<br>
> return;<br>
> }<br>
><br>
> @@ -2075,12 +2071,10 @@ void TreeToLLVM::CopyElementByElement(Me<br>
> // Get the address of the field.<br>
> int FieldIdx = GetFieldIndex(Field, Ty);<br>
> assert(FieldIdx != INT_MAX && "Should not be copying if no LLVM field!");<br>
> - Value *DestFieldPtr = Builder.CreateStructGEP(DestLoc.Ptr, FieldIdx,<br>
> - flag_verbose_asm ? "df" :<br>
> - "");<br>
> - Value *SrcFieldPtr = Builder.CreateStructGEP(SrcLoc.Ptr, FieldIdx,<br>
> - flag_verbose_asm ? "sf" :<br>
> - "");<br>
> + Value *DestFieldPtr = Builder.CreateStructGEP(<br>
> + DestLoc.Ptr, FieldIdx, flag_verbose_asm ? "df" : "");<br>
> + Value *SrcFieldPtr = Builder.CreateStructGEP(<br>
> + SrcLoc.Ptr, FieldIdx, flag_verbose_asm ? "sf" : "");<br>
><br>
> // Compute the field's alignment.<br>
> unsigned DestFieldAlign = DestLoc.getAlignment();<br>
> @@ -2113,9 +2107,9 @@ void TreeToLLVM::CopyElementByElement(Me<br>
> Value *DestCompPtr = DestLoc.Ptr, *SrcCompPtr = SrcLoc.Ptr;<br>
> if (i) {<br>
> DestCompPtr = Builder.CreateConstInBoundsGEP1_32(<br>
> - DestCompPtr, i, flag_verbose_asm ? "da" : "");<br>
> + DestCompPtr, i, flag_verbose_asm ? "da" : "");<br>
> SrcCompPtr = Builder.CreateConstInBoundsGEP1_32(<br>
> - SrcCompPtr, i, flag_verbose_asm ? "sa" : "");<br>
> + SrcCompPtr, i, flag_verbose_asm ? "sa" : "");<br>
> }<br>
><br>
> // Compute the component's alignment.<br>
> @@ -2209,7 +2203,7 @@ void TreeToLLVM::ZeroElementByElement(Me<br>
> Value *CompPtr = DestLoc.Ptr;<br>
> if (i)<br>
> CompPtr = Builder.CreateConstInBoundsGEP1_32(<br>
> - CompPtr, i, flag_verbose_asm ? "za" : "");<br>
> + CompPtr, i, flag_verbose_asm ? "za" : "");<br>
><br>
> // Compute the component's alignment.<br>
> unsigned CompAlign = DestLoc.getAlignment();<br>
> @@ -2312,12 +2306,12 @@ void TreeToLLVM::EmitAnnotateIntrinsic(V<br>
> if (!annotateAttr)<br>
> return;<br>
><br>
> - Function *annotateFun = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::var_annotation);<br>
> + Function *annotateFun =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::var_annotation);<br>
><br>
> // Get file and line number<br>
> - Constant *lineNo = ConstantInt::get(Type::getInt32Ty(Context),<br>
> - DECL_SOURCE_LINE(decl));<br>
> + Constant *lineNo =<br>
> + ConstantInt::get(Type::getInt32Ty(Context), DECL_SOURCE_LINE(decl));<br>
> Constant *file = ConvertMetadataStringToGV(DECL_SOURCE_FILE(decl));<br>
> Type *SBP = Type::getInt8PtrTy(Context);<br>
> file = TheFolder->CreateBitCast(file, SBP);<br>
> @@ -2575,8 +2569,8 @@ void TreeToLLVM::EmitLandingPads() {<br>
> // the start of the corresponding landing pad. At this point each exception<br>
> // handling region has its own landing pad, which is only reachable via the<br>
> // unwind edges of the region's invokes.<br>
> - Type *UnwindDataTy = StructType::get(Builder.getInt8PtrTy(),<br>
> - Builder.getInt32Ty(), NULL);<br>
> + Type *UnwindDataTy =<br>
> + StructType::get(Builder.getInt8PtrTy(), Builder.getInt32Ty(), NULL);<br>
> for (unsigned LPadNo = 1; LPadNo < NormalInvokes.size(); ++LPadNo) {<br>
> // Get the list of invokes for this GCC landing pad.<br>
> SmallVector<InvokeInst *, 8> &InvokesForPad = NormalInvokes[LPadNo];<br>
> @@ -2603,9 +2597,8 @@ void TreeToLLVM::EmitLandingPads() {<br>
> "No exception handling personality!");<br>
> personality = lang_hooks.eh_personality();<br>
> }<br>
> - LandingPadInst *LPadInst = Builder.CreateLandingPad(UnwindDataTy,<br>
> - DECL_LLVM(personality),<br>
> - 0, "exc");<br>
> + LandingPadInst *LPadInst = Builder.CreateLandingPad(<br>
> + UnwindDataTy, DECL_LLVM(personality), 0, "exc");<br>
><br>
> // Store the exception pointer if made use of elsewhere.<br>
> if (RegionNo < ExceptionPtrs.size() && ExceptionPtrs[RegionNo]) {<br>
> @@ -2641,8 +2634,8 @@ void TreeToLLVM::EmitLandingPads() {<br>
> }<br>
><br>
> // Add the list of typeinfos as a filter clause.<br>
> - ArrayType *FilterTy = ArrayType::get(Builder.getInt8PtrTy(),<br>
> - TypeInfos.size());<br>
> + ArrayType *FilterTy =<br>
> + ArrayType::get(Builder.getInt8PtrTy(), TypeInfos.size());<br>
> LPadInst->addClause(ConstantArray::get(FilterTy, TypeInfos));<br>
> break;<br>
> }<br>
> @@ -2652,8 +2645,8 @@ void TreeToLLVM::EmitLandingPads() {<br>
> case ERT_MUST_NOT_THROW: {<br>
> // Same as a zero-length filter: add an empty filter clause.<br>
> ArrayType *FilterTy = ArrayType::get(Builder.getInt8PtrTy(), 0);<br>
> - LPadInst->addClause(ConstantArray::get(FilterTy,<br>
> - ArrayRef<Constant *>()));<br>
> + LPadInst->addClause(<br>
> + ConstantArray::get(FilterTy, ArrayRef<Constant *>()));<br>
> AllCaught = true;<br>
> break;<br>
> }<br>
> @@ -2728,13 +2721,12 @@ void TreeToLLVM::EmitFailureBlocks() {<br>
><br>
> // Generate a landingpad instruction with an empty (i.e. catch-all) filter<br>
> // clause.<br>
> - Type *UnwindDataTy = StructType::get(Builder.getInt8PtrTy(),<br>
> - Builder.getInt32Ty(), NULL);<br>
> + Type *UnwindDataTy =<br>
> + StructType::get(Builder.getInt8PtrTy(), Builder.getInt32Ty(), NULL);<br>
> tree personality = DECL_FUNCTION_PERSONALITY(FnDecl);<br>
> assert(personality && "No-throw region but no personality function!");<br>
> LandingPadInst *LPadInst = Builder.CreateLandingPad(<br>
> - UnwindDataTy, DECL_LLVM(personality), 1,<br>
> - "exc");<br>
> + UnwindDataTy, DECL_LLVM(personality), 1, "exc");<br>
> ArrayType *FilterTy = ArrayType::get(Builder.getInt8PtrTy(), 0);<br>
> LPadInst->addClause(ConstantArray::get(FilterTy, ArrayRef<Constant *>()));<br>
><br>
> @@ -2835,10 +2827,10 @@ Value *TreeToLLVM::EmitLoadOfLValue(tree<br>
> // Shift the sign bit of the bitfield to the sign bit position in the loaded<br>
> // type. This zaps any extra bits occurring after the end of the bitfield.<br>
> unsigned FirstBitInVal = BYTES_BIG_ENDIAN ? LoadSizeInBits - LV.BitStart -<br>
> - LV.BitSize : LV.BitStart;<br>
> + LV.BitSize : LV.BitStart;<br>
> if (FirstBitInVal + LV.BitSize != LoadSizeInBits) {<br>
> Value *ShAmt = ConstantInt::get(LoadType, LoadSizeInBits -<br>
> - (FirstBitInVal + LV.BitSize));<br>
> + (FirstBitInVal + LV.BitSize));<br>
> Val = Builder.CreateShl(Val, ShAmt);<br>
> }<br>
> // Shift the first bit of the bitfield to be bit zero. This zaps any extra<br>
> @@ -2846,8 +2838,8 @@ Value *TreeToLLVM::EmitLoadOfLValue(tree<br>
> // this also duplicates the sign bit, giving a sign extended value.<br>
> bool isSigned = !TYPE_UNSIGNED(TREE_TYPE(exp));<br>
> Value *ShAmt = ConstantInt::get(LoadType, LoadSizeInBits - LV.BitSize);<br>
> - Val = isSigned ? Builder.CreateAShr(Val, ShAmt) :<br>
> - Builder.CreateLShr(Val, ShAmt);<br>
> + Val = isSigned ? Builder.CreateAShr(Val, ShAmt)<br>
> + : Builder.CreateLShr(Val, ShAmt);<br>
><br>
> // Get the bits as a value of the correct type.<br>
> // FIXME: This assumes the result is an integer.<br>
> @@ -2867,9 +2859,9 @@ Value *TreeToLLVM::EmitADDR_EXPR(tree ex<br>
><br>
> #if (GCC_MINOR < 7)<br>
> Value *TreeToLLVM::EmitCondExpr(tree exp) {<br>
> - return TriviallyTypeConvert(EmitReg_CondExpr(<br>
> - TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1), TREE_OPERAND(exp, 2)),<br>
> - getRegType(TREE_TYPE(exp)));<br>
> + return TriviallyTypeConvert(<br>
> + EmitReg_CondExpr(TREE_OPERAND(exp, 0), TREE_OPERAND(exp, 1),<br>
> + TREE_OPERAND(exp, 2)), getRegType(TREE_TYPE(exp)));<br>
> }<br>
> #endif<br>
><br>
> @@ -2922,7 +2914,7 @@ Value *TreeToLLVM::EmitCONSTRUCTOR(tree<br>
> // Start out with the value zero'd out.<br>
> EmitAggregateZero(*DestLoc, type);<br>
><br>
> - VEC(constructor_elt, gc) * elt = CONSTRUCTOR_ELTS(exp);<br>
> + VEC(constructor_elt, gc) *elt = CONSTRUCTOR_ELTS(exp);<br>
> switch (TREE_CODE(TREE_TYPE(exp))) {<br>
> case ARRAY_TYPE:<br>
> case RECORD_TYPE:<br>
> @@ -3211,8 +3203,8 @@ struct FunctionCallArgumentConversion :<br>
> void EnterField(unsigned FieldNo, llvm::Type *StructTy) {<br>
> Value *Loc = getAddress();<br>
> Loc = Builder.CreateBitCast(Loc, StructTy->getPointerTo());<br>
> - pushAddress(Builder.CreateStructGEP(Loc, FieldNo,<br>
> - flag_verbose_asm ? "elt" : ""));<br>
> + pushAddress(<br>
> + Builder.CreateStructGEP(Loc, FieldNo, flag_verbose_asm ? "elt" : ""));<br>
> }<br>
> void ExitField() {<br>
> assert(!LocStack.empty());<br>
> @@ -3265,8 +3257,8 @@ Value *TreeToLLVM::EmitCallOf(Value *Cal<br>
> }<br>
><br>
> tree fndecl = gimple_call_fndecl(stmt);<br>
> - tree fntype = fndecl ? TREE_TYPE(fndecl) :<br>
> - TREE_TYPE(TREE_TYPE(gimple_call_fn(stmt)));<br>
> + tree fntype =<br>
> + fndecl ? TREE_TYPE(fndecl) : TREE_TYPE(TREE_TYPE(gimple_call_fn(stmt)));<br>
><br>
> // Determine the calling convention.<br>
> CallingConv::ID CallingConvention = CallingConv::C;<br>
> @@ -3345,8 +3337,8 @@ Value *TreeToLLVM::EmitCallOf(Value *Cal<br>
><br>
> // If the caller and callee disagree about a parameter type but the difference<br>
> // is trivial, correct the type used by the caller.<br>
> - for (unsigned i = 0, e = std::min((unsigned) CallOperands.size(),<br>
> - FTy->getNumParams());<br>
> + for (unsigned i =<br>
> + 0, e = std::min((unsigned) CallOperands.size(), FTy->getNumParams());<br>
> i != e; ++i) {<br>
> Type *ExpectedTy = FTy->getParamType(i);<br>
> Type *ActualTy = CallOperands[i]->getType();<br>
> @@ -3406,10 +3398,10 @@ Value *TreeToLLVM::EmitCallOf(Value *Cal<br>
> Target = CreateTempLoc(ConvertType(gimple_call_return_type(stmt)));<br>
><br>
> if (DL.getTypeAllocSize(Call->getType()) <=<br>
> - DL.getTypeAllocSize(<br>
> - cast<PointerType>(Target.Ptr->getType())->getElementType())) {<br>
> - Value *Dest = Builder.CreateBitCast(Target.Ptr,<br>
> - Call->getType()->getPointerTo());<br>
> + DL.getTypeAllocSize(cast<PointerType>(Target.Ptr->getType())<br>
> + ->getElementType())) {<br>
> + Value *Dest =<br>
> + Builder.CreateBitCast(Target.Ptr, Call->getType()->getPointerTo());<br>
> LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Call, Dest, Target.Volatile, Builder);<br>
> } else {<br>
> // The call will return an aggregate value in registers, but<br>
> @@ -3421,10 +3413,11 @@ Value *TreeToLLVM::EmitCallOf(Value *Cal<br>
> AllocaInst *biggerTmp = CreateTemporary(Call->getType());<br>
> LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Call, biggerTmp, /*Volatile=*/ false,<br>
> Builder);<br>
> - EmitAggregateCopy(Target, MemRef(Builder.CreateBitCast(<br>
> - biggerTmp, Call->getType()->getPointerTo()),<br>
> - Target.getAlignment(), Target.Volatile),<br>
> - gimple_call_return_type(stmt));<br>
> + EmitAggregateCopy(<br>
> + Target, MemRef(Builder.CreateBitCast(biggerTmp,<br>
> + Call->getType()->getPointerTo()),<br>
> + Target.getAlignment(), Target.Volatile),<br>
> + gimple_call_return_type(stmt));<br>
> }<br>
><br>
> return DestLoc ? 0 : Builder.CreateLoad(Target.Ptr);<br>
> @@ -3445,8 +3438,8 @@ Value *TreeToLLVM::EmitCallOf(Value *Cal<br>
> "Size mismatch in scalar to scalar conversion!");<br>
> Value *Tmp = CreateTemporary(Call->getType());<br>
> Builder.CreateStore(Call, Tmp);<br>
> - return Builder.CreateLoad(Builder.CreateBitCast(Tmp,<br>
> - RetTy->getPointerTo()));<br>
> + return Builder.CreateLoad(<br>
> + Builder.CreateBitCast(Tmp, RetTy->getPointerTo()));<br>
> }<br>
><br>
> // If the caller expects an aggregate, we have a situation where the ABI for<br>
> @@ -3464,10 +3457,9 @@ Value *TreeToLLVM::EmitCallOf(Value *Cal<br>
> int64_t MaxStoreSize = DL.getTypeAllocSize(AggTy);<br>
> if (Client.Offset) {<br>
> Ptr = Builder.CreateBitCast(Ptr, Type::getInt8PtrTy(Context));<br>
> - Ptr = Builder.CreateGEP(Ptr,<br>
> - ConstantInt::get(DL.getIntPtrType(Ptr->getType()),<br>
> - Client.Offset),<br>
> - flag_verbose_asm ? "ro" : "");<br>
> + Ptr = Builder.CreateGEP(<br>
> + Ptr, ConstantInt::get(DL.getIntPtrType(Ptr->getType()), Client.Offset),<br>
> + flag_verbose_asm ? "ro" : "");<br>
> Align = MinAlign(Align, Client.Offset);<br>
> MaxStoreSize -= Client.Offset;<br>
> }<br>
> @@ -3522,8 +3514,8 @@ CallInst *TreeToLLVM::EmitSimpleCall(Str<br>
> #endif<br>
> va_end(ops);<br>
><br>
> - Type *RetTy = isa<VOID_TYPE>(ret_type) ? Type::getVoidTy(Context) :<br>
> - getRegType(ret_type);<br>
> + Type *RetTy = isa<VOID_TYPE>(ret_type) ? Type::getVoidTy(Context)<br>
> + : getRegType(ret_type);<br>
><br>
> // The LLVM argument types.<br>
> std::vector<Type *> ArgTys;<br>
> @@ -3611,8 +3603,8 @@ void TreeToLLVM::EmitModifyOfRegisterVar<br>
> // Turn this into a 'call void asm sideeffect "", "{reg}"(Ty %RHS)'.<br>
> std::vector<Type *> ArgTys;<br>
> ArgTys.push_back(RHS->getType());<br>
> - FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), ArgTys,<br>
> - false);<br>
> + FunctionType *FTy =<br>
> + FunctionType::get(Type::getVoidTy(Context), ArgTys, false);<br>
><br>
> const char *Name = extractRegisterName(decl);<br>
> Name = LLVM_GET_REG_NAME(Name, decode_reg_name(Name));<br>
> @@ -3836,8 +3828,8 @@ static std::string CanonicalizeConstrain<br>
> // what it is. Cache this information in AnalyzedRegClasses once computed.<br>
> static std::map<unsigned, int> AnalyzedRegClasses;<br>
><br>
> - std::map<unsigned, int>::iterator I = AnalyzedRegClasses.lower_bound(<br>
> - RegClass);<br>
> + std::map<unsigned, int>::iterator I =<br>
> + AnalyzedRegClasses.lower_bound(RegClass);<br>
><br>
> int RegMember;<br>
> if (I != AnalyzedRegClasses.end() && I->first == RegClass) {<br>
> @@ -3947,7 +3939,7 @@ static void ChooseConstraintTuple(gimple<br>
> // are incremented as we go to point to the beginning of each<br>
> // comma-separated alternative.<br>
> const char **RunningConstraints =<br>
> - (const char * *) alloca((NumInputs + NumOutputs) * sizeof(const char *));<br>
> + (const char **)alloca((NumInputs + NumOutputs) * sizeof(const char *));<br>
> memcpy(RunningConstraints, Constraints,<br>
> (NumInputs + NumOutputs) * sizeof(const char *));<br>
> // The entire point of this loop is to compute CommasToSkip.<br>
> @@ -4054,8 +4046,8 @@ Value *TreeToLLVM::BuildVector(const std<br>
> }<br>
><br>
> // Otherwise, insertelement the values to build the vector.<br>
> - Value *Result = UndefValue::get(VectorType::get(Ops[0]->getType(),<br>
> - Ops.size()));<br>
> + Value *Result =<br>
> + UndefValue::get(VectorType::get(Ops[0]->getType(), Ops.size()));<br>
><br>
> for (unsigned i = 0, e = Ops.size(); i != e; ++i)<br>
> Result = Builder.CreateInsertElement(Result, Ops[i], Builder.getInt32(i));<br>
> @@ -4164,9 +4156,9 @@ Value *TreeToLLVM::BuildBinaryAtomic(gim<br>
> Ty[1] = ResultTy->getPointerTo();<br>
> C[0] = Builder.CreateBitCast(C[0], Ty[1]);<br>
> C[1] = Builder.CreateIntCast(<br>
> - C[1], Ty[0], /*isSigned*/ !TYPE_UNSIGNED(return_type), "cast");<br>
> - Value *Result = Builder.CreateAtomicRMW(Kind, C[0], C[1],<br>
> - SequentiallyConsistent);<br>
> + C[1], Ty[0], /*isSigned*/ !TYPE_UNSIGNED(return_type), "cast");<br>
> + Value *Result =<br>
> + Builder.CreateAtomicRMW(Kind, C[0], C[1], SequentiallyConsistent);<br>
> if (PostOp)<br>
> Result = Builder.CreateBinOp(Instruction::BinaryOps(PostOp), Result, C[1]);<br>
><br>
> @@ -4174,8 +4166,8 @@ Value *TreeToLLVM::BuildBinaryAtomic(gim<br>
> return Result;<br>
> }<br>
><br>
> -Value *TreeToLLVM::BuildCmpAndSwapAtomic(gimple stmt, unsigned Bits,<br>
> - bool isBool) {<br>
> +Value *<br>
> +TreeToLLVM::BuildCmpAndSwapAtomic(gimple stmt, unsigned Bits, bool isBool) {<br>
> tree ptr = gimple_call_arg(stmt, 0);<br>
> tree old_val = gimple_call_arg(stmt, 1);<br>
> tree new_val = gimple_call_arg(stmt, 2);<br>
> @@ -4185,16 +4177,16 @@ Value *TreeToLLVM::BuildCmpAndSwapAtomic<br>
> Type *MemPtrTy = MemTy->getPointerTo();<br>
><br>
> Value *Ptr = Builder.CreateBitCast(EmitRegister(ptr), MemPtrTy);<br>
> - Value *Old_Val = CastToAnyType(EmitRegister(old_val),<br>
> - !TYPE_UNSIGNED(TREE_TYPE(old_val)), MemTy,<br>
> - !TYPE_UNSIGNED(TREE_TYPE(old_val)));<br>
> - Value *New_Val = CastToAnyType(EmitRegister(new_val),<br>
> - !TYPE_UNSIGNED(TREE_TYPE(new_val)), MemTy,<br>
> - !TYPE_UNSIGNED(TREE_TYPE(new_val)));<br>
> + Value *Old_Val =<br>
> + CastToAnyType(EmitRegister(old_val), !TYPE_UNSIGNED(TREE_TYPE(old_val)),<br>
> + MemTy, !TYPE_UNSIGNED(TREE_TYPE(old_val)));<br>
> + Value *New_Val =<br>
> + CastToAnyType(EmitRegister(new_val), !TYPE_UNSIGNED(TREE_TYPE(new_val)),<br>
> + MemTy, !TYPE_UNSIGNED(TREE_TYPE(new_val)));<br>
><br>
> Value *C[3] = { Ptr, Old_Val, New_Val };<br>
> - Value *Result = Builder.CreateAtomicCmpXchg(C[0], C[1], C[2],<br>
> - SequentiallyConsistent);<br>
> + Value *Result =<br>
> + Builder.CreateAtomicCmpXchg(C[0], C[1], C[2], SequentiallyConsistent);<br>
><br>
> if (isBool)<br>
> Result = Builder.CreateICmpEQ(Result, Old_Val);<br>
> @@ -4228,8 +4220,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // If this builtin directly corresponds to an LLVM intrinsic, get the<br>
> // IntrinsicID now.<br>
> const char *BuiltinName = IDENTIFIER_POINTER(DECL_NAME(fndecl));<br>
> - Intrinsic::ID IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(<br>
> - TargetPrefix, BuiltinName);<br>
> + Intrinsic::ID IntrinsicID =<br>
> + Intrinsic::getIntrinsicForGCCBuiltin(TargetPrefix, BuiltinName);<br>
> if (IntrinsicID == Intrinsic::not_intrinsic) {<br>
> error("unsupported target builtin %<%s%> used", BuiltinName);<br>
> Type *ResTy = ConvertType(gimple_call_return_type(stmt));<br>
> @@ -4239,12 +4231,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
><br>
> // Finally, map the intrinsic ID back to a name.<br>
> - TargetBuiltinCache[FnCode] = Intrinsic::getDeclaration(TheModule,<br>
> - IntrinsicID);<br>
> + TargetBuiltinCache[FnCode] =<br>
> + Intrinsic::getDeclaration(TheModule, IntrinsicID);<br>
> }<br>
><br>
> - Result = EmitCallOf(TargetBuiltinCache[FnCode], stmt, DestLoc,<br>
> - AttributeSet());<br>
> + Result =<br>
> + EmitCallOf(TargetBuiltinCache[FnCode], stmt, DestLoc, AttributeSet());<br>
> return true;<br>
> }<br>
><br>
> @@ -4371,8 +4363,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Args[1] = Builder.CreateIntCast(Args[1], Type::getInt1Ty(Context),<br>
> /*isSigned*/ false);<br>
><br>
> - Result = Builder.CreateCall(Intrinsic::getDeclaration(<br>
> - TheModule, Intrinsic::objectsize, Ty), Args);<br>
> + Result = Builder.CreateCall(<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::objectsize, Ty), Args);<br>
> return true;<br>
> }<br>
> // Unary bit counting intrinsics.<br>
> @@ -4397,9 +4389,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> ConstantInt::get(Result->getType(), 1));<br>
> tree return_type = gimple_call_return_type(stmt);<br>
> Type *DestTy = ConvertType(return_type);<br>
> - Result = Builder.CreateIntCast(Result, DestTy,<br>
> - /*isSigned*/ !TYPE_UNSIGNED(return_type),<br>
> - "cast");<br>
> + Result = Builder.CreateIntCast(<br>
> + Result, DestTy, /*isSigned*/ !TYPE_UNSIGNED(return_type), "cast");<br>
> return true;<br>
> }<br>
> case BUILT_IN_POPCOUNT: // These GCC builtins always return int.<br>
> @@ -4409,9 +4400,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> EmitBuiltinUnaryOp(Amt, Result, Intrinsic::ctpop);<br>
> tree return_type = gimple_call_return_type(stmt);<br>
> Type *DestTy = ConvertType(return_type);<br>
> - Result = Builder.CreateIntCast(Result, DestTy,<br>
> - /*isSigned*/ !TYPE_UNSIGNED(return_type),<br>
> - "cast");<br>
> + Result = Builder.CreateIntCast(<br>
> + Result, DestTy, /*isSigned*/ !TYPE_UNSIGNED(return_type), "cast");<br>
> return true;<br>
> }<br>
> case BUILT_IN_BSWAP32:<br>
> @@ -4420,9 +4410,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> EmitBuiltinUnaryOp(Amt, Result, Intrinsic::bswap);<br>
> tree return_type = gimple_call_return_type(stmt);<br>
> Type *DestTy = ConvertType(return_type);<br>
> - Result = Builder.CreateIntCast(Result, DestTy,<br>
> - /*isSigned*/ !TYPE_UNSIGNED(return_type),<br>
> - "cast");<br>
> + Result = Builder.CreateIntCast(<br>
> + Result, DestTy, /*isSigned*/ !TYPE_UNSIGNED(return_type), "cast");<br>
> return true;<br>
> }<br>
><br>
> @@ -4508,17 +4497,16 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // The argument and return type of cttz should match the argument type of<br>
> // the ffs, but should ignore the return type of ffs.<br>
> Value *Amt = EmitMemory(gimple_call_arg(stmt, 0));<br>
> - Result = Builder.CreateCall2(Intrinsic::getDeclaration(<br>
> - TheModule, Intrinsic::cttz, Amt->getType()),<br>
> - Amt, Builder.getTrue());<br>
> + Result = Builder.CreateCall2(<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::cttz, Amt->getType()),<br>
> + Amt, Builder.getTrue());<br>
> Result = Builder.CreateAdd(Result, ConstantInt::get(Result->getType(), 1));<br>
> - Result = Builder.CreateIntCast(Result,<br>
> - ConvertType(gimple_call_return_type(stmt)),<br>
> - /*isSigned*/ false);<br>
> - Value *Cond = Builder.CreateICmpEQ(Amt,<br>
> - Constant::getNullValue(Amt->getType()));<br>
> + Result = Builder.CreateIntCast(<br>
> + Result, ConvertType(gimple_call_return_type(stmt)), /*isSigned*/ false);<br>
> + Value *Cond =<br>
> + Builder.CreateICmpEQ(Amt, Constant::getNullValue(Amt->getType()));<br>
> Result = Builder.CreateSelect(<br>
> - Cond, Constant::getNullValue(Result->getType()), Result);<br>
> + Cond, Constant::getNullValue(Result->getType()), Result);<br>
> return true;<br>
> }<br>
> #if (GCC_MINOR > 6)<br>
> @@ -4954,9 +4942,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Value *C[2] = { EmitMemory(gimple_call_arg(stmt, 0)),<br>
> EmitMemory(gimple_call_arg(stmt, 1)) };<br>
> C[0] = Builder.CreateBitCast(C[0], ResultTy->getPointerTo());<br>
> - C[1] = Builder.CreateIntCast(C[1], ResultTy,<br>
> - /*isSigned*/ !TYPE_UNSIGNED(return_type),<br>
> - "cast");<br>
> + C[1] = Builder.CreateIntCast(<br>
> + C[1], ResultTy, /*isSigned*/ !TYPE_UNSIGNED(return_type), "cast");<br>
> Result = Builder.CreateAtomicRMW(AtomicRMWInst::Nand, C[0], C[1],<br>
> SequentiallyConsistent);<br>
><br>
> @@ -5079,7 +5066,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return false;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinUnaryOp(Value *InVal, Value *&Result,<br>
> + bool TreeToLLVM::EmitBuiltinUnaryOp(Value * InVal, Value * &Result,<br>
> Intrinsic::ID Id) {<br>
> // The intrinsic might be overloaded in which case the argument is of<br>
> // varying type. Make sure that we specify the actual type for "iAny"<br>
> @@ -5094,9 +5081,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Value *TreeToLLVM::EmitBuiltinBitCountIntrinsic(gimple stmt,<br>
> Intrinsic::ID Id) {<br>
> Value *Amt = EmitMemory(gimple_call_arg(stmt, 0));<br>
> - Value *Result = Builder.CreateCall2(Intrinsic::getDeclaration(<br>
> - TheModule, Id, Amt->getType()),<br>
> - Amt, Builder.getTrue());<br>
> + Value *Result = Builder.CreateCall2(<br>
> + Intrinsic::getDeclaration(TheModule, Id, Amt->getType()), Amt,<br>
> + Builder.getTrue());<br>
> tree return_type = gimple_call_return_type(stmt);<br>
> Type *DestTy = ConvertType(return_type);<br>
> return Builder.CreateIntCast(<br>
> @@ -5159,8 +5146,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Then type cast the result of the "ceil" call.<br>
> tree type = gimple_call_return_type(stmt);<br>
> Type *RetTy = getRegType(type);<br>
> - return TYPE_UNSIGNED(type) ? Builder.CreateFPToUI(Call, RetTy) :<br>
> - Builder.CreateFPToSI(Call, RetTy);<br>
> + return TYPE_UNSIGNED(type) ? Builder.CreateFPToUI(Call, RetTy)<br>
> + : Builder.CreateFPToSI(Call, RetTy);<br>
> }<br>
><br>
> Value *TreeToLLVM::EmitBuiltinLFLOOR(gimple stmt) {<br>
> @@ -5179,8 +5166,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Then type cast the result of the "floor" call.<br>
> tree type = gimple_call_return_type(stmt);<br>
> Type *RetTy = getRegType(type);<br>
> - return TYPE_UNSIGNED(type) ? Builder.CreateFPToUI(Call, RetTy) :<br>
> - Builder.CreateFPToSI(Call, RetTy);<br>
> + return TYPE_UNSIGNED(type) ? Builder.CreateFPToUI(Call, RetTy)<br>
> + : Builder.CreateFPToSI(Call, RetTy);<br>
> }<br>
><br>
> Value *TreeToLLVM::EmitBuiltinCEXPI(gimple stmt) {<br>
> @@ -5212,8 +5199,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> #ifdef TARGET_ADJUST_LLVM_CC<br>
> // Query the target for the calling convention to use.<br>
> tree fntype = build_function_type_list(<br>
> - void_type_node, arg_type, TYPE_POINTER_TO(arg_type),<br>
> - TYPE_POINTER_TO(arg_type), NULL_TREE);<br>
> + void_type_node, arg_type, TYPE_POINTER_TO(arg_type),<br>
> + TYPE_POINTER_TO(arg_type), NULL_TREE);<br>
> TARGET_ADJUST_LLVM_CC(CC, fntype);<br>
> #endif<br>
><br>
> @@ -5263,8 +5250,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> // Form the complex number "0 + i*arg".<br>
> Value *Arg = EmitRegister(arg);<br>
> - Value *CplxArg = CreateComplex(Constant::getNullValue(Arg->getType()),<br>
> - Arg);<br>
> + Value *CplxArg =<br>
> + CreateComplex(Constant::getNullValue(Arg->getType()), Arg);<br>
><br>
> // Call cexp and return the result. This is rather painful because complex<br>
> // numbers may be passed in funky ways and we don't have a proper interface<br>
> @@ -5317,8 +5304,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> assert(DL.getTypeAllocSize(CI->getType()) <=<br>
> DL.getTypeAllocSize(CplxTy) &&<br>
> "Complex number returned in too large registers!");<br>
> - Value *Dest = Builder.CreateBitCast(Target.Ptr,<br>
> - CI->getType()->getPointerTo());<br>
> + Value *Dest =<br>
> + Builder.CreateBitCast(Target.Ptr, CI->getType()->getPointerTo());<br>
> LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(CI, Dest, Target.Volatile,<br>
> Builder);<br>
> return Builder.CreateLoad(Target.Ptr);<br>
> @@ -5338,13 +5325,13 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinConstantP(gimple stmt, Value *&Result) {<br>
> - Result = Constant::getNullValue(<br>
> - ConvertType(gimple_call_return_type(stmt)));<br>
> + bool TreeToLLVM::EmitBuiltinConstantP(gimple stmt, Value * &Result) {<br>
> + Result =<br>
> + Constant::getNullValue(ConvertType(gimple_call_return_type(stmt)));<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinExtendPointer(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinExtendPointer(gimple stmt, Value * &Result) {<br>
> tree arg0 = gimple_call_arg(stmt, 0);<br>
> Value *Amt = EmitMemory(arg0);<br>
> bool AmtIsSigned = !TYPE_UNSIGNED(TREE_TYPE(arg0));<br>
> @@ -5359,7 +5346,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> /// size checking builtin calls (e.g. __builtin___memcpy_chk into the<br>
> /// plain non-checking calls. If the size of the argument is either -1 (unknown)<br>
> /// or large enough to ensure no overflow (> len), then it's safe to do so.<br>
> - static bool OptimizeIntoPlainBuiltIn(gimple stmt, Value *Len, Value *Size) {<br>
> + static bool OptimizeIntoPlainBuiltIn(gimple stmt, Value * Len,<br>
> + Value * Size) {<br>
> if (BitCastInst *SizeBC = dyn_cast<BitCastInst>(Size))<br>
> Size = SizeBC->getOperand(0);<br>
> ConstantInt *SizeCI = dyn_cast<ConstantInt>(Size);<br>
> @@ -5384,7 +5372,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> /// EmitBuiltinMemCopy - Emit an llvm.memcpy or llvm.memmove intrinsic,<br>
> /// depending on the value of isMemMove.<br>
> - bool TreeToLLVM::EmitBuiltinMemCopy(gimple stmt, Value *&Result,<br>
> + bool TreeToLLVM::EmitBuiltinMemCopy(gimple stmt, Value * &Result,<br>
> bool isMemMove, bool SizeCheck) {<br>
> if (SizeCheck) {<br>
> if (!validate_gimple_arglist(stmt, POINTER_TYPE, POINTER_TYPE,<br>
> @@ -5411,13 +5399,13 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return false;<br>
> }<br>
><br>
> - Result = isMemMove ?<br>
> - EmitMemMove(DstV, SrcV, Len, std::min(SrcAlign, DstAlign)) :<br>
> - EmitMemCpy(DstV, SrcV, Len, std::min(SrcAlign, DstAlign));<br>
> + Result =<br>
> + isMemMove ? EmitMemMove(DstV, SrcV, Len, std::min(SrcAlign, DstAlign))<br>
> + : EmitMemCpy(DstV, SrcV, Len, std::min(SrcAlign, DstAlign));<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinMemSet(gimple stmt, Value *&Result,<br>
> + bool TreeToLLVM::EmitBuiltinMemSet(gimple stmt, Value * &Result,<br>
> bool SizeCheck) {<br>
> if (SizeCheck) {<br>
> if (!validate_gimple_arglist(stmt, POINTER_TYPE, INTEGER_TYPE,<br>
> @@ -5445,7 +5433,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinBZero(gimple stmt, Value *&/*Result*/) {<br>
> + bool TreeToLLVM::EmitBuiltinBZero(gimple stmt, Value * &/*Result*/) {<br>
> if (!validate_gimple_arglist(stmt, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))<br>
> return false;<br>
><br>
> @@ -5511,21 +5499,21 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> Ptr = Builder.CreateBitCast(Ptr, Type::getInt8PtrTy(Context));<br>
><br>
> - Builder.CreateCall4(Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::prefetch),<br>
> - Ptr, ReadWrite, Locality, Data);<br>
> + Builder.CreateCall4(<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::prefetch), Ptr,<br>
> + ReadWrite, Locality, Data);<br>
> return true;<br>
> }<br>
><br>
> /// EmitBuiltinReturnAddr - Emit an llvm.returnaddress or llvm.frameaddress<br>
> /// instruction, depending on whether isFrame is true or not.<br>
> - bool TreeToLLVM::EmitBuiltinReturnAddr(gimple stmt, Value *&Result,<br>
> + bool TreeToLLVM::EmitBuiltinReturnAddr(gimple stmt, Value * &Result,<br>
> bool isFrame) {<br>
> if (!validate_gimple_arglist(stmt, INTEGER_TYPE, VOID_TYPE))<br>
> return false;<br>
><br>
> - ConstantInt *Level = dyn_cast<ConstantInt>(<br>
> - EmitMemory(gimple_call_arg(stmt, 0)));<br>
> + ConstantInt *Level =<br>
> + dyn_cast<ConstantInt>(EmitMemory(gimple_call_arg(stmt, 0)));<br>
> if (!Level) {<br>
> if (isFrame)<br>
> error("invalid argument to %<__builtin_frame_address%>");<br>
> @@ -5534,16 +5522,17 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return false;<br>
> }<br>
><br>
> - Intrinsic::ID IID = !isFrame ? Intrinsic::returnaddress :<br>
> - Intrinsic::frameaddress;<br>
> - Result = Builder.CreateCall(Intrinsic::getDeclaration(TheModule, IID),<br>
> - Level);<br>
> + Intrinsic::ID IID =<br>
> + !isFrame ? Intrinsic::returnaddress : Intrinsic::frameaddress;<br>
> + Result =<br>
> + Builder.CreateCall(Intrinsic::getDeclaration(TheModule, IID), Level);<br>
> Result = Builder.CreateBitCast(<br>
> - Result, ConvertType(gimple_call_return_type(stmt)));<br>
> + Result, ConvertType(gimple_call_return_type(stmt)));<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinExtractReturnAddr(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinExtractReturnAddr(gimple stmt,<br>
> + Value * &Result) {<br>
> Value *Ptr = EmitMemory(gimple_call_arg(stmt, 0));<br>
><br>
> // FIXME: Actually we should do something like this:<br>
> @@ -5558,7 +5547,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinFrobReturnAddr(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinFrobReturnAddr(gimple stmt, Value * &Result) {<br>
> Value *Ptr = EmitMemory(gimple_call_arg(stmt, 0));<br>
><br>
> // FIXME: Actually we should do something like this:<br>
> @@ -5572,12 +5561,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinStackSave(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinStackSave(gimple stmt, Value * &Result) {<br>
> if (!validate_gimple_arglist(stmt, VOID_TYPE))<br>
> return false;<br>
><br>
> Result = Builder.CreateCall(<br>
> - Intrinsic::getDeclaration(TheModule, Intrinsic::stacksave));<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::stacksave));<br>
> return true;<br>
> }<br>
><br>
> @@ -5600,7 +5589,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinEHFilter(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinEHFilter(gimple stmt, Value * &Result) {<br>
> // Lookup the local that holds the selector value for this region.<br>
> unsigned RegionNo = tree_low_cst(gimple_call_arg(stmt, 0), 0);<br>
> AllocaInst *Filter = getExceptionFilter(RegionNo);<br>
> @@ -5613,7 +5602,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinEHPointer(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinEHPointer(gimple stmt, Value * &Result) {<br>
> // Lookup the local that holds the exception pointer for this region.<br>
> unsigned RegionNo = tree_low_cst(gimple_call_arg(stmt, 0), 0);<br>
> AllocaInst *ExcPtr = getExceptionPtr(RegionNo);<br>
> @@ -5651,21 +5640,21 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> #define HARD_REGNO_CALL_PART_CLOBBERED(REGNO, MODE) 0<br>
> #endif<br>
><br>
> - bool TreeToLLVM::EmitBuiltinDwarfCFA(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinDwarfCFA(gimple stmt, Value * &Result) {<br>
> if (!validate_gimple_arglist(stmt, VOID_TYPE))<br>
> return false;<br>
><br>
> int cfa_offset = ARG_POINTER_CFA_OFFSET(exp);<br>
><br>
> // FIXME: is i32 always enough here?<br>
> - Result = Builder.CreateCall(Intrinsic::getDeclaration(<br>
> - TheModule, Intrinsic::eh_dwarf_cfa),<br>
> - Builder.getInt32(cfa_offset));<br>
> + Result = Builder.CreateCall(<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::eh_dwarf_cfa),<br>
> + Builder.getInt32(cfa_offset));<br>
><br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinDwarfSPColumn(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinDwarfSPColumn(gimple stmt, Value * &Result) {<br>
> if (!validate_gimple_arglist(stmt, VOID_TYPE))<br>
> return false;<br>
><br>
> @@ -5676,7 +5665,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinEHReturnDataRegno(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinEHReturnDataRegno(gimple stmt,<br>
> + Value * &Result) {<br>
> #ifdef EH_RETURN_DATA_REGNO<br>
> if (!validate_gimple_arglist(stmt, INTEGER_TYPE, VOID_TYPE))<br>
> return false;<br>
> @@ -5696,14 +5686,14 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> iwhich = DWARF_FRAME_REGNUM(iwhich);<br>
><br>
> - Result = ConstantInt::get(ConvertType(gimple_call_return_type(stmt)),<br>
> - iwhich);<br>
> + Result =<br>
> + ConstantInt::get(ConvertType(gimple_call_return_type(stmt)), iwhich);<br>
> #endif<br>
><br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinEHReturn(gimple stmt, Value *&/*Result*/) {<br>
> + bool TreeToLLVM::EmitBuiltinEHReturn(gimple stmt, Value * &/*Result*/) {<br>
> if (!validate_gimple_arglist(stmt, INTEGER_TYPE, POINTER_TYPE, VOID_TYPE))<br>
> return false;<br>
><br>
> @@ -5711,8 +5701,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Value *Offset = EmitMemory(gimple_call_arg(stmt, 0));<br>
> Value *Handler = EmitMemory(gimple_call_arg(stmt, 1));<br>
><br>
> - Intrinsic::ID IID = IntPtr->isIntegerTy(32) ? Intrinsic::eh_return_i32 :<br>
> - Intrinsic::eh_return_i64;<br>
> + Intrinsic::ID IID = IntPtr->isIntegerTy(32) ? Intrinsic::eh_return_i32<br>
> + : Intrinsic::eh_return_i64;<br>
><br>
> Offset = Builder.CreateIntCast(Offset, IntPtr, /*isSigned*/ true);<br>
> Handler = Builder.CreateBitCast(Handler, Type::getInt8PtrTy(Context));<br>
> @@ -5726,7 +5716,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
><br>
> bool TreeToLLVM::EmitBuiltinInitDwarfRegSizes(gimple stmt,<br>
> - Value *&/*Result*/) {<br>
> + Value * &/*Result*/) {<br>
> #ifdef DWARF2_UNWIND_INFO<br>
> unsigned int i;<br>
> bool wrote_return_column = false;<br>
> @@ -5764,9 +5754,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> Size = Builder.getInt8(size);<br>
> Idx = Builder.getInt32(rnum);<br>
> - Builder.CreateStore(Size,<br>
> - Builder.CreateGEP(Addr, Idx, flag_verbose_asm ?<br>
> - "rnum" : ""), false);<br>
> + Builder.CreateStore(<br>
> + Size, Builder.CreateGEP(Addr, Idx,<br>
> + flag_verbose_asm ? "rnum" : ""), false);<br>
> }<br>
> }<br>
><br>
> @@ -5781,8 +5771,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> #ifdef DWARF_ALT_FRAME_RETURN_COLUMN<br>
> Size = Builder.getInt8(GET_MODE_SIZE(Pmode));<br>
> Idx = Builder.getInt32(DWARF_ALT_FRAME_RETURN_COLUMN);<br>
> - Builder.CreateStore(Size, Builder.CreateGEP(Addr, Idx, flag_verbose_asm ?<br>
> - "acol" : ""), false);<br>
> + Builder.CreateStore(<br>
> + Size, Builder.CreateGEP(Addr, Idx, flag_verbose_asm ? "acol" : ""),<br>
> + false);<br>
> #endif<br>
><br>
> #endif /* DWARF2_UNWIND_INFO */<br>
> @@ -5792,12 +5783,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinUnwindInit(gimple stmt, Value *&/*Result*/) {<br>
> + bool TreeToLLVM::EmitBuiltinUnwindInit(gimple stmt, Value * &/*Result*/) {<br>
> if (!validate_gimple_arglist(stmt, VOID_TYPE))<br>
> return false;<br>
><br>
> - Builder.CreateCall(Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::eh_unwind_init));<br>
> + Builder.CreateCall(<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::eh_unwind_init));<br>
><br>
> return true;<br>
> }<br>
> @@ -5814,7 +5805,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinAlloca(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinAlloca(gimple stmt, Value * &Result) {<br>
> if (!validate_gimple_arglist(stmt, INTEGER_TYPE, VOID_TYPE))<br>
> return false;<br>
> Value *Amt = EmitMemory(gimple_call_arg(stmt, 0));<br>
> @@ -5824,7 +5815,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinAllocaWithAlign(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinAllocaWithAlign(gimple stmt, Value * &Result) {<br>
> if (!validate_gimple_arglist(stmt, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))<br>
> return false;<br>
> Value *Amt = EmitMemory(gimple_call_arg(stmt, 0));<br>
> @@ -5836,29 +5827,29 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
><br>
> #if (GCC_MINOR > 6)<br>
> - bool TreeToLLVM::EmitBuiltinAssumeAligned(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinAssumeAligned(gimple stmt, Value * &Result) {<br>
> if (!validate_gimple_arglist(stmt, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))<br>
> return false;<br>
> // Return the pointer argument. TODO: Pass the alignment information on to<br>
> // the optimizers.<br>
> Value *Ptr = EmitRegister(gimple_call_arg(stmt, 0));<br>
> // Bitcast it to the return type.<br>
> - Ptr = TriviallyTypeConvert(Ptr,<br>
> - getRegType(gimple_call_return_type(stmt)));<br>
> + Ptr =<br>
> + TriviallyTypeConvert(Ptr, getRegType(gimple_call_return_type(stmt)));<br>
> Result = Reg2Mem(Ptr, gimple_call_return_type(stmt), Builder);<br>
> return true;<br>
> }<br>
> #endif<br>
><br>
> - bool TreeToLLVM::EmitBuiltinExpect(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinExpect(gimple stmt, Value * &Result) {<br>
> tree type = gimple_call_return_type(stmt);<br>
> if (gimple_call_num_args(stmt) < 2) {<br>
> Result = Constant::getNullValue(ConvertType(type));<br>
> return true;<br>
> }<br>
> Type *ArgTy = getRegType(type);<br>
> - Value *ExpectIntr = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::expect, ArgTy);<br>
> + Value *ExpectIntr =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::expect, ArgTy);<br>
> Value *ArgValue = EmitRegister(gimple_call_arg(stmt, 0));<br>
> Value *ExpectedValue = EmitRegister(gimple_call_arg(stmt, 1));<br>
> Result = Builder.CreateCall2(ExpectIntr, ArgValue, ExpectedValue);<br>
> @@ -5879,8 +5870,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - Constant *va_start = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::vastart);<br>
> + Constant *va_start =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::vastart);<br>
> Value *ArgVal = EmitMemory(gimple_call_arg(stmt, 0));<br>
> ArgVal = Builder.CreateBitCast(ArgVal, Type::getInt8PtrTy(Context));<br>
> Builder.CreateCall(va_start, ArgVal);<br>
> @@ -5926,12 +5917,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return true;<br>
> }<br>
><br>
> - bool TreeToLLVM::EmitBuiltinAdjustTrampoline(gimple stmt, Value *&Result) {<br>
> + bool TreeToLLVM::EmitBuiltinAdjustTrampoline(gimple stmt, Value * &Result) {<br>
> if (!validate_gimple_arglist(stmt, POINTER_TYPE, VOID_TYPE))<br>
> return false;<br>
><br>
> - Function *Intr = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::adjust_trampoline);<br>
> + Function *Intr =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::adjust_trampoline);<br>
> Value *Arg = Builder.CreateBitCast(EmitRegister(gimple_call_arg(stmt, 0)),<br>
> Builder.getInt8PtrTy());<br>
> Result = Builder.CreateCall(Intr, Arg);<br>
> @@ -5939,7 +5930,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
><br>
> bool TreeToLLVM::EmitBuiltinInitTrampoline(gimple stmt,<br>
> - Value *&/*Result*/) {<br>
> + Value * &/*Result*/) {<br>
> if (!validate_gimple_arglist(stmt, POINTER_TYPE, POINTER_TYPE,<br>
> POINTER_TYPE, VOID_TYPE))<br>
> return false;<br>
> @@ -5953,8 +5944,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Builder.CreateBitCast(Func, VPTy),<br>
> Builder.CreateBitCast(Chain, VPTy) };<br>
><br>
> - Function *Intr = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::init_trampoline);<br>
> + Function *Intr =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::init_trampoline);<br>
> Builder.CreateCall(Intr, Ops);<br>
> return true;<br>
> }<br>
> @@ -5963,7 +5954,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // ... Complex Math Expressions ...<br>
> //===----------------------------------------------------------------------===//<br>
><br>
> - Value *TreeToLLVM::CreateComplex(Value *Real, Value *Imag) {<br>
> + Value *TreeToLLVM::CreateComplex(Value * Real, Value * Imag) {<br>
> assert(Real->getType() == Imag->getType() && "Component type mismatch!");<br>
> Type *EltTy = Real->getType();<br>
> Value *Result = UndefValue::get(StructType::get(EltTy, EltTy, NULL));<br>
> @@ -5972,7 +5963,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> return Result;<br>
> }<br>
><br>
> - void TreeToLLVM::SplitComplex(Value *Complex, Value *&Real, Value *&Imag) {<br>
> + void TreeToLLVM::SplitComplex(Value * Complex, Value * &Real,<br>
> + Value * &Imag) {<br>
> Real = Builder.CreateExtractValue(Complex, 0);<br>
> Imag = Builder.CreateExtractValue(Complex, 1);<br>
> }<br>
> @@ -5981,14 +5973,14 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // ... L-Value Expressions ...<br>
> //===----------------------------------------------------------------------===//<br>
><br>
> - Value *TreeToLLVM::EmitFieldAnnotation(Value *FieldPtr, tree FieldDecl) {<br>
> - tree AnnotateAttr = lookup_attribute("annotate",<br>
> - DECL_ATTRIBUTES(FieldDecl));<br>
> + Value *TreeToLLVM::EmitFieldAnnotation(Value * FieldPtr, tree FieldDecl) {<br>
> + tree AnnotateAttr =<br>
> + lookup_attribute("annotate", DECL_ATTRIBUTES(FieldDecl));<br>
><br>
> Type *SBP = Type::getInt8PtrTy(Context);<br>
><br>
> - Function *An = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::ptr_annotation, SBP);<br>
> + Function *An =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::ptr_annotation, SBP);<br>
><br>
> // Get file and line number. FIXME: Should this be for the decl or the<br>
> // use. Is there a location info for the use?<br>
> @@ -6021,8 +6013,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // the GEP that is critical to distinguish between an annotate<br>
> // attribute on a whole struct from one on the first element of the<br>
> // struct.<br>
> - BitCastInst *CastFieldPtr = new BitCastInst(FieldPtr, SBP,<br>
> - FieldPtr->getName());<br>
> + BitCastInst *CastFieldPtr =<br>
> + new BitCastInst(FieldPtr, SBP, FieldPtr->getName());<br>
> Builder.Insert(CastFieldPtr);<br>
><br>
> Value *Ops[4] = { CastFieldPtr, Builder.CreateBitCast(strGV, SBP),<br>
> @@ -6061,8 +6053,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> tree LowerBound = array_ref_low_bound(exp);<br>
> if (!integer_zerop(LowerBound))<br>
> IndexVal = Builder.CreateSub(<br>
> - IndexVal, EmitRegisterWithCast(LowerBound, IndexType),<br>
> - "", hasNUW(TREE_TYPE(Index)), hasNSW(TREE_TYPE(Index)));<br>
> + IndexVal, EmitRegisterWithCast(LowerBound, IndexType), "",<br>
> + hasNUW(TREE_TYPE(Index)), hasNSW(TREE_TYPE(Index)));<br>
><br>
> LValue ArrayAddrLV = EmitLV(Array);<br>
> assert(!ArrayAddrLV.isBitfield() && "Arrays cannot be bitfields!");<br>
> @@ -6080,14 +6072,14 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Type *EltTy = ConvertType(ElementType);<br>
> ArrayAddr = Builder.CreateBitCast(ArrayAddr, EltTy->getPointerTo());<br>
> StringRef GEPName = flag_verbose_asm ? "ar" : "";<br>
> - Value *Ptr = POINTER_TYPE_OVERFLOW_UNDEFINED ?<br>
> - Builder.CreateInBoundsGEP(ArrayAddr, IndexVal, GEPName) :<br>
> - Builder.CreateGEP(ArrayAddr, IndexVal, GEPName);<br>
> - unsigned Alignment = MinAlign(ArrayAlign,<br>
> - DL.getABITypeAlignment(EltTy));<br>
> - return LValue(Builder.CreateBitCast(<br>
> - Ptr, PointerType::getUnqual(ConvertType(TREE_TYPE(exp)))),<br>
> - Alignment);<br>
> + Value *Ptr = POINTER_TYPE_OVERFLOW_UNDEFINED<br>
> + ? Builder.CreateInBoundsGEP(ArrayAddr, IndexVal, GEPName)<br>
> + : Builder.CreateGEP(ArrayAddr, IndexVal, GEPName);<br>
> + unsigned Alignment =<br>
> + MinAlign(ArrayAlign, DL.getABITypeAlignment(EltTy));<br>
> + return LValue(<br>
> + Builder.CreateBitCast(Ptr, PointerType::getUnqual(ConvertType(<br>
> + TREE_TYPE(exp)))), Alignment);<br>
> }<br>
><br>
> // Otherwise, just do raw, low-level pointer arithmetic. FIXME: this could be<br>
> @@ -6095,12 +6087,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // float foo(int w, float A[][w], int g) { return A[g][0]; }<br>
><br>
> if (isa<VOID_TYPE>(TREE_TYPE(ArrayTreeType))) {<br>
> - ArrayAddr = Builder.CreateBitCast(ArrayAddr,<br>
> - Type::getInt8PtrTy(Context));<br>
> + ArrayAddr =<br>
> + Builder.CreateBitCast(ArrayAddr, Type::getInt8PtrTy(Context));<br>
> StringRef GEPName = flag_verbose_asm ? "va" : "";<br>
> - ArrayAddr = POINTER_TYPE_OVERFLOW_UNDEFINED ?<br>
> - Builder.CreateInBoundsGEP(ArrayAddr, IndexVal, GEPName) :<br>
> - Builder.CreateGEP(ArrayAddr, IndexVal, GEPName);<br>
> + ArrayAddr = POINTER_TYPE_OVERFLOW_UNDEFINED<br>
> + ? Builder.CreateInBoundsGEP(ArrayAddr, IndexVal, GEPName)<br>
> + : Builder.CreateGEP(ArrayAddr, IndexVal, GEPName);<br>
> return LValue(ArrayAddr, 1);<br>
> }<br>
><br>
> @@ -6111,8 +6103,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // ScaleFactor is the size of the element type in units divided by (exactly)<br>
> // TYPE_ALIGN_UNIT(ElementType).<br>
> Value *ScaleFactor = Builder.CreateIntCast(<br>
> - EmitRegister(TREE_OPERAND(exp, 3)), IntPtrTy,<br>
> - /*isSigned*/ false);<br>
> + EmitRegister(TREE_OPERAND(exp, 3)), IntPtrTy, /*isSigned*/ false);<br>
> assert(isPowerOf2_32(TYPE_ALIGN(ElementType)) &&<br>
> "Alignment not a power of two!");<br>
> assert(TYPE_ALIGN(ElementType) >= 8 &&<br>
> @@ -6124,11 +6115,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> IndexVal = Builder.CreateMul(IndexVal, ScaleFactor);<br>
> unsigned Alignment = MinAlign(ArrayAlign, TYPE_ALIGN(ElementType) / 8);<br>
> StringRef GEPName = flag_verbose_asm ? "ra" : "";<br>
> - Value *Ptr = POINTER_TYPE_OVERFLOW_UNDEFINED ?<br>
> - Builder.CreateInBoundsGEP(ArrayAddr, IndexVal, GEPName) :<br>
> - Builder.CreateGEP(ArrayAddr, IndexVal, GEPName);<br>
> - return LValue(Builder.CreateBitCast(<br>
> - Ptr, PointerType::getUnqual(ConvertType(TREE_TYPE(exp)))), Alignment);<br>
> + Value *Ptr = POINTER_TYPE_OVERFLOW_UNDEFINED<br>
> + ? Builder.CreateInBoundsGEP(ArrayAddr, IndexVal, GEPName)<br>
> + : Builder.CreateGEP(ArrayAddr, IndexVal, GEPName);<br>
> + return LValue(<br>
> + Builder.CreateBitCast(Ptr, PointerType::getUnqual(ConvertType(<br>
> + TREE_TYPE(exp)))), Alignment);<br>
> }<br>
><br>
> LValue TreeToLLVM::EmitLV_BIT_FIELD_REF(tree exp) {<br>
> @@ -6184,14 +6176,14 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> assert((!StructAddrLV.isBitfield() || StructAddrLV.BitStart == 0) &&<br>
> "structs cannot be bitfields!");<br>
><br>
> - StructAddrLV.Ptr = Builder.CreateBitCast(StructAddrLV.Ptr,<br>
> - StructTy->getPointerTo());<br>
> + StructAddrLV.Ptr =<br>
> + Builder.CreateBitCast(StructAddrLV.Ptr, StructTy->getPointerTo());<br>
> Type *FieldTy = ConvertType(TREE_TYPE(FieldDecl));<br>
><br>
> // BitStart - This is the actual offset of the field from the start of the<br>
> // struct, in bits. For bitfields this may be on a non-byte boundary.<br>
> - uint64_t FieldBitOffset = getInt64(DECL_FIELD_BIT_OFFSET(FieldDecl),<br>
> - true);<br>
> + uint64_t FieldBitOffset =<br>
> + getInt64(DECL_FIELD_BIT_OFFSET(FieldDecl), true);<br>
> unsigned BitStart;<br>
> Value *FieldPtr;<br>
><br>
> @@ -6215,7 +6207,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> unsigned factor = DECL_OFFSET_ALIGN(FieldDecl) / 8;<br>
> if (factor != 1)<br>
> Offset = Builder.CreateMul(<br>
> - Offset, ConstantInt::get(Offset->getType(), factor));<br>
> + Offset, ConstantInt::get(Offset->getType(), factor));<br>
> } else {<br>
> assert(DECL_FIELD_OFFSET(FieldDecl) && "Field offset not available!");<br>
> Offset = EmitRegister(DECL_FIELD_OFFSET(FieldDecl));<br>
> @@ -6223,7 +6215,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> unsigned factor = BITS_PER_UNIT / 8;<br>
> if (factor != 1)<br>
> Offset = Builder.CreateMul(<br>
> - Offset, ConstantInt::get(Offset->getType(), factor));<br>
> + Offset, ConstantInt::get(Offset->getType(), factor));<br>
> }<br>
><br>
> // Here BitStart gives the offset of the field in bits from Offset.<br>
> @@ -6232,8 +6224,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Incorporate as much of it as possible into the pointer computation.<br>
> unsigned ByteOffset = BitStart / 8;<br>
> if (ByteOffset > 0) {<br>
> - Offset = Builder.CreateAdd(Offset, ConstantInt::get(Offset->getType(),<br>
> - ByteOffset));<br>
> + Offset = Builder.CreateAdd(<br>
> + Offset, ConstantInt::get(Offset->getType(), ByteOffset));<br>
> BitStart -= ByteOffset * 8;<br>
> }<br>
><br>
> @@ -6297,12 +6289,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> LValue TreeToLLVM::EmitLV_INDIRECT_REF(tree exp) {<br>
> // The lvalue is just the address.<br>
> - LValue LV = LValue(EmitRegister(TREE_OPERAND(exp, 0)),<br>
> - expr_align(exp) / 8);<br>
> + LValue LV =<br>
> + LValue(EmitRegister(TREE_OPERAND(exp, 0)), expr_align(exp) / 8);<br>
> // May need to change pointer type, for example when INDIRECT_REF is applied<br>
> // to a void*, resulting in a non-void type.<br>
> - LV.Ptr = Builder.CreateBitCast(LV.Ptr, ConvertType(TREE_TYPE(exp))<br>
> - ->getPointerTo());<br>
> + LV.Ptr = Builder<br>
> + .CreateBitCast(LV.Ptr, ConvertType(TREE_TYPE(exp))->getPointerTo());<br>
> return LV;<br>
> }<br>
><br>
> @@ -6315,9 +6307,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Addr = Builder.CreateBitCast(Addr, GetUnitPointerType(Context));<br>
> APInt Offset = getAPIntValue(TREE_OPERAND(exp, 1));<br>
> // The address is always inside the referenced object, so "inbounds".<br>
> - Addr = Builder.CreateInBoundsGEP(Addr,<br>
> - ConstantInt::get(Context, Offset),<br>
> - flag_verbose_asm ? "mrf" : "");<br>
> + Addr =<br>
> + Builder.CreateInBoundsGEP(Addr, ConstantInt::get(Context, Offset),<br>
> + flag_verbose_asm ? "mrf" : "");<br>
> }<br>
><br>
> // Ensure the pointer has the right type.<br>
> @@ -6352,8 +6344,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> LValue LV = LValue(EmitRegister(TREE_OPERAND(exp, 0)), Alignment / 8);<br>
> // May need to change pointer type, for example when MISALIGNED_INDIRECT_REF<br>
> // is applied to a void*, resulting in a non-void type.<br>
> - LV.Ptr = Builder.CreateBitCast(LV.Ptr, ConvertType(TREE_TYPE(exp))<br>
> - ->getPointerTo());<br>
> + LV.Ptr = Builder<br>
> + .CreateBitCast(LV.Ptr, ConvertType(TREE_TYPE(exp))->getPointerTo());<br>
> return LV;<br>
> }<br>
> #endif<br>
> @@ -6362,8 +6354,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // The address is the address of the operand.<br>
> LValue LV = EmitLV(TREE_OPERAND(exp, 0));<br>
> // The type is the type of the expression.<br>
> - LV.Ptr = Builder.CreateBitCast(LV.Ptr, ConvertType(TREE_TYPE(exp))<br>
> - ->getPointerTo());<br>
> + LV.Ptr = Builder<br>
> + .CreateBitCast(LV.Ptr, ConvertType(TREE_TYPE(exp))->getPointerTo());<br>
> return LV;<br>
> }<br>
><br>
> @@ -6384,8 +6376,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // IMAGPART alignment = MinAlign(Ptr.Alignment, sizeof field);<br>
> Alignment = MinAlign(Ptr.getAlignment(),<br>
> DL.getTypeAllocSize(Ptr.Ptr->getType()));<br>
> - return LValue(Builder.CreateStructGEP(Ptr.Ptr, Idx, flag_verbose_asm ?<br>
> - "prtxpr" : ""), Alignment);<br>
> + return LValue(Builder.CreateStructGEP(Ptr.Ptr, Idx,<br>
> + flag_verbose_asm ? "prtxpr" : ""),<br>
> + Alignment);<br>
> }<br>
><br>
> LValue TreeToLLVM::EmitLV_SSA_NAME(tree exp) {<br>
> @@ -6428,8 +6421,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
><br>
> if (TMR_OFFSET(exp) && !integer_zerop(TMR_OFFSET(exp))) {<br>
> - Constant *Off = ConstantInt::get(Context,<br>
> - getAPIntValue(TMR_OFFSET(exp)));<br>
> + Constant *Off =<br>
> + ConstantInt::get(Context, getAPIntValue(TMR_OFFSET(exp)));<br>
> Delta = Delta ? Builder.CreateAdd(Delta, Off) : Off;<br>
> }<br>
><br>
> @@ -6437,9 +6430,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Advance the base pointer by the given number of units.<br>
> Addr = Builder.CreateBitCast(Addr, GetUnitPointerType(Context));<br>
> StringRef GEPName = flag_verbose_asm ? "" : "tmrf";<br>
> - Addr = POINTER_TYPE_OVERFLOW_UNDEFINED ?<br>
> - Builder.CreateInBoundsGEP(Addr, Delta, GEPName) :<br>
> - Builder.CreateGEP(Addr, Delta, GEPName);<br>
> + Addr = POINTER_TYPE_OVERFLOW_UNDEFINED<br>
> + ? Builder.CreateInBoundsGEP(Addr, Delta, GEPName)<br>
> + : Builder.CreateGEP(Addr, Delta, GEPName);<br>
> }<br>
><br>
> // The result can be of a different pointer type even if we didn't advance it.<br>
> @@ -6470,8 +6463,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> /// EmitMinInvariant - The given value is constant in this function. Return the<br>
> /// corresponding LLVM value. Only creates code in the entry block.<br>
> Value *TreeToLLVM::EmitMinInvariant(tree reg) {<br>
> - Value *V = isa<ADDR_EXPR>(reg) ? EmitInvariantAddress(reg) :<br>
> - EmitRegisterConstant(reg);<br>
> + Value *V = isa<ADDR_EXPR>(reg) ? EmitInvariantAddress(reg)<br>
> + : EmitRegisterConstant(reg);<br>
> assert(V->getType() == getRegType(TREE_TYPE(reg)) &&<br>
> "Gimple min invariant has wrong type!");<br>
> return V;<br>
> @@ -6572,7 +6565,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> /// The following kinds of expressions are currently supported: INTEGER_CST,<br>
> /// REAL_CST, COMPLEX_CST, VECTOR_CST, STRING_CST.<br>
> static unsigned EncodeExpr(tree exp,<br>
> - SmallVectorImpl<unsigned char> &Buffer) {<br>
> + SmallVectorImpl<unsigned char> & Buffer) {<br>
> const tree type = TREE_TYPE(exp);<br>
> unsigned SizeInBytes = (TREE_INT_CST_LOW(TYPE_SIZE(type)) + 7) / 8;<br>
> Buffer.resize(SizeInBytes);<br>
> @@ -6601,8 +6594,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // a generalized cast here<br>
> Type *Ty = getRegType(TREE_TYPE(reg));<br>
> Instruction::CastOps opcode = CastInst::getCastOpcode(<br>
> - CI, false, Ty,<br>
> - !TYPE_UNSIGNED(TREE_TYPE(reg)));<br>
> + CI, false, Ty, !TYPE_UNSIGNED(TREE_TYPE(reg)));<br>
> return TheFolder->CreateCast(opcode, CI, Ty);<br>
> }<br>
><br>
> @@ -6691,7 +6683,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> /// VectorHighElements - Return a vector of half the length, consisting of the<br>
> /// elements of the given vector with indices in the top half.<br>
> - Value *TreeToLLVM::VectorHighElements(Value *Vec) {<br>
> + Value *TreeToLLVM::VectorHighElements(Value * Vec) {<br>
> VectorType *Ty = cast<VectorType>(Vec->getType());<br>
> assert(!(Ty->getNumElements() & 1) &&<br>
> "Vector has odd number of elements!");<br>
> @@ -6706,7 +6698,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> /// VectorLowElements - Return a vector of half the length, consisting of the<br>
> /// elements of the given vector with indices in the bottom half.<br>
> - Value *TreeToLLVM::VectorLowElements(Value *Vec) {<br>
> + Value *TreeToLLVM::VectorLowElements(Value * Vec) {<br>
> VectorType *Ty = cast<VectorType>(Vec->getType());<br>
> assert(!(Ty->getNumElements() & 1) &&<br>
> "Vector has odd number of elements!");<br>
> @@ -6809,8 +6801,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> // Use it to load the parameter value.<br>
> MemRef ParamLoc(DECL_LOCAL_IF_SET(var), Alignment, false);<br>
> - Value *Def = LoadRegisterFromMemory(ParamLoc, TREE_TYPE(reg), 0,<br>
> - SSABuilder);<br>
> + Value *Def =<br>
> + LoadRegisterFromMemory(ParamLoc, TREE_TYPE(reg), 0, SSABuilder);<br>
><br>
> if (flag_verbose_asm)<br>
> NameValue(Def, reg);<br>
> @@ -6822,11 +6814,11 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> if (!isa<FLOAT_TYPE>(TREE_TYPE(op))) {<br>
> Value *Op = EmitRegister(op);<br>
> Value *OpN = Builder.CreateNeg(Op, Op->getName() + "neg");<br>
> - ICmpInst::Predicate pred = TYPE_UNSIGNED(TREE_TYPE(op)) ?<br>
> - ICmpInst::ICMP_UGE : ICmpInst::ICMP_SGE;<br>
> - Value *Cmp = Builder.CreateICmp(pred, Op,<br>
> - Constant::getNullValue(Op->getType()),<br>
> - "abscond");<br>
> + ICmpInst::Predicate pred =<br>
> + TYPE_UNSIGNED(TREE_TYPE(op)) ? ICmpInst::ICMP_UGE<br>
> + : ICmpInst::ICMP_SGE;<br>
> + Value *Cmp = Builder.CreateICmp(<br>
> + pred, Op, Constant::getNullValue(Op->getType()), "abscond");<br>
> return Builder.CreateSelect(Cmp, Op, OpN, Op->getName() + "abs");<br>
> }<br>
><br>
> @@ -7064,10 +7056,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Value *Val = EmitRegister(op);<br>
> Type *Ty = Val->getType();<br>
><br>
> - CmpInst::Predicate Pred = CmpInst::Predicate(<br>
> - isa<FLOAT_TYPE>(TREE_TYPE(op)) ? FPPred :<br>
> - TYPE_UNSIGNED(TREE_TYPE(op)) ? UIPred :<br>
> - SIPred);<br>
> + CmpInst::Predicate Pred = CmpInst::Predicate(isa<FLOAT_TYPE>(TREE_TYPE(<br>
> + op)) ? FPPred : TYPE_UNSIGNED(TREE_TYPE(op)) ? UIPred : SIPred);<br>
><br>
> unsigned Length = (unsigned) TYPE_VECTOR_SUBPARTS(TREE_TYPE(op));<br>
> assert(Length > 1 && !(Length & (Length - 1)) &&<br>
> @@ -7090,9 +7080,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> ConstantVector::get(Mask));<br>
><br>
> // Replace Val with the max/min of the extracted elements.<br>
> - Value *Compare = isa<FLOAT_TYPE>(TREE_TYPE(op)) ?<br>
> - Builder.CreateFCmp(Pred, LHS, RHS) :<br>
> - Builder.CreateICmp(Pred, LHS, RHS);<br>
> + Value *Compare =<br>
> + isa<FLOAT_TYPE>(TREE_TYPE(op)) ? Builder.CreateFCmp(Pred, LHS, RHS)<br>
> + : Builder.CreateICmp(Pred, LHS, RHS);<br>
> Val = Builder.CreateSelect(Compare, LHS, RHS);<br>
><br>
> // Repeat, using half as many elements.<br>
> @@ -7153,14 +7143,13 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Amt->getName() + ".cast");<br>
><br>
> Value *TypeSize = ConstantInt::get(<br>
> - In->getType(),<br>
> - In->getType()->getPrimitiveSizeInBits());<br>
> + In->getType(), In->getType()->getPrimitiveSizeInBits());<br>
><br>
> // Do the two shifts.<br>
> Value *V1 = Builder.CreateBinOp((Instruction::BinaryOps) Opc1, In, Amt);<br>
> Value *OtherShift = Builder.CreateSub(TypeSize, Amt);<br>
> - Value *V2 = Builder.CreateBinOp((Instruction::BinaryOps) Opc2, In,<br>
> - OtherShift);<br>
> + Value *V2 =<br>
> + Builder.CreateBinOp((Instruction::BinaryOps) Opc2, In, OtherShift);<br>
><br>
> // Or the two together to return them.<br>
> Value *Merge = Builder.CreateOr(V1, V2);<br>
> @@ -7221,8 +7210,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> unsigned EltBits = VecTy->getElementType()->getPrimitiveSizeInBits();<br>
> if (!(ShiftAmt % EltBits)) {<br>
> // A shift by an integral number of elements.<br>
> - unsigned EltOffset = ShiftAmt /<br>
> - EltBits; // Shift by this many elements.<br>
> + unsigned EltOffset =<br>
> + ShiftAmt / EltBits; // Shift by this many elements.<br>
> // Shuffle the elements sideways by the appropriate number of elements.<br>
> unsigned Length = VecTy->getNumElements();<br>
> SmallVector<Constant *, 8> Mask;<br>
> @@ -7255,8 +7244,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Amt->getName() + ".cast");<br>
><br>
> // Perform the shift.<br>
> - LHS = Builder.CreateBinOp(isLeftShift ? Instruction::Shl :<br>
> - Instruction::LShr, LHS, Amt);<br>
> + LHS = Builder.CreateBinOp(isLeftShift ? Instruction::Shl<br>
> + : Instruction::LShr, LHS, Amt);<br>
><br>
> // Turn the result back into a vector.<br>
> return Builder.CreateBitCast(LHS, VecTy);<br>
> @@ -7308,8 +7297,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Determine the signs of LHS and RHS, and whether they have the same sign.<br>
> Value *LHSIsPositive = Builder.CreateICmpSGE(LHS, Zero);<br>
> Value *RHSIsPositive = Builder.CreateICmpSGE(RHS, Zero);<br>
> - Value *HaveSameSign = Builder.CreateICmpEQ(LHSIsPositive,<br>
> - RHSIsPositive);<br>
> + Value *HaveSameSign =<br>
> + Builder.CreateICmpEQ(LHSIsPositive, RHSIsPositive);<br>
><br>
> // Offset equals 1 if LHS and RHS have the same sign and LHS is not zero.<br>
> Value *LHSNotZero = Builder.CreateICmpNE(LHS, Zero);<br>
> @@ -7372,15 +7361,15 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // reason for accessing tree operands directly rather than taking advantage<br>
> // of COND_EXPR_COND and friends is that the latter fail for VEC_COND_EXPR,<br>
> // which is also handled here.<br>
> - Value *CondVal = COMPARISON_CLASS_P(op0) ?<br>
> - EmitCompare(TREE_OPERAND(op0, 0), TREE_OPERAND(op0, 1),<br>
> - TREE_CODE(op0)) :<br>
> - EmitRegister(op0);<br>
> + Value *CondVal = COMPARISON_CLASS_P(op0)<br>
> + ? EmitCompare(TREE_OPERAND(op0, 0), TREE_OPERAND(op0, 1),<br>
> + TREE_CODE(op0))<br>
> + : EmitRegister(op0);<br>
><br>
> // Ensure the condition has i1 type.<br>
> if (!CondVal->getType()->getScalarType()->isIntegerTy(1))<br>
> CondVal = Builder.CreateICmpNE(<br>
> - CondVal, Constant::getNullValue(CondVal->getType()));<br>
> + CondVal, Constant::getNullValue(CondVal->getType()));<br>
><br>
> // Emit the true and false values.<br>
> Value *TrueVal = EmitRegister(op1);<br>
> @@ -7570,9 +7559,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Convert the pointer into an i8* and add the offset to it.<br>
> Ptr = Builder.CreateBitCast(Ptr, GetUnitPointerType(Context));<br>
> StringRef GEPName = flag_verbose_asm ? "pp" : "";<br>
> - return POINTER_TYPE_OVERFLOW_UNDEFINED ?<br>
> - Builder.CreateInBoundsGEP(Ptr, Idx, GEPName) :<br>
> - Builder.CreateGEP(Ptr, Idx, GEPName);<br>
> + return POINTER_TYPE_OVERFLOW_UNDEFINED<br>
> + ? Builder.CreateInBoundsGEP(Ptr, Idx, GEPName)<br>
> + : Builder.CreateGEP(Ptr, Idx, GEPName);<br>
> }<br>
><br>
> Value *TreeToLLVM::EmitReg_RDIV_EXPR(tree op0, tree op1) {<br>
> @@ -7645,8 +7634,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Determine the signs of LHS and RHS, and whether they have the same sign.<br>
> Value *LHSIsPositive = Builder.CreateICmpSGE(LHS, Zero);<br>
> Value *RHSIsPositive = Builder.CreateICmpSGE(RHS, Zero);<br>
> - Value *HaveSameSign = Builder.CreateICmpEQ(LHSIsPositive,<br>
> - RHSIsPositive);<br>
> + Value *HaveSameSign =<br>
> + Builder.CreateICmpEQ(LHSIsPositive, RHSIsPositive);<br>
><br>
> // Calculate |LHS| ...<br>
> Value *MinusLHS = Builder.CreateNeg(LHS);<br>
> @@ -7725,14 +7714,14 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c<br>
> Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d<br>
> Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd<br>
> - DSTr = TYPE_UNSIGNED(elt_type) ? Builder.CreateUDiv(Tmp3, Tmp6) :<br>
> - Builder.CreateSDiv(Tmp3, Tmp6);<br>
> + DSTr = TYPE_UNSIGNED(elt_type) ? Builder.CreateUDiv(Tmp3, Tmp6)<br>
> + : Builder.CreateSDiv(Tmp3, Tmp6);<br>
><br>
> Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c<br>
> Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d<br>
> Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad<br>
> - DSTi = TYPE_UNSIGNED(elt_type) ? Builder.CreateUDiv(Tmp9, Tmp6) :<br>
> - Builder.CreateSDiv(Tmp9, Tmp6);<br>
> + DSTi = TYPE_UNSIGNED(elt_type) ? Builder.CreateUDiv(Tmp9, Tmp6)<br>
> + : Builder.CreateSDiv(Tmp9, Tmp6);<br>
><br>
> return CreateComplex(DSTr, DSTi);<br>
> }<br>
> @@ -7748,8 +7737,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Value *TreeToLLVM::EmitReg_TRUNC_MOD_EXPR(tree op0, tree op1) {<br>
> Value *LHS = EmitRegister(op0);<br>
> Value *RHS = EmitRegister(op1);<br>
> - return TYPE_UNSIGNED(TREE_TYPE(op0)) ? Builder.CreateURem(LHS, RHS) :<br>
> - Builder.CreateSRem(LHS, RHS);<br>
> + return TYPE_UNSIGNED(TREE_TYPE(op0)) ? Builder.CreateURem(LHS, RHS)<br>
> + : Builder.CreateSRem(LHS, RHS);<br>
> }<br>
><br>
> #if (GCC_MINOR < 7)<br>
> @@ -7849,14 +7838,14 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // The GCC semantics are that mask indices off the end are wrapped back into<br>
> // range, so reduce the mask modulo 2*Length.<br>
> assert(!(Length & (Length - 1)) && "Vector length not a power of two!");<br>
> - Mask = Builder.CreateAnd(Mask, ConstantInt::get(Mask->getType(),<br>
> - 2 * Length - 1));<br>
> + Mask = Builder.CreateAnd(<br>
> + Mask, ConstantInt::get(Mask->getType(), 2 * Length - 1));<br>
><br>
> // Convert to a vector of i32, as required by the shufflevector instruction.<br>
> Type *MaskTy = VectorType::get(Builder.getInt32Ty(), Length);<br>
> tree mask_elt_type = TREE_TYPE(TREE_TYPE(op2));<br>
> - Value *Mask32 = Builder.CreateIntCast(Mask, MaskTy,<br>
> - !TYPE_UNSIGNED(mask_elt_type));<br>
> + Value *Mask32 =<br>
> + Builder.CreateIntCast(Mask, MaskTy, !TYPE_UNSIGNED(mask_elt_type));<br>
><br>
> // Use a shufflevector instruction if this directly corresponds to one, i.e.<br>
> // if the mask is a vector of constant integers or undef.<br>
> @@ -7872,13 +7861,13 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> ConvertType(TREE_TYPE(op1)), NULL);<br>
> AllocaInst *Tmp = CreateTemporary(TmpTy, Align);<br>
> // Store the first vector to the first element of the pair.<br>
> - Value *Tmp0 = Builder.CreateStructGEP(Tmp, 0,<br>
> - flag_verbose_asm ? "vp1s" : "");<br>
> + Value *Tmp0 =<br>
> + Builder.CreateStructGEP(Tmp, 0, flag_verbose_asm ? "vp1s" : "");<br>
> StoreRegisterToMemory(V0, MemRef(Tmp0, Align, /*Volatile*/ false),<br>
> TREE_TYPE(op0), 0, Builder);<br>
> // Store the second vector to the second element of the pair.<br>
> - Value *Tmp1 = Builder.CreateStructGEP(Tmp, 1,<br>
> - flag_verbose_asm ? "vp2s" : "");<br>
> + Value *Tmp1 =<br>
> + Builder.CreateStructGEP(Tmp, 1, flag_verbose_asm ? "vp2s" : "");<br>
> StoreRegisterToMemory(V1, MemRef(Tmp1, Align, /*Volatile*/ false),<br>
> TREE_TYPE(op1), 0, Builder);<br>
><br>
> @@ -8017,9 +8006,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> /// form instead of list form. This way of doing things is forced on us by<br>
> /// GCC routines like parse_output_constraint which rummage around inside the<br>
> /// array.<br>
> - const char **Constraints = (const char * *)<br>
> - alloca((NumOutputs + NumInputs) *<br>
> - sizeof(const char *));<br>
> + const char **Constraints = (const char **)alloca(<br>
> + (NumOutputs + NumInputs) * sizeof(const char *));<br>
><br>
> // Initialize the Constraints array.<br>
> for (unsigned i = 0; i != NumOutputs; ++i) {<br>
> @@ -8028,8 +8016,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> if (TREE_TYPE(TREE_VALUE(Output)) == error_mark_node)<br>
> return;<br>
> // Record the output constraint.<br>
> - const char *Constraint = TREE_STRING_POINTER(<br>
> - TREE_VALUE(TREE_PURPOSE(Output)));<br>
> + const char *Constraint =<br>
> + TREE_STRING_POINTER(TREE_VALUE(TREE_PURPOSE(Output)));<br>
> Constraints[i] = Constraint;<br>
> }<br>
> for (unsigned i = 0; i != NumInputs; ++i) {<br>
> @@ -8038,8 +8026,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> if (TREE_TYPE(TREE_VALUE(Input)) == error_mark_node)<br>
> return;<br>
> // Record the input constraint.<br>
> - const char *Constraint = TREE_STRING_POINTER(<br>
> - TREE_VALUE(TREE_PURPOSE(Input)));<br>
> + const char *Constraint =<br>
> + TREE_STRING_POINTER(TREE_VALUE(TREE_PURPOSE(Input)));<br>
> Constraints[NumOutputs + i] = Constraint;<br>
> }<br>
><br>
> @@ -8186,8 +8174,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> bool IsSigned = !TYPE_UNSIGNED(TREE_TYPE(Operand));<br>
> CallResultDests.push_back(std::make_pair(Dest.Ptr, IsSigned));<br>
> CallResultTypes.push_back(std::make_pair(DestValTy, IsSigned));<br>
> - OutputLocations.push_back(std::make_pair(true,<br>
> - CallResultTypes.size() - 1));<br>
> + OutputLocations.push_back(<br>
> + std::make_pair(true, CallResultTypes.size() - 1));<br>
> } else {<br>
> ConstraintStr += ",=*";<br>
> ConstraintStr += SimplifiedConstraint;<br>
> @@ -8243,7 +8231,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> TySize == 64 || (TySize == 128 && !AllowsMem)) {<br>
> LLVMTy = IntegerType::get(Context, (unsigned) TySize);<br>
> Op = Builder.CreateLoad(<br>
> - Builder.CreateBitCast(LV.Ptr, LLVMTy->getPointerTo()));<br>
> + Builder.CreateBitCast(LV.Ptr, LLVMTy->getPointerTo()));<br>
> } else {<br>
> // Codegen only supports indirect operands with mem constraints.<br>
> if (!AllowsMem)<br>
> @@ -8264,8 +8252,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // type, then cast it to the larger type and shift the value if the target<br>
> // is big endian.<br>
> if (ISDIGIT(Constraint[0])) {<br>
> - unsigned Match = (unsigned)<br>
> - atoi(Constraint); // Unsigned - no minus sign<br>
> + unsigned Match =<br>
> + (unsigned) atoi(Constraint); // Unsigned - no minus sign<br>
> // This output might have gotten put in either CallResult or CallArg<br>
> // depending whether it's a register or not. Find its type.<br>
> Type *OTy = 0;<br>
> @@ -8452,8 +8440,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> CallArgTypes[i] = CallOps[i]->getType();<br>
><br>
> // Get the type of the called asm "function".<br>
> - FunctionType *FTy = FunctionType::get(CallResultType, CallArgTypes,<br>
> - false);<br>
> + FunctionType *FTy =<br>
> + FunctionType::get(CallResultType, CallArgTypes, false);<br>
><br>
> // Remove the leading comma if we have operands.<br>
> if (!ConstraintStr.empty())<br>
> @@ -8466,10 +8454,10 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
><br>
> std::string NewAsmStr = ConvertInlineAsmStr(stmt, NumOutputs + NumInputs);<br>
> - Value *Asm = InlineAsm::get(FTy, NewAsmStr, ConstraintStr,<br>
> - HasSideEffects);<br>
> - CallInst *CV = Builder.CreateCall(Asm, CallOps, CallResultTypes.empty() ?<br>
> - "" : "asmtmp");<br>
> + Value *Asm =<br>
> + InlineAsm::get(FTy, NewAsmStr, ConstraintStr, HasSideEffects);<br>
> + CallInst *CV = Builder.CreateCall(<br>
> + Asm, CallOps, CallResultTypes.empty() ? "" : "asmtmp");<br>
> CV->setDoesNotThrow();<br>
> if (gimple_has_location(stmt)) {<br>
> // Pass the location of the asm using a !srcloc metadata.<br>
> @@ -8480,8 +8468,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // If the call produces a value, store it into the destination.<br>
> for (unsigned i = 0, NumResults = (unsigned) CallResultTypes.size();<br>
> i != NumResults; ++i) {<br>
> - Value *Val = NumResults == 1 ? CV :<br>
> - Builder.CreateExtractValue(CV, i, "asmresult");<br>
> + Value *Val = NumResults ==<br>
> + 1 ? CV : Builder.CreateExtractValue(CV, i, "asmresult");<br>
> bool ValIsSigned = CallResultTypes[i].second;<br>
><br>
> Value *Dest = CallResultDests[i].first;<br>
> @@ -8520,12 +8508,13 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // saying that a RESULT_DECL is dead means we are dead - which is why we<br>
> // don't even consider it.<br>
> if (isa<PARM_DECL>(lhs) || isa<VAR_DECL>(lhs)) {<br>
> - Value *LHSAddr = Builder.CreateBitCast(DECL_LOCAL(lhs),<br>
> - Builder.getInt8PtrTy());<br>
> - uint64_t LHSSize = isInt64(DECL_SIZE(lhs), true) ?<br>
> - getInt64(DECL_SIZE(lhs), true) / 8 : ~0UL;<br>
> - Function *EndIntr = Intrinsic::getDeclaration(<br>
> - TheModule, Intrinsic::lifetime_end);<br>
> + Value *LHSAddr =<br>
> + Builder.CreateBitCast(DECL_LOCAL(lhs), Builder.getInt8PtrTy());<br>
> + uint64_t LHSSize =<br>
> + isInt64(DECL_SIZE(lhs), true) ? getInt64(DECL_SIZE(lhs), true) / 8<br>
> + : ~0UL;<br>
> + Function *EndIntr =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::lifetime_end);<br>
> Builder.CreateCall2(EndIntr, Builder.getInt64(LHSSize), LHSAddr);<br>
> }<br>
> return;<br>
> @@ -8624,8 +8613,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Catches.<br>
> Value *Filter = NULL;<br>
> SmallSet<Value *, 8> AlreadyCaught; // Typeinfos known caught.<br>
> - Function *TypeIDIntr = Intrinsic::getDeclaration(<br>
> - TheModule, Intrinsic::eh_typeid_for);<br>
> + Function *TypeIDIntr =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::eh_typeid_for);<br>
> for (eh_catch c = region->u.eh_try.first_catch; c; c = c->next_catch) {<br>
> BasicBlock *Dest = getLabelDeclBlock(c->label);<br>
> if (!c->type_list) {<br>
> @@ -8691,8 +8680,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // region then the reraised exception may be caught by the current function,<br>
> // in which case it can be simplified into a branch.<br>
> int DstLPadNo = lookup_stmt_eh_lp(stmt);<br>
> - eh_region dst_rgn = DstLPadNo ? get_eh_region_from_lp_number(DstLPadNo) :<br>
> - NULL;<br>
> + eh_region dst_rgn =<br>
> + DstLPadNo ? get_eh_region_from_lp_number(DstLPadNo) : NULL;<br>
> eh_region src_rgn = get_eh_region_from_number(gimple_resx_region(stmt));<br>
><br>
> if (!src_rgn) {<br>
> @@ -8730,8 +8719,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Unwind the exception out of the function using a resume instruction.<br>
> Value *ExcPtr = Builder.CreateLoad(getExceptionPtr(src_rgn->index));<br>
> Value *Filter = Builder.CreateLoad(getExceptionFilter(src_rgn->index));<br>
> - Type *UnwindDataTy = StructType::get(Builder.getInt8PtrTy(),<br>
> - Builder.getInt32Ty(), NULL);<br>
> + Type *UnwindDataTy =<br>
> + StructType::get(Builder.getInt8PtrTy(), Builder.getInt32Ty(), NULL);<br>
> Value *UnwindData = UndefValue::get(UnwindDataTy);<br>
> UnwindData = Builder.CreateInsertValue(UnwindData, ExcPtr, 0, "exc_ptr");<br>
> UnwindData = Builder.CreateInsertValue(UnwindData, Filter, 1, "filter");<br>
> @@ -8769,9 +8758,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> // Create the switch instruction.<br>
> tree default_label = CASE_LABEL(gimple_switch_label(stmt, 0));<br>
> - SwitchInst *SI = Builder.CreateSwitch(Index,<br>
> - getLabelDeclBlock(default_label),<br>
> - gimple_switch_num_labels(stmt));<br>
> + SwitchInst *SI =<br>
> + Builder.CreateSwitch(Index, getLabelDeclBlock(default_label),<br>
> + gimple_switch_num_labels(stmt));<br>
><br>
> // Add the switch cases.<br>
> BasicBlock *IfBlock = 0; // Set if a range was output as an "if".<br>
> @@ -8811,8 +8800,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> BeginBlock(IfBlock);<br>
> }<br>
> Value *Diff = Builder.CreateSub(Index, LowC);<br>
> - Value *Cond = Builder.CreateICmpULE(Diff,<br>
> - ConstantInt::get(Context, Range));<br>
> + Value *Cond =<br>
> + Builder.CreateICmpULE(Diff, ConstantInt::get(Context, Range));<br>
> BasicBlock *False_Block = BasicBlock::Create(Context);<br>
> Builder.CreateCondBr(Cond, Dest, False_Block);<br>
> BeginBlock(False_Block);<br>
> @@ -8898,8 +8887,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> case UNLT_EXPR:<br>
> case UNORDERED_EXPR:<br>
> // The GCC result may be of any integer type.<br>
> - RHS = Builder.CreateZExt(EmitCompare(rhs1, rhs2, code),<br>
> - getRegType(type));<br>
> + RHS =<br>
> + Builder.CreateZExt(EmitCompare(rhs1, rhs2, code), getRegType(type));<br>
> break;<br>
><br>
> // Binary expressions.<br>
> @@ -8976,8 +8965,9 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> Instruction::Shl);<br>
> break;<br>
> case RSHIFT_EXPR:<br>
> - RHS = EmitReg_ShiftOp(rhs1, rhs2, TYPE_UNSIGNED(type) ?<br>
> - Instruction::LShr : Instruction::AShr);<br>
> + RHS = EmitReg_ShiftOp(rhs1, rhs2,<br>
> + TYPE_UNSIGNED(type) ? Instruction::LShr<br>
> + : Instruction::AShr);<br>
> break;<br>
> case TRUNC_DIV_EXPR:<br>
> RHS = EmitReg_TRUNC_DIV_EXPR(rhs1, rhs2, /*isExact*/ false);<br>
> @@ -9075,8 +9065,8 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // Exceptional (tcc_exceptional).<br>
> case CONSTRUCTOR:<br>
> // Vector constant constructors are gimple invariant.<br>
> - return is_gimple_constant(rhs) ? EmitRegisterConstant(rhs) :<br>
> - EmitCONSTRUCTOR(rhs, 0);<br>
> + return is_gimple_constant(rhs) ? EmitRegisterConstant(rhs)<br>
> + : EmitCONSTRUCTOR(rhs, 0);<br>
><br>
> // References (tcc_reference).<br>
> case ARRAY_REF:<br>
> @@ -9109,7 +9099,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> }<br>
><br>
> /// OutputCallRHS - Convert the RHS of a GIMPLE_CALL.<br>
> - Value *TreeToLLVM::OutputCallRHS(gimple stmt, const MemRef *DestLoc) {<br>
> + Value *TreeToLLVM::OutputCallRHS(gimple stmt, const MemRef * DestLoc) {<br>
> // Check for a built-in function call. If we can lower it directly, do so<br>
> // now.<br>
> tree fndecl = gimple_call_fndecl(stmt);<br>
> @@ -9136,13 +9126,13 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> // with arguments none the less, then calculate the LLVM type from the list<br>
> // of arguments.<br>
> if (flag_functions_from_args) {<br>
> - tree *FirstArgAddr = gimple_call_num_args(stmt) > 0 ?<br>
> - gimple_call_arg_ptr(stmt, 0) : NULL;<br>
> + tree *FirstArgAddr = gimple_call_num_args(stmt) ><br>
> + 0 ? gimple_call_arg_ptr(stmt, 0) : NULL;<br>
> Ty = ConvertArgListToFnType(<br>
> - function_type,<br>
> - ArrayRef<tree>(FirstArgAddr, gimple_call_num_args(stmt)),<br>
> - gimple_call_chain(stmt), !flag_functions_from_args,<br>
> - CallingConv, PAL);<br>
> + function_type,<br>
> + ArrayRef<tree>(FirstArgAddr, gimple_call_num_args(stmt)),<br>
> + gimple_call_chain(stmt), !flag_functions_from_args, CallingConv,<br>
> + PAL);<br>
> } else {<br>
> Ty = ConvertFunctionType(function_type, fndecl, gimple_call_chain(stmt),<br>
> CallingConv, PAL);<br>
> @@ -9163,12 +9153,12 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
> BeginBlock(BasicBlock::Create(Context));<br>
> }<br>
><br>
> - return Result ? Mem2Reg(Result, gimple_call_return_type(stmt), Builder) :<br>
> - 0;<br>
> + return Result ? Mem2Reg(Result, gimple_call_return_type(stmt), Builder)<br>
> + : 0;<br>
> }<br>
><br>
> /// WriteScalarToLHS - Store RHS, a non-aggregate value, into the given LHS.<br>
> - void TreeToLLVM::WriteScalarToLHS(tree lhs, Value *RHS) {<br>
> + void TreeToLLVM::WriteScalarToLHS(tree lhs, Value * RHS) {<br>
> // May need a useless type conversion (useless_type_conversion_p).<br>
> RHS = TriviallyTypeConvert(RHS, getRegType(TREE_TYPE(lhs)));<br>
><br>
> @@ -9205,14 +9195,14 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> // Load and store the minimum number of bytes that covers the field.<br>
> unsigned LoadSizeInBits = LV.BitStart + LV.BitSize;<br>
> - LoadSizeInBits = (unsigned)<br>
> - RoundUpToAlignment(LoadSizeInBits, BITS_PER_UNIT);<br>
> + LoadSizeInBits =<br>
> + (unsigned) RoundUpToAlignment(LoadSizeInBits, BITS_PER_UNIT);<br>
> Type *LoadType = IntegerType::get(Context, LoadSizeInBits);<br>
><br>
> // Load the bits.<br>
> Value *Ptr = Builder.CreateBitCast(LV.Ptr, LoadType->getPointerTo());<br>
> - Value *Val = Builder.CreateAlignedLoad(Ptr, LV.getAlignment(),<br>
> - LV.Volatile);<br>
> + Value *Val =<br>
> + Builder.CreateAlignedLoad(Ptr, LV.getAlignment(), LV.Volatile);<br>
><br>
> // Get the right-hand side as a value of the same type.<br>
> // FIXME: This assumes the right-hand side is an integer.<br>
> @@ -9221,7 +9211,7 @@ bool TreeToLLVM::EmitBuiltinCall(gimple<br>
><br>
> // Shift the right-hand side so that its bits are in the right position.<br>
> unsigned FirstBitInVal = BYTES_BIG_ENDIAN ? LoadSizeInBits - LV.BitStart -<br>
> - LV.BitSize : LV.BitStart;<br>
> + LV.BitSize : LV.BitStart;<br>
> if (FirstBitInVal) {<br>
> Value *ShAmt = ConstantInt::get(LoadType, FirstBitInVal);<br>
> RHS = Builder.CreateShl(RHS, ShAmt);<br>
><br>
> Modified: dragonegg/trunk/src/Debug.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Debug.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Debug.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/Debug.cpp (original)<br>
> +++ dragonegg/trunk/src/Debug.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -122,8 +122,8 @@ static uint64_t NodeAlignInBits(tree Nod<br>
> static tree FieldType(tree Field) {<br>
> if (isa<ERROR_MARK>(Field))<br>
> return integer_type_node;<br>
> - return DECL_BIT_FIELD_TYPE(Field) ? DECL_BIT_FIELD_TYPE(Field) :<br>
> - TREE_TYPE(Field);<br>
> + return DECL_BIT_FIELD_TYPE(Field) ? DECL_BIT_FIELD_TYPE(Field)<br>
> + : TREE_TYPE(Field);<br>
> }<br>
><br>
> /// GetNodeName - Returns the name stored in a node regardless of whether the<br>
> @@ -238,7 +238,8 @@ void DebugInfo::EmitFunctionStart(tree F<br>
> std::map<tree_node *, WeakVH>::iterator I = SPCache.find(FnDecl);<br>
> if (I != SPCache.end()) {<br>
> DISubprogram SPDecl(cast<MDNode>(I->second));<br>
> - DISubprogram SP = DebugFactory.CreateSubprogramDefinition(SPDecl, lineno, Fn);<br>
> + DISubprogram SP =<br>
> + DebugFactory.CreateSubprogramDefinition(SPDecl, lineno, Fn);<br>
> SPDecl->replaceAllUsesWith(SP);<br>
><br>
> // Push function on region stack.<br>
> @@ -254,16 +255,17 @@ void DebugInfo::EmitFunctionStart(tree F<br>
> DECL_ABSTRACT_ORIGIN(FnDecl) != FnDecl)<br>
> ArtificialFnWithAbstractOrigin = true;<br>
><br>
> - DIDescriptor SPContext = ArtificialFnWithAbstractOrigin ?<br>
> - getOrCreateFile(main_input_filename) :<br>
> - findRegion(DECL_CONTEXT(FnDecl));<br>
> + DIDescriptor SPContext =<br>
> + ArtificialFnWithAbstractOrigin ? getOrCreateFile(main_input_filename)<br>
> + : findRegion(DECL_CONTEXT(FnDecl));<br>
><br>
> // Creating context may have triggered creation of this SP descriptor. So<br>
> // check the cache again.<br>
> I = SPCache.find(FnDecl);<br>
> if (I != SPCache.end()) {<br>
> DISubprogram SPDecl(cast<MDNode>(I->second));<br>
> - DISubprogram SP = DebugFactory.CreateSubprogramDefinition(SPDecl, lineno, Fn);<br>
> + DISubprogram SP =<br>
> + DebugFactory.CreateSubprogramDefinition(SPDecl, lineno, Fn);<br>
> SPDecl->replaceAllUsesWith(SP);<br>
><br>
> // Push function on region stack.<br>
> @@ -290,11 +292,9 @@ void DebugInfo::EmitFunctionStart(tree F<br>
> StringRef FnName = getFunctionName(FnDecl);<br>
><br>
> DISubprogram SP = DebugFactory.CreateSubprogram(<br>
> - SPContext, FnName, FnName, LinkageName,<br>
> - getOrCreateFile(Loc.file), lineno, FNType,<br>
> - Fn->hasInternalLinkage(), true /*definition*/,<br>
> - Virtuality, VIndex, ContainingType,<br>
> - DECL_ARTIFICIAL(FnDecl), optimize, Fn);<br>
> + SPContext, FnName, FnName, LinkageName, getOrCreateFile(Loc.file), lineno,<br>
> + FNType, Fn->hasInternalLinkage(), true /*definition*/, Virtuality, VIndex,<br>
> + ContainingType, DECL_ARTIFICIAL(FnDecl), optimize, Fn);<br>
><br>
> SPCache[FnDecl] = WeakVH(SP);<br>
><br>
> @@ -310,9 +310,8 @@ DINameSpace DebugInfo::getOrCreateNameSp<br>
> return DINameSpace(cast<MDNode>(I->second));<br>
><br>
> expanded_location Loc = GetNodeLocation(Node, false);<br>
> - DINameSpace DNS = DebugFactory.CreateNameSpace(Context, GetNodeName(Node),<br>
> - getOrCreateFile(Loc.file),<br>
> - Loc.line);<br>
> + DINameSpace DNS = DebugFactory.CreateNameSpace(<br>
> + Context, GetNodeName(Node), getOrCreateFile(Loc.file), Loc.line);<br>
><br>
> NameSpaceCache[Node] = WeakVH(DNS);<br>
> return DNS;<br>
> @@ -379,12 +378,11 @@ void DebugInfo::EmitDeclare(tree decl, u<br>
> // If type info is not available then do not emit debug info for this var.<br>
> if (!Ty)<br>
> return;<br>
> - llvm::DIVariable D = DebugFactory.CreateVariable(Tag, VarScope, Name,<br>
> - getOrCreateFile(Loc.file),<br>
> - Loc.line, Ty, optimize);<br>
> + llvm::DIVariable D = DebugFactory.CreateVariable(<br>
> + Tag, VarScope, Name, getOrCreateFile(Loc.file), Loc.line, Ty, optimize);<br>
><br>
> - Instruction *Call = DebugFactory.InsertDeclare(AI, D,<br>
> - Builder.GetInsertBlock());<br>
> + Instruction *Call =<br>
> + DebugFactory.InsertDeclare(AI, D, Builder.GetInsertBlock());<br>
><br>
> Call->setDebugLoc(DebugLoc::get(Loc.line, 0, VarScope));<br>
> }<br>
> @@ -458,8 +456,8 @@ DIType DebugInfo::createBasicType(tree t<br>
> Encoding = DW_ATE_float;<br>
> break;<br>
> case COMPLEX_TYPE:<br>
> - Encoding = isa<REAL_TYPE>(TREE_TYPE(type)) ? DW_ATE_complex_float :<br>
> - DW_ATE_lo_user;<br>
> + Encoding =<br>
> + isa<REAL_TYPE>(TREE_TYPE(type)) ? DW_ATE_complex_float : DW_ATE_lo_user;<br>
> break;<br>
> case BOOLEAN_TYPE:<br>
> Encoding = DW_ATE_boolean;<br>
> @@ -522,8 +520,8 @@ DIType DebugInfo::createMethodType(tree<br>
> ProcessedFirstArg = true;<br>
> }<br>
><br>
> - llvm::DIArray EltTypeArray = DebugFactory.GetOrCreateArray(EltTys.data(),<br>
> - EltTys.size());<br>
> + llvm::DIArray EltTypeArray =<br>
> + DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());<br>
><br>
> RegionStack.pop_back();<br>
> std::map<tree_node *, WeakVH>::iterator RI = RegionMap.find(type);<br>
> @@ -531,10 +529,9 @@ DIType DebugInfo::createMethodType(tree<br>
> RegionMap.erase(RI);<br>
><br>
> llvm::DIType RealType = DebugFactory.CreateCompositeType(<br>
> - llvm::dwarf::DW_TAG_subroutine_type,<br>
> - findRegion(TYPE_CONTEXT(type)), StringRef(),<br>
> - getOrCreateFile(main_input_filename), 0, 0, 0, 0,<br>
> - 0, llvm::DIType(), EltTypeArray);<br>
> + llvm::dwarf::DW_TAG_subroutine_type, findRegion(TYPE_CONTEXT(type)),<br>
> + StringRef(), getOrCreateFile(main_input_filename), 0, 0, 0, 0, 0,<br>
> + llvm::DIType(), EltTypeArray);<br>
><br>
> // Now that we have a real decl for the struct, replace anything using the<br>
> // old decl with the new one. This will recursively update the debug info.<br>
> @@ -549,8 +546,8 @@ DIType DebugInfo::createPointerType(tree<br>
> DIType FromTy = getOrCreateType(TREE_TYPE(type));<br>
> // type* and type&<br>
> // FIXME: Should BLOCK_POINTER_TYP have its own DW_TAG?<br>
> - unsigned Tag = isa<REFERENCE_TYPE>(type) ? DW_TAG_reference_type :<br>
> - DW_TAG_pointer_type;<br>
> + unsigned Tag =<br>
> + isa<REFERENCE_TYPE>(type) ? DW_TAG_reference_type : DW_TAG_pointer_type;<br>
> unsigned Flags = 0;<br>
><br>
> // Check if this pointer type has a name.<br>
> @@ -558,21 +555,19 @@ DIType DebugInfo::createPointerType(tree<br>
> if (isa<TYPE_DECL>(TyName) && !DECL_ORIGINAL_TYPE(TyName)) {<br>
> expanded_location TypeNameLoc = GetNodeLocation(TyName);<br>
> DIType Ty = DebugFactory.CreateDerivedType(<br>
> - Tag, findRegion(DECL_CONTEXT(TyName)),<br>
> - GetNodeName(TyName), getOrCreateFile(TypeNameLoc.file),<br>
> - TypeNameLoc.line, 0 /*size*/, 0 /*align*/, 0 /*offset */,<br>
> - 0 /*flags*/, FromTy);<br>
> + Tag, findRegion(DECL_CONTEXT(TyName)), GetNodeName(TyName),<br>
> + getOrCreateFile(TypeNameLoc.file), TypeNameLoc.line, 0 /*size*/,<br>
> + 0 /*align*/, 0 /*offset */, 0 /*flags*/, FromTy);<br>
> TypeCache[TyName] = WeakVH(Ty);<br>
> return Ty;<br>
> }<br>
><br>
> StringRef PName = FromTy.getName();<br>
> DIType PTy = DebugFactory.CreateDerivedType(<br>
> - Tag, findRegion(TYPE_CONTEXT(type)),<br>
> - Tag == DW_TAG_pointer_type ? StringRef() : PName,<br>
> - getOrCreateFile(main_input_filename), 0 /*line no*/,<br>
> - NodeSizeInBits(type), NodeAlignInBits(type), 0 /*offset */,<br>
> - Flags, FromTy);<br>
> + Tag, findRegion(TYPE_CONTEXT(type)),<br>
> + Tag == DW_TAG_pointer_type ? StringRef() : PName,<br>
> + getOrCreateFile(main_input_filename), 0 /*line no*/, NodeSizeInBits(type),<br>
> + NodeAlignInBits(type), 0 /*offset */, Flags, FromTy);<br>
> return PTy;<br>
> }<br>
><br>
> @@ -610,8 +605,8 @@ DIType DebugInfo::createArrayType(tree t<br>
> Subscripts.push_back(DebugFactory.GetOrCreateSubrange(0, Length));<br>
> }<br>
><br>
> - llvm::DIArray SubscriptArray = DebugFactory.GetOrCreateArray(<br>
> - Subscripts.data(), Subscripts.size());<br>
> + llvm::DIArray SubscriptArray =<br>
> + DebugFactory.GetOrCreateArray(Subscripts.data(), Subscripts.size());<br>
> expanded_location Loc = GetNodeLocation(type);<br>
> return DebugFactory.CreateCompositeType(<br>
> llvm::dwarf::DW_TAG_array_type, findRegion(TYPE_CONTEXT(type)),<br>
> @@ -635,8 +630,8 @@ DIType DebugInfo::createEnumType(tree ty<br>
> }<br>
> }<br>
><br>
> - llvm::DIArray EltArray = DebugFactory.GetOrCreateArray(Elements.data(),<br>
> - Elements.size());<br>
> + llvm::DIArray EltArray =<br>
> + DebugFactory.GetOrCreateArray(Elements.data(), Elements.size());<br>
><br>
> expanded_location Loc = { NULL, 0, 0, false };<br>
> if (TYPE_SIZE(type))<br>
> @@ -654,8 +649,8 @@ DIType DebugInfo::createEnumType(tree ty<br>
> DIType DebugInfo::createStructType(tree type) {<br>
><br>
> // struct { a; b; ... z; }; | union { a; b; ... z; };<br>
> - unsigned Tag = isa<RECORD_TYPE>(type) ? DW_TAG_structure_type :<br>
> - DW_TAG_union_type;<br>
> + unsigned Tag =<br>
> + isa<RECORD_TYPE>(type) ? DW_TAG_structure_type : DW_TAG_union_type;<br>
><br>
> unsigned RunTimeLang = 0;<br>
> //TODO if (TYPE_LANG_SPECIFIC (type)<br>
> @@ -699,11 +694,10 @@ DIType DebugInfo::createStructType(tree<br>
><br>
> // forward declaration,<br>
> if (TYPE_SIZE(type) == 0) {<br>
> - llvm::DICompositeType FwdDecl =<br>
> - DebugFactory.CreateCompositeType(<br>
> - Tag, TyContext, GetNodeName(type), getOrCreateFile(Loc.file),<br>
> - Loc.line, 0, 0, 0, SFlags | llvm::DIType::FlagFwdDecl,<br>
> - llvm::DIType(), llvm::DIArray(), RunTimeLang);<br>
> + llvm::DICompositeType FwdDecl = DebugFactory.CreateCompositeType(<br>
> + Tag, TyContext, GetNodeName(type), getOrCreateFile(Loc.file), Loc.line,<br>
> + 0, 0, 0, SFlags | llvm::DIType::FlagFwdDecl, llvm::DIType(),<br>
> + llvm::DIArray(), RunTimeLang);<br>
> return FwdDecl;<br>
> }<br>
><br>
> @@ -722,7 +716,7 @@ DIType DebugInfo::createStructType(tree<br>
> llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;<br>
><br>
> if (tree binfo = TYPE_BINFO(type)) {<br>
> - VEC(tree, gc) * accesses = BINFO_BASE_ACCESSES(binfo);<br>
> + VEC(tree, gc) *accesses = BINFO_BASE_ACCESSES(binfo);<br>
><br>
> for (unsigned i = 0, e = BINFO_N_BASE_BINFOS(binfo); i != e; ++i) {<br>
> tree BInfo = BINFO_BASE_BINFO(binfo, i);<br>
> @@ -741,16 +735,15 @@ DIType DebugInfo::createStructType(tree<br>
><br>
> // Check for zero BINFO_OFFSET.<br>
> // FIXME : Is this correct ?<br>
> - unsigned Offset = BINFO_OFFSET(BInfo) ?<br>
> - getInt64(BINFO_OFFSET(BInfo), true) * 8 : 0;<br>
> + unsigned Offset =<br>
> + BINFO_OFFSET(BInfo) ? getInt64(BINFO_OFFSET(BInfo), true) * 8 : 0;<br>
><br>
> if (BINFO_VIRTUAL_P(BInfo))<br>
> Offset = 0 - getInt64(BINFO_VPTR_FIELD(BInfo), false);<br>
> // FIXME : name, size, align etc...<br>
> DIType DTy = DebugFactory.CreateDerivedType(<br>
> - DW_TAG_inheritance, findRegion(type),<br>
> - StringRef(), llvm::DIFile(), 0, 0, 0, Offset, BFlags,<br>
> - BaseClass);<br>
> + DW_TAG_inheritance, findRegion(type), StringRef(), llvm::DIFile(), 0,<br>
> + 0, 0, Offset, BFlags, BaseClass);<br>
> EltTys.push_back(DTy);<br>
> }<br>
> }<br>
> @@ -790,10 +783,10 @@ DIType DebugInfo::createStructType(tree<br>
> MFlags = llvm::DIType::FlagPrivate;<br>
><br>
> DIType DTy = DebugFactory.CreateDerivedType(<br>
> - DW_TAG_member, findRegion(DECL_CONTEXT(Member)),<br>
> - MemberName, getOrCreateFile(MemLoc.file), MemLoc.line,<br>
> - NodeSizeInBits(Member), NodeAlignInBits(FieldNodeType),<br>
> - int_bit_position(Member), MFlags, MemberType);<br>
> + DW_TAG_member, findRegion(DECL_CONTEXT(Member)), MemberName,<br>
> + getOrCreateFile(MemLoc.file), MemLoc.line, NodeSizeInBits(Member),<br>
> + NodeAlignInBits(FieldNodeType), int_bit_position(Member), MFlags,<br>
> + MemberType);<br>
> EltTys.push_back(DTy);<br>
> }<br>
><br>
> @@ -827,18 +820,17 @@ DIType DebugInfo::createStructType(tree<br>
> ContainingType = getOrCreateType(DECL_CONTEXT(Member));<br>
> }<br>
> DISubprogram SP = DebugFactory.CreateSubprogram(<br>
> - findRegion(DECL_CONTEXT(Member)), MemberName,<br>
> - MemberName, LinkageName,<br>
> - getOrCreateFile(MemLoc.file), MemLoc.line, SPTy,<br>
> - false, false, Virtuality, VIndex, ContainingType,<br>
> - DECL_ARTIFICIAL(Member), optimize);<br>
> + findRegion(DECL_CONTEXT(Member)), MemberName, MemberName, LinkageName,<br>
> + getOrCreateFile(MemLoc.file), MemLoc.line, SPTy, false, false,<br>
> + Virtuality, VIndex, ContainingType, DECL_ARTIFICIAL(Member),<br>
> + optimize);<br>
> EltTys.push_back(SP);<br>
> SPCache[Member] = WeakVH(SP);<br>
> }<br>
> }<br>
><br>
> - llvm::DIArray Elements = DebugFactory.GetOrCreateArray(EltTys.data(),<br>
> - EltTys.size());<br>
> + llvm::DIArray Elements =<br>
> + DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());<br>
><br>
> RegionStack.pop_back();<br>
> std::map<tree_node *, WeakVH>::iterator RI = RegionMap.find(type);<br>
> @@ -850,12 +842,11 @@ DIType DebugInfo::createStructType(tree<br>
> tree vtype = DECL_FCONTEXT(TYPE_VFIELD(type));<br>
> ContainingType = getOrCreateType(vtype);<br>
> }<br>
> - llvm::DICompositeType RealDecl =<br>
> - DebugFactory.CreateCompositeType(<br>
> - Tag, findRegion(TYPE_CONTEXT(type)), GetNodeName(type),<br>
> - getOrCreateFile(Loc.file), Loc.line, NodeSizeInBits(type),<br>
> - NodeAlignInBits(type), 0, SFlags, llvm::DIType(), Elements,<br>
> - RunTimeLang, ContainingType);<br>
> + llvm::DICompositeType RealDecl = DebugFactory.CreateCompositeType(<br>
> + Tag, findRegion(TYPE_CONTEXT(type)), GetNodeName(type),<br>
> + getOrCreateFile(Loc.file), Loc.line, NodeSizeInBits(type),<br>
> + NodeAlignInBits(type), 0, SFlags, llvm::DIType(), Elements, RunTimeLang,<br>
> + ContainingType);<br>
> RegionMap[type] = WeakVH(RealDecl);<br>
><br>
> // Now that we have a real decl for the struct, replace anything using the<br>
> @@ -877,10 +868,9 @@ DIType DebugInfo::createVariantType(tree<br>
> if (isa<TYPE_DECL>(TyDef) && DECL_ORIGINAL_TYPE(TyDef)) {<br>
> expanded_location TypeDefLoc = GetNodeLocation(TyDef);<br>
> Ty = DebugFactory.CreateDerivedType(<br>
> - DW_TAG_typedef, findRegion(DECL_CONTEXT(TyDef)),<br>
> - GetNodeName(TyDef), getOrCreateFile(TypeDefLoc.file),<br>
> - TypeDefLoc.line, 0 /*size*/, 0 /*align*/, 0 /*offset */,<br>
> - 0 /*flags*/, MainTy);<br>
> + DW_TAG_typedef, findRegion(DECL_CONTEXT(TyDef)), GetNodeName(TyDef),<br>
> + getOrCreateFile(TypeDefLoc.file), TypeDefLoc.line, 0 /*size*/,<br>
> + 0 /*align*/, 0 /*offset */, 0 /*flags*/, MainTy);<br>
> TypeCache[TyDef] = WeakVH(Ty);<br>
> return Ty;<br>
> }<br>
> @@ -888,19 +878,19 @@ DIType DebugInfo::createVariantType(tree<br>
><br>
> if (TYPE_VOLATILE(type)) {<br>
> Ty = DebugFactory.CreateDerivedType(<br>
> - DW_TAG_volatile_type, findRegion(TYPE_CONTEXT(type)), StringRef(),<br>
> - getOrCreateFile(main_input_filename), 0 /*line no*/,<br>
> - NodeSizeInBits(type), NodeAlignInBits(type), 0 /*offset */,<br>
> - 0 /* flags */, MainTy);<br>
> + DW_TAG_volatile_type, findRegion(TYPE_CONTEXT(type)), StringRef(),<br>
> + getOrCreateFile(main_input_filename), 0 /*line no*/,<br>
> + NodeSizeInBits(type), NodeAlignInBits(type), 0 /*offset */,<br>
> + 0 /* flags */, MainTy);<br>
> MainTy = Ty;<br>
> }<br>
><br>
> if (TYPE_READONLY(type))<br>
> Ty = DebugFactory.CreateDerivedType(<br>
> - DW_TAG_const_type, findRegion(TYPE_CONTEXT(type)), StringRef(),<br>
> - getOrCreateFile(main_input_filename), 0 /*line no*/,<br>
> - NodeSizeInBits(type), NodeAlignInBits(type), 0 /*offset */,<br>
> - 0 /* flags */, MainTy);<br>
> + DW_TAG_const_type, findRegion(TYPE_CONTEXT(type)), StringRef(),<br>
> + getOrCreateFile(main_input_filename), 0 /*line no*/,<br>
> + NodeSizeInBits(type), NodeAlignInBits(type), 0 /*offset */,<br>
> + 0 /* flags */, MainTy);<br>
><br>
> if (TYPE_VOLATILE(type) || TYPE_READONLY(type)) {<br>
> TypeCache[type] = WeakVH(Ty);<br>
> @@ -1012,8 +1002,7 @@ void DebugInfo::Initialize() {<br>
><br>
> /// getOrCreateCompileUnit - Get the compile unit from the cache or<br>
> /// create a new one if necessary.<br>
> -void DebugInfo::getOrCreateCompileUnit(const char *FullPath,<br>
> - bool isMain) {<br>
> +void DebugInfo::getOrCreateCompileUnit(const char *FullPath, bool isMain) {<br>
> if (!FullPath) {<br>
> if (!strcmp(main_input_filename, ""))<br>
> FullPath = "<stdin>";<br>
> @@ -1084,12 +1073,11 @@ DIFactory::DIFactory(Module &m)<br>
> }<br>
><br>
> Constant *DIFactory::GetTagConstant(unsigned TAG) {<br>
> - assert((TAG &LLVMDebugVersionMask) == 0 &&<br>
> + assert((TAG & LLVMDebugVersionMask) == 0 &&<br>
> "Tag too large for debug encoding!");<br>
> // llvm has moved forward. DIFactory does not emit debug info in updated form.<br>
> // Use LLVMDebugVersion10 directly here.<br>
> - return ConstantInt::get(Type::getInt32Ty(VMContext),<br>
> - TAG | LLVMDebugVersion);<br>
> + return ConstantInt::get(Type::getInt32Ty(VMContext), TAG | LLVMDebugVersion);<br>
> }<br>
><br>
> //===----------------------------------------------------------------------===//<br>
> @@ -1119,11 +1107,12 @@ DIDescriptor DIFactory::CreateUnspecifie<br>
><br>
> /// CreateCompileUnit - Create a new descriptor for the specified compile<br>
> /// unit. Note that this does not unique compile units within the module.<br>
> -void DIFactory::CreateCompileUnit(<br>
> - unsigned LangID, StringRef Filename, StringRef Directory,<br>
> - StringRef Producer, bool isMain, bool isOptimized, StringRef Flags,<br>
> - unsigned RunTimeVer) {<br>
> - Builder.createCompileUnit(LangID, Filename, Directory, Producer, isOptimized, Flags, RunTimeVer);<br>
> +void DIFactory::CreateCompileUnit(unsigned LangID, StringRef Filename,<br>
> + StringRef Directory, StringRef Producer,<br>
> + bool isMain, bool isOptimized,<br>
> + StringRef Flags, unsigned RunTimeVer) {<br>
> + Builder.createCompileUnit(LangID, Filename, Directory, Producer, isOptimized,<br>
> + Flags, RunTimeVer);<br>
> }<br>
><br>
> /// CreateFile - Create a new descriptor for the specified file.<br>
> @@ -1172,21 +1161,22 @@ DIDerivedType DIFactory::CreateDerivedTy<br>
> // an invalid typedef that is a typedef of no other type. (hence the null<br>
> // value as the last parameter in Elts, below)<br>
> if (!DerivedFrom.isValid()) {<br>
> - Value* Elts[] = {<br>
> - GetTagConstant(dwarf::DW_TAG_typedef),<br>
> - Context, MDString::get(VMContext, Name), F,<br>
> + Value *Elts[] = {<br>
> + GetTagConstant(dwarf::DW_TAG_typedef), Context,<br>
> + MDString::get(VMContext, Name), F,<br>
> ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),<br>
> - ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size<br>
> - ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align<br>
> - ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset<br>
> - ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags<br>
> + ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size<br>
> + ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align<br>
> + ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset<br>
> + ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags<br>
> NULL<br>
> };<br>
> return DIDerivedType(MDNode::get(VMContext, Elts));<br>
> }<br>
> return Builder.createTypedef(DerivedFrom, Name, F, LineNumber, Context);<br>
> case dwarf::DW_TAG_pointer_type:<br>
> - return Builder.createPointerType(DerivedFrom, SizeInBits, AlignInBits, Name);<br>
> + return Builder.createPointerType(DerivedFrom, SizeInBits, AlignInBits,<br>
> + Name);<br>
> case dwarf::DW_TAG_reference_type:<br>
> case dwarf::DW_TAG_rvalue_reference_type:<br>
> return Builder.createReferenceType(Tag, DerivedFrom);<br>
> @@ -1199,7 +1189,8 @@ DIDerivedType DIFactory::CreateDerivedTy<br>
> AlignInBits, OffsetInBits, Flags,<br>
> DerivedFrom);<br>
> case dwarf::DW_TAG_inheritance:<br>
> - return Builder.createInheritance(DIType(Context), DerivedFrom, OffsetInBits, Flags);<br>
> + return Builder.createInheritance(DIType(Context), DerivedFrom, OffsetInBits,<br>
> + Flags);<br>
> case dwarf::DW_TAG_friend:<br>
> case dwarf::DW_TAG_ptr_to_member_type:<br>
> break;<br>
> @@ -1259,8 +1250,8 @@ DISubprogram DIFactory::CreateSubprogram<br>
> isLocalToUnit, isDefinition, VK, VIndex, NULL,<br>
> Flags, isOptimized, Fn, NULL);<br>
> return Builder.createFunction(Context, Name, LinkageName, F, LineNo, Ty,<br>
> - isLocalToUnit, isDefinition,<br>
> - LineNo, Flags, isOptimized, Fn, NULL, NULL);<br>
> + isLocalToUnit, isDefinition, LineNo, Flags,<br>
> + isOptimized, Fn, NULL, NULL);<br>
> }<br>
><br>
> /// CreateSubprogramDefinition - Create new subprogram descriptor for the<br>
> @@ -1270,12 +1261,10 @@ DISubprogram DIFactory::CreateSubprogram<br>
> if (SP.isDefinition())<br>
> return DISubprogram(SP);<br>
><br>
> - return Builder.createFunction(SP.getContext(), SP.getName(),<br>
> - SP.getLinkageName(), SP.getFile(),<br>
> - SP.getLineNumber(), SP.getType(),<br>
> - SP.isLocalToUnit(), true, LineNo, SP.getFlags(),<br>
> - SP.isOptimized(), Fn, SP.getTemplateParams(),<br>
> - SP);<br>
> + return Builder.createFunction(<br>
> + SP.getContext(), SP.getName(), SP.getLinkageName(), SP.getFile(),<br>
> + SP.getLineNumber(), SP.getType(), SP.isLocalToUnit(), true, LineNo,<br>
> + SP.getFlags(), SP.isOptimized(), Fn, SP.getTemplateParams(), SP);<br>
> }<br>
><br>
> /// CreateGlobalVariable - Create a new descriptor for the specified global.<br>
> @@ -1283,7 +1272,8 @@ DIGlobalVariable DIFactory::CreateGlobal<br>
> DIDescriptor Context, StringRef Name, StringRef DisplayName,<br>
> StringRef LinkageName, DIFile F, unsigned LineNo, DIType Ty,<br>
> bool isLocalToUnit, bool isDefinition, llvm::GlobalVariable *Val) {<br>
> - return Builder.createStaticVariable(Context, Name, LinkageName, F, LineNo, Ty, isLocalToUnit, Val);<br>
> + return Builder.createStaticVariable(Context, Name, LinkageName, F, LineNo, Ty,<br>
> + isLocalToUnit, Val);<br>
> }<br>
><br>
> /// CreateGlobalVariable - Create a new descriptor for the specified constant.<br>
> @@ -1298,7 +1288,8 @@ DIGlobalVariable DIFactory::CreateGlobal<br>
> DIVariable DIFactory::CreateVariable(<br>
> unsigned Tag, DIDescriptor Context, StringRef Name, DIFile F,<br>
> unsigned LineNo, DIType Ty, bool AlwaysPreserve, unsigned Flags) {<br>
> - return Builder.createLocalVariable(Tag, Context, Name, F, LineNo, Ty, AlwaysPreserve, Flags);<br>
> + return Builder.createLocalVariable(Tag, Context, Name, F, LineNo, Ty,<br>
> + AlwaysPreserve, Flags);<br>
> }<br>
><br>
> /// CreateComplexVariable - Create a new descriptor for the specified variable<br>
> @@ -1306,7 +1297,8 @@ DIVariable DIFactory::CreateVariable(<br>
> DIVariable DIFactory::CreateComplexVariable(<br>
> unsigned Tag, DIDescriptor Context, StringRef Name, DIFile F,<br>
> unsigned LineNo, DIType Ty, Value *const *Addr, unsigned NumAddr) {<br>
> - return Builder.createComplexVariable(Tag, Context, Name, F, LineNo, Ty, ArrayRef<Value *>(Addr, NumAddr));<br>
> + return Builder.createComplexVariable(Tag, Context, Name, F, LineNo, Ty,<br>
> + ArrayRef<Value *>(Addr, NumAddr));<br>
> }<br>
><br>
> /// CreateBlock - This creates a descriptor for a lexical block with the<br>
> @@ -1396,6 +1388,4 @@ Instruction *DIFactory::InsertDbgValueIn<br>
><br>
> // RecordType - Record DIType in a module such that it is not lost even if<br>
> // it is not referenced through debug info anchors.<br>
> -void DIFactory::RecordType(DIType T) {<br>
> - Builder.retainType(T);<br>
> -}<br>
> +void DIFactory::RecordType(DIType T) { Builder.retainType(T); }<br>
><br>
> Modified: dragonegg/trunk/src/DefaultABI.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/DefaultABI.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/DefaultABI.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/DefaultABI.cpp (original)<br>
> +++ dragonegg/trunk/src/DefaultABI.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -110,9 +110,9 @@ tree isSingleElementStructOrArray(tree t<br>
> return 0; // More than one field.<br>
> }<br>
> }<br>
> - return FoundField ?<br>
> - isSingleElementStructOrArray(FoundField, ignoreZeroLength, false) :<br>
> - 0;<br>
> + return FoundField<br>
> + ? isSingleElementStructOrArray(FoundField, ignoreZeroLength, false)<br>
> + : 0;<br>
> case ARRAY_TYPE:<br>
> ArrayType *Ty = dyn_cast<ArrayType>(ConvertType(type));<br>
> if (!Ty || Ty->getNumElements() != 1)<br>
> @@ -165,11 +165,11 @@ void DefaultABI::HandleReturnType(tree t<br>
> } else {<br>
> // Otherwise return as an integer value large enough to hold the entire<br>
> // aggregate.<br>
> - if (Type *AggrTy = LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(type,<br>
> - C.getCallingConv()))<br>
> + if (Type *AggrTy =<br>
> + LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(type, C.getCallingConv()))<br>
> C.HandleAggregateResultAsAggregate(AggrTy);<br>
> - else if (Type *ScalarTy = LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN(type,<br>
> - &Offset))<br>
> + else if (Type *ScalarTy =<br>
> + LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN(type, &Offset))<br>
> C.HandleAggregateResultAsScalar(ScalarTy, Offset);<br>
> else<br>
> llvm_unreachable("Unable to determine how to return this aggregate!");<br>
> @@ -231,9 +231,9 @@ void DefaultABI::HandleArgument(tree typ<br>
> } else if (LLVM_SHOULD_PASS_AGGREGATE_AS_FCA(type, Ty)) {<br>
> C.HandleFCAArgument(Ty, type);<br>
> } else if (LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS(<br>
> - type, Ty, C.getCallingConv(), Elts)) {<br>
> + type, Ty, C.getCallingConv(), Elts)) {<br>
> if (!LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(<br>
> - Elts, ScalarElts, C.isShadowReturn(), C.getCallingConv()))<br>
> + Elts, ScalarElts, C.isShadowReturn(), C.getCallingConv()))<br>
> PassInMixedRegisters(Ty, Elts, ScalarElts);<br>
> else {<br>
> C.HandleByValArgument(Ty, type);<br>
> @@ -347,8 +347,8 @@ void DefaultABI::PassInIntegerRegisters(<br>
> // don't bitcast aggregate value to Int64 if its alignment is different<br>
> // from Int64 alignment. ARM backend needs this.<br>
> unsigned Align = TYPE_ALIGN(type) / 8;<br>
> - unsigned Int64Align = getDataLayout().getABITypeAlignment(<br>
> - Type::getInt64Ty(getGlobalContext()));<br>
> + unsigned Int64Align =<br>
> + getDataLayout().getABITypeAlignment(Type::getInt64Ty(getGlobalContext()));<br>
> bool UseInt64 = (DontCheckAlignment || Align >= Int64Align);<br>
><br>
> unsigned ElementSize = UseInt64 ? 8 : 4;<br>
> @@ -359,8 +359,8 @@ void DefaultABI::PassInIntegerRegisters(<br>
> Type *ArrayElementType = NULL;<br>
> if (ArraySize) {<br>
> Size = Size % ElementSize;<br>
> - ArrayElementType = (UseInt64 ? Type::getInt64Ty(getGlobalContext()) :<br>
> - Type::getInt32Ty(getGlobalContext()));<br>
> + ArrayElementType = (UseInt64 ? Type::getInt64Ty(getGlobalContext())<br>
> + : Type::getInt32Ty(getGlobalContext()));<br>
> ATy = ArrayType::get(ArrayElementType, ArraySize);<br>
> }<br>
><br>
> @@ -417,9 +417,9 @@ void DefaultABI::PassInMixedRegisters(Ty<br>
> // that occupies storage but has no useful information, and is not passed<br>
> // anywhere". Happens on x86-64.<br>
> std::vector<Type *> Elts(OrigElts);<br>
> - Type *wordType = getDataLayout().getPointerSize(0) == 4 ?<br>
> - Type::getInt32Ty(getGlobalContext()) :<br>
> - Type::getInt64Ty(getGlobalContext());<br>
> + Type *wordType = getDataLayout().getPointerSize(0) == 4<br>
> + ? Type::getInt32Ty(getGlobalContext())<br>
> + : Type::getInt64Ty(getGlobalContext());<br>
> for (unsigned i = 0, e = Elts.size(); i != e; ++i)<br>
> if (OrigElts[i]->isVoidTy())<br>
> Elts[i] = wordType;<br>
> @@ -437,8 +437,8 @@ void DefaultABI::PassInMixedRegisters(Ty<br>
> unsigned N = STy->getNumElements();<br>
> llvm::Type *LastEltTy = STy->getElementType(N - 1);<br>
> if (LastEltTy->isIntegerTy())<br>
> - LastEltSizeDiff = getDataLayout().getTypeAllocSize(LastEltTy) -<br>
> - (Size - InSize);<br>
> + LastEltSizeDiff =<br>
> + getDataLayout().getTypeAllocSize(LastEltTy) - (Size - InSize);<br>
> }<br>
> }<br>
> for (unsigned i = 0, e = Elts.size(); i != e; ++i) {<br>
><br>
> Modified: dragonegg/trunk/src/Trees.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Trees.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/Trees.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/Trees.cpp (original)<br>
> +++ dragonegg/trunk/src/Trees.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -53,8 +53,8 @@ using namespace llvm;<br>
><br>
> /// concatIfNotEmpty - Concatenate the given strings if they are both non-empty.<br>
> /// Otherwise return the empty string.<br>
> -static std::string concatIfNotEmpty(const std::string &Left,<br>
> - const std::string &Right) {<br>
> +static std::string<br>
> +concatIfNotEmpty(const std::string &Left, const std::string &Right) {<br>
> if (Left.empty() || Right.empty())<br>
> return std::string();<br>
> return Left + Right;<br>
> @@ -156,9 +156,9 @@ APInt getAPIntValue(const_tree exp, unsi<br>
> assert(integerPartWidth == 2 * HOST_BITS_PER_WIDE_INT &&<br>
> "Unsupported host integer width!");<br>
> unsigned ShiftAmt = HOST_BITS_PER_WIDE_INT;<br>
> - integerPart Part = integerPart((unsigned HOST_WIDE_INT) val.low) +<br>
> - (integerPart((unsigned HOST_WIDE_INT) val.high)<br>
> - << ShiftAmt);<br>
> + integerPart Part =<br>
> + integerPart((unsigned HOST_WIDE_INT) val.low) +<br>
> + (integerPart((unsigned HOST_WIDE_INT) val.high) << ShiftAmt);<br>
> DefaultValue = APInt(DefaultWidth, Part);<br>
> }<br>
><br>
> @@ -166,8 +166,8 @@ APInt getAPIntValue(const_tree exp, unsi<br>
> return DefaultValue;<br>
><br>
> if (Bitwidth > DefaultWidth)<br>
> - return TYPE_UNSIGNED(TREE_TYPE(exp)) ? DefaultValue.zext(Bitwidth) :<br>
> - DefaultValue.sext(Bitwidth);<br>
> + return TYPE_UNSIGNED(TREE_TYPE(exp)) ? DefaultValue.zext(Bitwidth)<br>
> + : DefaultValue.sext(Bitwidth);<br>
><br>
> assert((TYPE_UNSIGNED(TREE_TYPE(exp)) ||<br>
> DefaultValue.trunc(Bitwidth).sext(DefaultWidth) == DefaultValue) &&<br>
><br>
> Modified: dragonegg/trunk/src/TypeConversion.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/TypeConversion.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/TypeConversion.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/TypeConversion.cpp (original)<br>
> +++ dragonegg/trunk/src/TypeConversion.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -85,8 +85,8 @@ class ContainedTypeIterator {<br>
> public:<br>
> /// Dereference operator.<br>
> tree operator*() {<br>
> - return isa<TREE_LIST>(type_ref) ? TREE_VALUE(type_ref) :<br>
> - TREE_TYPE(type_ref);<br>
> + return isa<TREE_LIST>(type_ref) ? TREE_VALUE(type_ref)<br>
> + : TREE_TYPE(type_ref);<br>
> }<br>
> ;<br>
><br>
> @@ -465,8 +465,9 @@ Type *getRegType(tree type) {<br>
> case REFERENCE_TYPE: {<br>
> // void* -> byte*<br>
> unsigned AS = TYPE_ADDR_SPACE(type);<br>
> - return isa<VOID_TYPE>(TREE_TYPE(type)) ? GetUnitPointerType(Context, AS) :<br>
> - ConvertType(TREE_TYPE(type))->getPointerTo(AS);<br>
> + return isa<VOID_TYPE>(TREE_TYPE(type))<br>
> + ? GetUnitPointerType(Context, AS)<br>
> + : ConvertType(TREE_TYPE(type))->getPointerTo(AS);<br>
> }<br>
><br>
> case REAL_TYPE:<br>
> @@ -680,8 +681,8 @@ FunctionType *ConvertArgListToFnType(<br>
> #endif<br>
><br>
> if (RAttrBuilder.hasAttributes())<br>
> - Attrs.push_back(AttributeSet::get(Context, AttributeSet::ReturnIndex,<br>
> - RAttrBuilder));<br>
> + Attrs.push_back(<br>
> + AttributeSet::get(Context, AttributeSet::ReturnIndex, RAttrBuilder));<br>
><br>
> // If this function returns via a shadow argument, the dest loc is passed<br>
> // in as a pointer. Mark that pointer as struct-ret and noalias.<br>
> @@ -715,17 +716,16 @@ FunctionType *ConvertArgListToFnType(<br>
> PAttrBuilder.addAttribute(Attribute::NoAlias);<br>
><br>
> if (PAttrBuilder.hasAttributes())<br>
> - Attrs.push_back(AttributeSet::get(Context, ArgTys.size(),<br>
> - PAttrBuilder));<br>
> + Attrs.push_back(AttributeSet::get(Context, ArgTys.size(), PAttrBuilder));<br>
> }<br>
><br>
> PAL = AttributeSet::get(Context, Attrs);<br>
> return FunctionType::get(RetTy, ArgTys, false);<br>
> }<br>
><br>
> -FunctionType *ConvertFunctionType(tree type, tree decl, tree static_chain,<br>
> - CallingConv::ID &CallingConv,<br>
> - AttributeSet &PAL) {<br>
> +FunctionType *<br>
> +ConvertFunctionType(tree type, tree decl, tree static_chain,<br>
> + CallingConv::ID &CallingConv, AttributeSet &PAL) {<br>
> Type *RetTy = Type::getVoidTy(Context);<br>
> SmallVector<Type *, 8> ArgTypes;<br>
> FunctionTypeConversion Client(RetTy, ArgTypes, CallingConv,<br>
> @@ -795,8 +795,8 @@ FunctionType *ConvertFunctionType(tree t<br>
> RAttrBuilder.addAttribute(Attribute::NoAlias);<br>
><br>
> if (RAttrBuilder.hasAttributes())<br>
> - Attrs.push_back(AttributeSet::get(Context, AttributeSet::ReturnIndex,<br>
> - RAttrBuilder));<br>
> + Attrs.push_back(<br>
> + AttributeSet::get(Context, AttributeSet::ReturnIndex, RAttrBuilder));<br>
><br>
> // If this function returns via a shadow argument, the dest loc is passed<br>
> // in as a pointer. Mark that pointer as struct-ret and noalias.<br>
> @@ -811,8 +811,8 @@ FunctionType *ConvertFunctionType(tree t<br>
> // Pass the static chain as the first parameter.<br>
> ABIConverter.HandleArgument(TREE_TYPE(static_chain), ScalarArgs);<br>
> // Mark it as the chain argument.<br>
> - Attrs.push_back(AttributeSet::get(Context, ArgTypes.size(),<br>
> - Attribute::Nest));<br>
> + Attrs.push_back(<br>
> + AttributeSet::get(Context, ArgTypes.size(), Attribute::Nest));<br>
> }<br>
><br>
> #ifdef LLVM_TARGET_ENABLE_REGPARM<br>
> @@ -898,8 +898,8 @@ FunctionType *ConvertFunctionType(tree t<br>
> assert(RetTy && "Return type not specified!");<br>
><br>
> if (FnAttrBuilder.hasAttributes())<br>
> - Attrs.push_back(AttributeSet::get(Context, AttributeSet::FunctionIndex,<br>
> - FnAttrBuilder));<br>
> + Attrs.push_back(<br>
> + AttributeSet::get(Context, AttributeSet::FunctionIndex, FnAttrBuilder));<br>
><br>
> // Finally, make the function type and result attributes.<br>
> PAL = AttributeSet::get(Context, Attrs);<br>
> @@ -1044,8 +1044,8 @@ public:<br>
> // If the type is something like i17 then round it up to a multiple of a<br>
> // byte. This is not needed for correctness, but helps the optimizers.<br>
> if ((Ty->getPrimitiveSizeInBits() % BITS_PER_UNIT) != 0) {<br>
> - unsigned BitWidth = RoundUpToAlignment(Ty->getPrimitiveSizeInBits(),<br>
> - BITS_PER_UNIT);<br>
> + unsigned BitWidth =<br>
> + RoundUpToAlignment(Ty->getPrimitiveSizeInBits(), BITS_PER_UNIT);<br>
> Ty = IntegerType::get(Context, BitWidth);<br>
> if (isSafeToReturnContentsDirectly(DL))<br>
> return Ty;<br>
> @@ -1093,8 +1093,8 @@ static Type *ConvertRecordTypeRecursive(<br>
><br>
> // Get the size of the type in bits. If the type has variable or ginormous<br>
> // size then it is convenient to pretend it is "infinitely" big.<br>
> - uint64_t TypeSize = isInt64(TYPE_SIZE(type), true) ?<br>
> - getInt64(TYPE_SIZE(type), true) : ~0UL;<br>
> + uint64_t TypeSize =<br>
> + isInt64(TYPE_SIZE(type), true) ? getInt64(TYPE_SIZE(type), true) : ~0UL;<br>
><br>
> // Record all interesting fields so they can easily be visited backwards.<br>
> SmallVector<tree, 16> Fields;<br>
> @@ -1353,8 +1353,8 @@ static Type *ConvertTypeRecursive(tree t<br>
> CallingConv::ID CallingConv;<br>
> AttributeSet PAL;<br>
> // No declaration to pass through, passing NULL.<br>
> - return RememberTypeConversion(type, ConvertFunctionType(type, NULL, NULL,<br>
> - CallingConv, PAL));<br>
> + return RememberTypeConversion(<br>
> + type, ConvertFunctionType(type, NULL, NULL, CallingConv, PAL));<br>
> }<br>
><br>
> case POINTER_TYPE:<br>
><br>
> Modified: dragonegg/trunk/src/arm/Target.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/arm/Target.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/arm/Target.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/arm/Target.cpp (original)<br>
> +++ dragonegg/trunk/src/arm/Target.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -78,8 +78,8 @@ enum arm_fdts {<br>
> static bool vfp_arg_homogeneous_aggregate_p(enum machine_mode mode, tree type,<br>
> int *fdt_counts) {<br>
> bool result = false;<br>
> - HOST_WIDE_INT bytes = (mode == BLKmode) ? int_size_in_bytes(type) :<br>
> - (int) GET_MODE_SIZE(mode);<br>
> + HOST_WIDE_INT bytes =<br>
> + (mode == BLKmode) ? int_size_in_bytes(type) : (int) GET_MODE_SIZE(mode);<br>
><br>
> if (type && isa<AGGREGATE_TYPE>(type)) {<br>
> int i;<br>
> @@ -114,9 +114,8 @@ static bool vfp_arg_homogeneous_aggregat<br>
> if (TREE_TYPE(field) == error_mark_node)<br>
> continue;<br>
><br>
> - result = vfp_arg_homogeneous_aggregate_p(TYPE_MODE(TREE_TYPE(field)),<br>
> - TREE_TYPE(field),<br>
> - fdt_counts);<br>
> + result = vfp_arg_homogeneous_aggregate_p(<br>
> + TYPE_MODE(TREE_TYPE(field)), TREE_TYPE(field), fdt_counts);<br>
> if (!result)<br>
> return false;<br>
> }<br>
> @@ -128,9 +127,8 @@ static bool vfp_arg_homogeneous_aggregat<br>
> {<br>
> int array_fdt_counts[ARM_FDT_MAX] = { 0 };<br>
><br>
> - result = vfp_arg_homogeneous_aggregate_p(TYPE_MODE(TREE_TYPE(type)),<br>
> - TREE_TYPE(type),<br>
> - array_fdt_counts);<br>
> + result = vfp_arg_homogeneous_aggregate_p(<br>
> + TYPE_MODE(TREE_TYPE(type)), TREE_TYPE(type), array_fdt_counts);<br>
><br>
> cnt = bytes / int_size_in_bytes(TREE_TYPE(type));<br>
> for (i = 0; i < ARM_FDT_MAX; ++i)<br>
> @@ -165,8 +163,8 @@ static bool vfp_arg_homogeneous_aggregat<br>
> if (union_field_fdt_counts[i] > 4) // bail early if we can<br>
> return false;<br>
><br>
> - union_fdt_counts[i] = MAX(union_fdt_counts[i],<br>
> - union_field_fdt_counts[i]);<br>
> + union_fdt_counts[i] =<br>
> + MAX(union_fdt_counts[i], union_field_fdt_counts[i]);<br>
> union_field_fdt_counts[i] = 0; // clear it out for next iter<br>
> }<br>
> }<br>
> @@ -216,22 +214,24 @@ static bool vfp_arg_homogeneous_aggregat<br>
><br>
> switch (TREE_CODE(type)) {<br>
> case REAL_TYPE:<br>
> - idx = (TYPE_PRECISION(type) == 32) ? ARM_FDT_FLOAT :<br>
> - ((TYPE_PRECISION(type) == 64) ? ARM_FDT_DOUBLE : ARM_FDT_INVALID);<br>
> + idx = (TYPE_PRECISION(type) == 32)<br>
> + ? ARM_FDT_FLOAT<br>
> + : ((TYPE_PRECISION(type) == 64) ? ARM_FDT_DOUBLE : ARM_FDT_INVALID);<br>
> cnt = 1;<br>
> break;<br>
><br>
> case COMPLEX_TYPE: {<br>
> tree subtype = TREE_TYPE(type);<br>
> - idx = (TYPE_PRECISION(subtype) == 32) ? ARM_FDT_FLOAT :<br>
> - ((TYPE_PRECISION(subtype) == 64) ? ARM_FDT_DOUBLE :<br>
> - ARM_FDT_INVALID);<br>
> + idx = (TYPE_PRECISION(subtype) == 32)<br>
> + ? ARM_FDT_FLOAT<br>
> + : ((TYPE_PRECISION(subtype) == 64) ? ARM_FDT_DOUBLE<br>
> + : ARM_FDT_INVALID);<br>
> cnt = 2;<br>
> } break;<br>
><br>
> case VECTOR_TYPE:<br>
> - idx = (bytes == 8) ? ARM_FDT_VECTOR_64 : (bytes == 16) ?<br>
> - ARM_FDT_VECTOR_128 : ARM_FDT_INVALID;<br>
> + idx = (bytes == 8) ? ARM_FDT_VECTOR_64<br>
> + : (bytes == 16) ? ARM_FDT_VECTOR_128 : ARM_FDT_INVALID;<br>
> cnt = 1;<br>
> break;<br>
><br>
> @@ -558,8 +558,8 @@ void llvm_arm_extract_multiple_return_va<br>
> unsigned i = 0;<br>
> unsigned Size = 1;<br>
><br>
> - if (const VectorType *SElemTy = dyn_cast<VectorType>(<br>
> - STy->getElementType(SNO))) {<br>
> + if (const VectorType *SElemTy =<br>
> + dyn_cast<VectorType>(STy->getElementType(SNO))) {<br>
> Size = SElemTy->getNumElements();<br>
> }<br>
> while (i < Size) {<br>
><br>
> Modified: dragonegg/trunk/src/x86/Target.cpp<br>
> URL: <a href="http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/x86/Target.cpp?rev=176016&r1=176015&r2=176016&view=diff" target="_blank" class="cremed">http://llvm.org/viewvc/llvm-project/dragonegg/trunk/src/x86/Target.cpp?rev=176016&r1=176015&r2=176016&view=diff</a><br>
> ==============================================================================<br>
> --- dragonegg/trunk/src/x86/Target.cpp (original)<br>
> +++ dragonegg/trunk/src/x86/Target.cpp Mon Feb 25 04:54:25 2013<br>
> @@ -146,8 +146,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> Handler = UnsupportedBuiltin;<br>
> const char *Identifier = IDENTIFIER_POINTER(DECL_NAME(fndecl));<br>
> HandlerEntry ToFind = { Identifier, SearchForHandler };<br>
> - const HandlerEntry *E = std::lower_bound(Handlers, Handlers + N, ToFind,<br>
> - HandlerLT);<br>
> + const HandlerEntry *E =<br>
> + std::lower_bound(Handlers, Handlers + N, ToFind, HandlerLT);<br>
> if ((E < Handlers + N) && !strcmp(E->Name, ToFind.Name))<br>
> Handler = E->Handler;<br>
> }<br>
> @@ -290,9 +290,9 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> case shufps:<br>
> if (ConstantInt *Elt = dyn_cast<ConstantInt>(Ops[2])) {<br>
> int EV = Elt->getZExtValue();<br>
> - Result = BuildVectorShuffle(Ops[0], Ops[1], ((EV & 0x03) >> 0),<br>
> - ((EV & 0x0c) >> 2), ((EV & 0x30) >> 4) +<br>
> - 4, ((EV & 0xc0) >> 6) + 4);<br>
> + Result = BuildVectorShuffle(<br>
> + Ops[0], Ops[1], ((EV & 0x03) >> 0), ((EV & 0x0c) >> 2),<br>
> + ((EV & 0x30) >> 4) + 4, ((EV & 0xc0) >> 6) + 4);<br>
> } else {<br>
> error_at(gimple_location(stmt), "mask must be an immediate");<br>
> Result = Ops[0];<br>
> @@ -324,9 +324,9 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> if (ConstantInt *Elt = dyn_cast<ConstantInt>(Ops[1])) {<br>
> int EV = Elt->getZExtValue();<br>
> Result = BuildVectorShuffle(<br>
> - Ops[0], Ops[0], 0, 1, 2, 3, ((EV & 0x03) >> 0) + 4,<br>
> - ((EV & 0x0c) >> 2) + 4, ((EV & 0x30) >> 4) + 4,<br>
> - ((EV & 0xc0) >> 6) + 4);<br>
> + Ops[0], Ops[0], 0, 1, 2, 3, ((EV & 0x03) >> 0) + 4,<br>
> + ((EV & 0x0c) >> 2) + 4, ((EV & 0x30) >> 4) + 4,<br>
> + ((EV & 0xc0) >> 6) + 4);<br>
> return true;<br>
> }<br>
> return false;<br>
> @@ -472,8 +472,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PointerType *f64Ptr = Type::getDoublePtrTy(Context);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], f64Ptr);<br>
> Value *Load = Builder.CreateLoad(Ops[1]);<br>
> - Ops[1] = BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)),<br>
> - NULL);<br>
> + Ops[1] =<br>
> + BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)), NULL);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], ResultType);<br>
> Result = BuildVectorShuffle(Ops[0], Ops[1], 0, 1, 4, 5);<br>
> Result = Builder.CreateBitCast(Result, ResultType);<br>
> @@ -483,8 +483,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PointerType *f64Ptr = Type::getDoublePtrTy(Context);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], f64Ptr);<br>
> Value *Load = Builder.CreateLoad(Ops[1]);<br>
> - Ops[1] = BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)),<br>
> - NULL);<br>
> + Ops[1] =<br>
> + BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)), NULL);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], ResultType);<br>
> Result = BuildVectorShuffle(Ops[0], Ops[1], 4, 5, 2, 3);<br>
> Result = Builder.CreateBitCast(Result, ResultType);<br>
> @@ -494,8 +494,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PointerType *f64Ptr = Type::getDoublePtrTy(Context);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], f64Ptr);<br>
> Value *Load = Builder.CreateLoad(Ops[1]);<br>
> - Ops[1] = BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)),<br>
> - NULL);<br>
> + Ops[1] =<br>
> + BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)), NULL);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], ResultType);<br>
> Result = BuildVectorShuffle(Ops[0], Ops[1], 0, 2);<br>
> Result = Builder.CreateBitCast(Result, ResultType);<br>
> @@ -505,8 +505,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PointerType *f64Ptr = Type::getDoublePtrTy(Context);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], f64Ptr);<br>
> Value *Load = Builder.CreateLoad(Ops[1]);<br>
> - Ops[1] = BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)),<br>
> - NULL);<br>
> + Ops[1] =<br>
> + BuildVector(Load, UndefValue::get(Type::getDoubleTy(Context)), NULL);<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], ResultType);<br>
> Result = BuildVectorShuffle(Ops[0], Ops[1], 2, 1);<br>
> Result = Builder.CreateBitCast(Result, ResultType);<br>
> @@ -627,8 +627,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PredCode = 7;<br>
> goto CMPXXPS;<br>
> CMPXXPS : {<br>
> - Function *cmpps = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse_cmp_ps);<br>
> + Function *cmpps =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse_cmp_ps);<br>
> Value *Pred = ConstantInt::get(Type::getInt8Ty(Context), PredCode);<br>
> Value *Arg0 = Ops[0];<br>
> Value *Arg1 = Ops[1];<br>
> @@ -664,8 +664,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PredCode = 7;<br>
> goto CMPXXSS;<br>
> CMPXXSS : {<br>
> - Function *cmpss = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse_cmp_ss);<br>
> + Function *cmpss =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse_cmp_ss);<br>
> Value *Pred = ConstantInt::get(Type::getInt8Ty(Context), PredCode);<br>
> Value *CallOps[3] = { Ops[0], Ops[1], Pred };<br>
> Result = Builder.CreateCall(cmpss, CallOps);<br>
> @@ -713,8 +713,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PredCode = 7;<br>
> goto CMPXXPD;<br>
> CMPXXPD : {<br>
> - Function *cmppd = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse2_cmp_pd);<br>
> + Function *cmppd =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse2_cmp_pd);<br>
> Value *Pred = ConstantInt::get(Type::getInt8Ty(Context), PredCode);<br>
> Value *Arg0 = Ops[0];<br>
> Value *Arg1 = Ops[1];<br>
> @@ -751,8 +751,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> PredCode = 7;<br>
> goto CMPXXSD;<br>
> CMPXXSD : {<br>
> - Function *cmpsd = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse2_cmp_sd);<br>
> + Function *cmpsd =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse2_cmp_sd);<br>
> Value *Pred = ConstantInt::get(Type::getInt8Ty(Context), PredCode);<br>
> Value *CallOps[3] = { Ops[0], Ops[1], Pred };<br>
> Result = Builder.CreateCall(cmpsd, CallOps);<br>
> @@ -760,8 +760,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> return true;<br>
> }<br>
> case ldmxcsr: {<br>
> - Function *ldmxcsr = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse_ldmxcsr);<br>
> + Function *ldmxcsr =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse_ldmxcsr);<br>
> Value *Ptr = CreateTemporary(Type::getInt32Ty(Context));<br>
> Builder.CreateStore(Ops[0], Ptr);<br>
> Ptr = Builder.CreateBitCast(Ptr, Type::getInt8PtrTy(Context));<br>
> @@ -769,8 +769,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> return true;<br>
> }<br>
> case stmxcsr: {<br>
> - Function *stmxcsr = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse_stmxcsr);<br>
> + Function *stmxcsr =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse_stmxcsr);<br>
> Value *Ptr = CreateTemporary(Type::getInt32Ty(Context));<br>
> Value *BPtr = Builder.CreateBitCast(Ptr, Type::getInt8PtrTy(Context));<br>
> Builder.CreateCall(stmxcsr, BPtr);<br>
> @@ -817,10 +817,10 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> Ops[1] = Builder.CreateBitCast(Ops[1], MMXTy);<br>
><br>
> // create i32 constant<br>
> - Function *F = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_mmx_psrl_q);<br>
> - Result = Builder.CreateCall(F, ArrayRef<Value *>(&Ops[0], 2),<br>
> - "palignr");<br>
> + Function *F =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_mmx_psrl_q);<br>
> + Result =<br>
> + Builder.CreateCall(F, ArrayRef<Value *>(&Ops[0], 2), "palignr");<br>
> Result = Builder.CreateBitCast(Result, ResultType);<br>
> return true;<br>
> }<br>
> @@ -872,10 +872,10 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> Ops[1] = ConstantInt::get(IntTy, (shiftVal - 16) * 8);<br>
><br>
> // create i32 constant<br>
> - Function *F = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse2_psrl_dq);<br>
> - Result = Builder.CreateCall(F, ArrayRef<Value *>(&Ops[0], 2),<br>
> - "palignr");<br>
> + Function *F =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse2_psrl_dq);<br>
> + Result =<br>
> + Builder.CreateCall(F, ArrayRef<Value *>(&Ops[0], 2), "palignr");<br>
> Result = Builder.CreateBitCast(Result, ResultType);<br>
> return true;<br>
> }<br>
> @@ -904,7 +904,7 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> // Convert the type of the pointer to a pointer to the stored type.<br>
> unsigned AS = Ops[0]->getType()->getPointerAddressSpace();<br>
> Value *Ptr = Builder.CreateBitCast(<br>
> - Ops[0], PointerType::get(Ops[1]->getType(), AS), "cast");<br>
> + Ops[0], PointerType::get(Ops[1]->getType(), AS), "cast");<br>
><br>
> StoreInst *SI = Builder.CreateAlignedStore(Ops[1], Ptr, 16);<br>
> SI->setMetadata(TheModule->getMDKindID("nontemporal"), Node);<br>
> @@ -913,8 +913,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> case rsqrtf: {<br>
> // rsqrtss with a Newton-Raphson step to improve accuracy:<br>
> // rsqrtf(x) = rsqrtss(x) * -0.5 * (rsqrtss(x) * x * rsqrtss(x) - 3.0)<br>
> - Function *rsqrtss = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse_rsqrt_ss);<br>
> + Function *rsqrtss =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse_rsqrt_ss);<br>
> // As rsqrtss is declared as taking a <4 x float> operand, mulch the operand<br>
> // into a vector.<br>
> Value *X = Ops[0];<br>
> @@ -930,9 +930,9 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> R = Builder.CreateFPExt(R, X->getType()); // rsqrtss(x)<br>
><br>
> // Perform the Newton-Raphson step.<br>
> - Value *RHS = Builder.CreateFAdd(Builder.CreateFMul(Builder.CreateFMul(R, X),<br>
> - R),<br>
> - ConstantFP::get(X->getType(), -3.0));<br>
> + Value *RHS =<br>
> + Builder.CreateFAdd(Builder.CreateFMul(Builder.CreateFMul(R, X), R),<br>
> + ConstantFP::get(X->getType(), -3.0));<br>
> Value *LHS = Builder.CreateFMul(R, ConstantFP::get(X->getType(), -0.5));<br>
> Result = Builder.CreateFMul(LHS, RHS);<br>
> return true;<br>
> @@ -940,13 +940,13 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> case rsqrtps_nr: {<br>
> // rsqrtps with a Newton-Raphson step to improve accuracy:<br>
> // rsqrtps_nr(x) = rsqrtps(x) * -0.5 * (rsqrtps(x) * x * rsqrtps(x) - 3.0)<br>
> - Function *rsqrtps = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse_rsqrt_ps);<br>
> + Function *rsqrtps =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse_rsqrt_ps);<br>
> Value *X = Ops[0]; // x<br>
> Value *R = Builder.CreateCall(rsqrtps, X); // rsqrtps(x)<br>
> - Value *RHS = Builder.CreateFAdd(Builder.CreateFMul(Builder.CreateFMul(R, X),<br>
> - R),<br>
> - ConstantFP::get(X->getType(), -3.0));<br>
> + Value *RHS =<br>
> + Builder.CreateFAdd(Builder.CreateFMul(Builder.CreateFMul(R, X), R),<br>
> + ConstantFP::get(X->getType(), -3.0));<br>
> Value *LHS = Builder.CreateFMul(R, ConstantFP::get(X->getType(), -0.5));<br>
> Result = Builder.CreateFMul(LHS, RHS);<br>
> return true;<br>
> @@ -954,8 +954,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> case sqrtps_nr: {<br>
> // Turn this into sqrtps without a Newton-Raphson step - sqrtps is already<br>
> // accurate enough.<br>
> - Function *sqrtps = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_sse_sqrt_ps);<br>
> + Function *sqrtps =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_sse_sqrt_ps);<br>
> Result = Builder.CreateCall(sqrtps, Ops[0]);<br>
> return true;<br>
> }<br>
> @@ -984,7 +984,7 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> return false;<br>
> if (!MaskTy->getElementType()->isIntegerTy(32))<br>
> Mask = ConstantExpr::getIntegerCast(<br>
> - Mask, VectorType::get(Builder.getInt32Ty(), NElts), false);<br>
> + Mask, VectorType::get(Builder.getInt32Ty(), NElts), false);<br>
> Result = Builder.CreateShuffleVector(Ops[0], Ops[1], Mask);<br>
> return true;<br>
> }<br>
> @@ -1016,8 +1016,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> case pswapdsi: {<br>
> Type *MMXTy = Type::getX86_MMXTy(Context);<br>
> Ops[0] = Builder.CreateBitCast(Ops[0], MMXTy);<br>
> - Function *pswapd = Intrinsic::getDeclaration(TheModule,<br>
> - Intrinsic::x86_3dnowa_pswapd);<br>
> + Function *pswapd =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::x86_3dnowa_pswapd);<br>
> Result = Builder.CreateCall(pswapd, Ops[0]);<br>
> Result = Builder.CreateBitCast(Result, ResultType);<br>
> return true;<br>
> @@ -1026,8 +1026,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> // The value is usually passed in as an int rather than as a short.<br>
> Type *Int16Ty = Builder.getInt16Ty();<br>
> Result = Builder.CreateTruncOrBitCast(Ops[0], Int16Ty);<br>
> - Function *ctlz = Intrinsic::getDeclaration(TheModule, Intrinsic::ctlz,<br>
> - Int16Ty);<br>
> + Function *ctlz =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::ctlz, Int16Ty);<br>
> Result = Builder.CreateCall2(ctlz, Result, Builder.getTrue());<br>
> return true;<br>
> }<br>
> @@ -1035,8 +1035,8 @@ bool TreeToLLVM::TargetIntrinsicLower(<br>
> // The value is usually passed in as an int rather than as a short.<br>
> Type *Int16Ty = Builder.getInt16Ty();<br>
> Result = Builder.CreateTruncOrBitCast(Ops[0], Int16Ty);<br>
> - Function *cttz = Intrinsic::getDeclaration(TheModule, Intrinsic::cttz,<br>
> - Int16Ty);<br>
> + Function *cttz =<br>
> + Intrinsic::getDeclaration(TheModule, Intrinsic::cttz, Int16Ty);<br>
> Result = Builder.CreateCall2(cttz, Result, Builder.getTrue());<br>
> return true;<br>
> }<br>
> @@ -1119,8 +1119,9 @@ bool llvm_x86_32_should_pass_aggregate_i<br>
> // 32 and 64-bit integers are fine, as are float and double. Long double<br>
> // (which can be picked as the type for a union of 16 bytes) is not fine,<br>
> // as loads and stores of it get only 10 bytes.<br>
> - if (EltTy == Type::getInt32Ty(Context) || EltTy ==<br>
> - Type::getInt64Ty(Context) || EltTy == Type::getFloatTy(Context) ||<br>
> + if (EltTy == Type::getInt32Ty(Context) ||<br>
> + EltTy == Type::getInt64Ty(Context) ||<br>
> + EltTy == Type::getFloatTy(Context) ||<br>
> EltTy == Type::getDoubleTy(Context) || EltTy->isPointerTy()) {<br>
> Elts.push_back(EltTy);<br>
> continue;<br>
> @@ -1151,8 +1152,8 @@ bool llvm_x86_should_pass_aggregate_as_f<br>
> Type *EltTy = STy->getElementType(0);<br>
> return !((TARGET_64BIT &&<br>
> (EltTy->isIntegerTy() || EltTy == Type::getFloatTy(Context) ||<br>
> - EltTy == Type::getDoubleTy(Context))) ||<br>
> - EltTy->isIntegerTy(16) || EltTy->isIntegerTy(8));<br>
> + EltTy == Type::getDoubleTy(Context))) || EltTy->isIntegerTy(16) ||<br>
> + EltTy->isIntegerTy(8));<br>
> }<br>
><br>
> /* Target hook for llvm-abi.h. It returns true if an aggregate of the<br>
> @@ -1162,8 +1163,8 @@ bool llvm_x86_should_pass_aggregate_in_m<br>
> return false;<br>
><br>
> enum machine_mode Mode = type_natural_mode(TreeType, NULL);<br>
> - HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(TreeType) :<br>
> - (int) GET_MODE_SIZE(Mode);<br>
> + HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(TreeType) : (int)<br>
> + GET_MODE_SIZE(Mode);<br>
><br>
> // Zero sized array, struct, or class, not passed in memory.<br>
> if (Bytes == 0)<br>
> @@ -1265,8 +1266,8 @@ bool llvm_x86_64_should_pass_aggregate_i<br>
> enum x86_64_reg_class Class[MAX_CLASSES];<br>
> enum machine_mode Mode = type_natural_mode(TreeType, NULL);<br>
> bool totallyEmpty = true;<br>
> - HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(TreeType) :<br>
> - (int) GET_MODE_SIZE(Mode);<br>
> + HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(TreeType) : (int)<br>
> + GET_MODE_SIZE(Mode);<br>
> int NumClasses = classify_argument(Mode, TreeType, Class, 0);<br>
> if (!NumClasses)<br>
> return false;<br>
> @@ -1549,8 +1550,8 @@ Type *llvm_x86_scalar_type_for_struct_re<br>
> if (Class[0] == X86_64_INTEGERSI_CLASS ||<br>
> Class[0] == X86_64_INTEGER_CLASS) {<br>
> // one int register<br>
> - HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(type) :<br>
> - (int) GET_MODE_SIZE(Mode);<br>
> + HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(type)<br>
> + : (int) GET_MODE_SIZE(Mode);<br>
> if (Bytes > 4)<br>
> return Type::getInt64Ty(Context);<br>
> else if (Bytes > 2)<br>
> @@ -1607,8 +1608,8 @@ static void llvm_x86_64_get_multiple_ret<br>
> tree TreeType, Type */*Ty*/, std::vector<Type *> &Elts) {<br>
> enum x86_64_reg_class Class[MAX_CLASSES];<br>
> enum machine_mode Mode = type_natural_mode(TreeType, NULL);<br>
> - HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(TreeType) :<br>
> - (int) GET_MODE_SIZE(Mode);<br>
> + HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(TreeType) : (int)<br>
> + GET_MODE_SIZE(Mode);<br>
> int NumClasses = classify_argument(Mode, TreeType, Class, 0);<br>
> assert(NumClasses && "This type does not need multiple return registers!");<br>
><br>
> @@ -1859,8 +1860,8 @@ void llvm_x86_extract_multiple_return_va<br>
> unsigned i = 0;<br>
> unsigned Size = 1;<br>
><br>
> - if (VectorType *SElemTy = dyn_cast<<br>
> - VectorType>(STy->getElementType(SNO))) {<br>
> + if (VectorType *SElemTy =<br>
> + dyn_cast<VectorType>(STy->getElementType(SNO))) {<br>
> Size = SElemTy->getNumElements();<br>
> if (SElemTy->getElementType()->getTypeID() == Type::FloatTyID &&<br>
> Size == 4)<br>
> @@ -1896,8 +1897,8 @@ bool llvm_x86_should_pass_aggregate_in_i<br>
> if (NumClasses == 1 && (Class[0] == X86_64_INTEGER_CLASS ||<br>
> Class[0] == X86_64_INTEGERSI_CLASS)) {<br>
> // one int register<br>
> - HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(type) :<br>
> - (int) GET_MODE_SIZE(Mode);<br>
> + HOST_WIDE_INT Bytes = (Mode == BLKmode) ? int_size_in_bytes(type) : (int)<br>
> + GET_MODE_SIZE(Mode);<br>
> if (Bytes > 4)<br>
> *size = 8;<br>
> else if (Bytes > 2)<br>
><br>
><br>
> _______________________________________________<br>
> llvm-commits mailing list<br>
> <a href="mailto:llvm-commits@cs.uiuc.edu" class="cremed">llvm-commits@cs.uiuc.edu</a><br>
> <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits" target="_blank" class="cremed">http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits</a><br>
</blockquote></div><br></div></div></div>