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