[llvm-commits] [dragonegg] r173244 - in /dragonegg/trunk/include: arm/dragonegg/Target.h darwin/dragonegg/OS.h dragonegg/ABI.h dragonegg/ADT/IntervalList.h dragonegg/ADT/Range.h dragonegg/Aliasing.h dragonegg/Cache.h dragonegg/ConstantConversion.h dragonegg/Debug.h dragonegg/Internals.h dragonegg/Trees.h dragonegg/TypeConversion.h freebsd/dragonegg/OS.h kfreebsd/dragonegg/OS.h linux/dragonegg/OS.h openbsd/dragonegg/OS.h x86/dragonegg/Target.h
Duncan Sands
baldrick at free.fr
Wed Jan 23 01:38:52 PST 2013
Author: baldrick
Date: Wed Jan 23 03:38:51 2013
New Revision: 173244
URL: http://llvm.org/viewvc/llvm-project?rev=173244&view=rev
Log:
Reformat using the excellent clang-format.
Modified:
dragonegg/trunk/include/arm/dragonegg/Target.h
dragonegg/trunk/include/darwin/dragonegg/OS.h
dragonegg/trunk/include/dragonegg/ABI.h
dragonegg/trunk/include/dragonegg/ADT/IntervalList.h
dragonegg/trunk/include/dragonegg/ADT/Range.h
dragonegg/trunk/include/dragonegg/Aliasing.h
dragonegg/trunk/include/dragonegg/Cache.h
dragonegg/trunk/include/dragonegg/ConstantConversion.h
dragonegg/trunk/include/dragonegg/Debug.h
dragonegg/trunk/include/dragonegg/Internals.h
dragonegg/trunk/include/dragonegg/Trees.h
dragonegg/trunk/include/dragonegg/TypeConversion.h
dragonegg/trunk/include/freebsd/dragonegg/OS.h
dragonegg/trunk/include/kfreebsd/dragonegg/OS.h
dragonegg/trunk/include/linux/dragonegg/OS.h
dragonegg/trunk/include/openbsd/dragonegg/OS.h
dragonegg/trunk/include/x86/dragonegg/Target.h
Modified: dragonegg/trunk/include/arm/dragonegg/Target.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/arm/dragonegg/Target.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/arm/dragonegg/Target.h (original)
+++ dragonegg/trunk/include/arm/dragonegg/Target.h Wed Jan 23 03:38:51 2013
@@ -31,79 +31,71 @@
(isVoid || hasArgList). */
/* from TARGET_AAPCS_BASED */
-#define DEFAULT_TARGET_AAPCS_BASED \
- (ARM_DEFAULT_ABI != ARM_ABI_APCS && ARM_DEFAULT_ABI != ARM_ABI_ATPCS)
+#define DEFAULT_TARGET_AAPCS_BASED(ARM_DEFAULT_ABI != ARM_ABI_APCS && \
+ ARM_DEFAULT_ABI != ARM_ABI_ATPCS)
-#define TARGET_ADJUST_LLVM_CC(CC, type) \
- { \
- if (TARGET_AAPCS_BASED) { \
- if (TARGET_VFP && TARGET_HARD_FLOAT_ABI && \
- ((TYPE_ARG_TYPES(type) == 0) || \
- (TREE_VALUE(tree_last(TYPE_ARG_TYPES(type))) == \
- void_type_node))) \
- CC = CallingConv::ARM_AAPCS_VFP; \
- else if (!DEFAULT_TARGET_AAPCS_BASED) \
- CC = CallingConv::ARM_AAPCS; \
- } else if (DEFAULT_TARGET_AAPCS_BASED) { \
- CC = CallingConv::ARM_APCS; \
- } \
+#define TARGET_ADJUST_LLVM_CC(CC, type) \
+ { \
+ if (TARGET_AAPCS_BASED) { \
+ if (TARGET_VFP && TARGET_HARD_FLOAT_ABI && \
+ ((TYPE_ARG_TYPES(type) == 0) || \
+ (TREE_VALUE(tree_last(TYPE_ARG_TYPES(type))) == void_type_node))) \
+ CC = CallingConv::ARM_AAPCS_VFP; \
+ else if (!DEFAULT_TARGET_AAPCS_BASED) \
+ CC = CallingConv::ARM_AAPCS; \
+ } else if (DEFAULT_TARGET_AAPCS_BASED) { \
+ CC = CallingConv::ARM_APCS; \
+ } \
}
#ifdef DRAGONEGG_ABI_H
-extern bool
-llvm_arm_should_pass_aggregate_in_mixed_regs(tree_node *, Type *Ty,
- CallingConv::ID,
- std::vector<Type*>&);
+extern bool llvm_arm_should_pass_aggregate_in_mixed_regs(
+ tree_node *, Type *Ty, CallingConv::ID, std::vector<Type *> &);
-#define LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS(T, TY, CC, E) \
- llvm_arm_should_pass_aggregate_in_mixed_regs((T), (TY), (CC), (E))
+#define LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS(T, TY, CC, E) \
+ llvm_arm_should_pass_aggregate_in_mixed_regs((T), (TY), (CC), (E))
struct DefaultABIClient;
-extern bool
-llvm_arm_try_pass_aggregate_custom(tree_node *, std::vector<Type*>&,
- CallingConv::ID CC,
- struct DefaultABIClient*);
+extern bool llvm_arm_try_pass_aggregate_custom(
+ tree_node *, std::vector<Type *> &, CallingConv::ID CC,
+ struct DefaultABIClient *);
-#define LLVM_TRY_PASS_AGGREGATE_CUSTOM(T, E, CC, C) \
+#define LLVM_TRY_PASS_AGGREGATE_CUSTOM(T, E, CC, C) \
llvm_arm_try_pass_aggregate_custom((T), (E), (CC), (C))
-extern
-bool llvm_arm_aggregate_partially_passed_in_regs(std::vector<Type*>&,
- std::vector<Type*>&,
- CallingConv::ID CC);
+extern bool llvm_arm_aggregate_partially_passed_in_regs(
+ std::vector<Type *> &, std::vector<Type *> &, CallingConv::ID CC);
-#define LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(E, SE, ISR, CC) \
- llvm_arm_aggregate_partially_passed_in_regs((E), (SE), (CC))
+#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);
/* LLVM_AGGR_TYPE_FOR_STRUCT_RETURN - Return LLVM Type if X can be
returned as an aggregate, otherwise return NULL. */
-#define LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(X, CC) \
- llvm_arm_aggr_type_for_struct_return((X), (CC))
+#define LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(X, CC) \
+ llvm_arm_aggr_type_for_struct_return((X), (CC))
-extern void llvm_arm_extract_multiple_return_value(Value *Src, Value *Dest,
- bool isVolatile,
- LLVMBuilder &B);
+extern void llvm_arm_extract_multiple_return_value(
+ Value *Src, Value *Dest, bool isVolatile, LLVMBuilder &B);
/* LLVM_EXTRACT_MULTIPLE_RETURN_VALUE - Extract multiple return value from
SRC and assign it to DEST. */
-#define LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Src,Dest,V,B) \
- llvm_arm_extract_multiple_return_value((Src),(Dest),(V),(B))
+#define LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Src, Dest, V, B) \
+ llvm_arm_extract_multiple_return_value((Src), (Dest), (V), (B))
-extern
-bool llvm_arm_should_pass_or_return_aggregate_in_regs(tree_node *TreeType,
- CallingConv::ID CC);
+extern bool llvm_arm_should_pass_or_return_aggregate_in_regs(
+ tree_node *TreeType, CallingConv::ID CC);
/* LLVM_SHOULD_NOT_USE_SHADOW_RETURN = Return true is the given type should
not be returned via a shadow parameter with the given calling conventions. */
-#define LLVM_SHOULD_NOT_USE_SHADOW_RETURN(X, CC) \
- llvm_arm_should_pass_or_return_aggregate_in_regs((X), (CC))
+#define LLVM_SHOULD_NOT_USE_SHADOW_RETURN(X, CC) \
+ llvm_arm_should_pass_or_return_aggregate_in_regs((X), (CC))
/* Vectors bigger than 128 are returned using sret. */
-#define LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW(X, isBuiltin) \
+#define LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW(X, isBuiltin) \
(TREE_INT_CST_LOW(TYPE_SIZE(X)) > 128)
#endif /* DRAGONEGG_ABI_H */
@@ -115,126 +107,201 @@
*/
#define LLVM_TARGET_NAME ARM
-
/* Turn -march=xx into a CPU type.
*/
-#define LLVM_SET_SUBTARGET_FEATURES(C, F) \
- { switch (arm_tune) { \
- case arm8: C = ("arm8"); break;\
- case arm810: C = ("arm810"); break;\
- case strongarm: C = ("strongarm"); break;\
- case strongarm110: C = ("strongarm110"); break;\
- case strongarm1100: C = ("strongarm1100"); break;\
- case strongarm1110: C = ("strongarm1110"); break;\
- case arm7tdmi: C = ("arm7tdmi"); break;\
- case arm7tdmis: C = ("arm7tdmi-s"); break;\
- case arm710t: C = ("arm710t"); break;\
- case arm720t: C = ("arm720t"); break;\
- case arm740t: C = ("arm740t"); break;\
- case arm9: C = ("arm9"); break;\
- case arm9tdmi: C = ("arm9tdmi"); break;\
- case arm920: C = ("arm920"); break;\
- case arm920t: C = ("arm920t"); break;\
- case arm922t: C = ("arm922t"); break;\
- case arm940t: C = ("arm940t"); break;\
- case ep9312: C = ("ep9312"); break;\
- case arm10tdmi: C = ("arm10tdmi"); break;\
- case arm1020t: C = ("arm1020t"); break;\
- case arm9e: C = ("arm9e"); break;\
- case arm946es: C = ("arm946e-s"); break;\
- case arm966es: C = ("arm966e-s"); break;\
- case arm968es: C = ("arm968e-s"); break;\
- case arm10e: C = ("arm10e"); break;\
- case arm1020e: C = ("arm1020e"); break;\
- case arm1022e: C = ("arm1022e"); break;\
- case xscale: C = ("xscale"); break;\
- case iwmmxt: C = ("iwmmxt"); break;\
- case arm926ejs: C = ("arm926ej-s"); break;\
- case arm1026ejs: C = ("arm1026ej-s"); break;\
- case arm1136js: C = ("arm1136j-s"); break;\
- case arm1136jfs: C = ("arm1136jf-s"); break;\
- case arm1176jzs: C = ("arm1176jz-s"); break;\
- case arm1176jzfs: C = ("arm1176jzf-s"); break;\
- case mpcorenovfp: C = ("mpcorenovfp"); break;\
- case mpcore: C = ("mpcore"); break;\
- case arm1156t2s: C = ("arm1156t2-s"); break; \
- case arm1156t2fs: C = ("arm1156t2f-s"); break; \
- case cortexa8: C = ("cortex-a8"); break; \
- case cortexa9: C = ("cortex-a9"); break; \
- case cortexr4: C = ("cortex-r4"); break; \
- case cortexm3: C = ("cortex-m3"); break; \
- case cortexm4: C = ("cortex-m4"); break; \
- case cortexm0: C = ("cortex-m0"); break; \
- default: \
- C = ("arm7tdmi"); \
- break; \
- } \
- F.AddFeature("vfp3", TARGET_VFP3); \
- if (!TARGET_VFP3) \
- F.AddFeature("vfp2", TARGET_VFP && TARGET_HARD_FLOAT); \
- F.AddFeature("neon", TARGET_NEON); \
- F.AddFeature("fp16", TARGET_FP16); \
+#define LLVM_SET_SUBTARGET_FEATURES(C, F) \
+ { \
+ switch (arm_tune) { \
+ case arm8: \
+ C = ("arm8"); \
+ break; \
+ case arm810: \
+ C = ("arm810"); \
+ break; \
+ case strongarm: \
+ C = ("strongarm"); \
+ break; \
+ case strongarm110: \
+ C = ("strongarm110"); \
+ break; \
+ case strongarm1100: \
+ C = ("strongarm1100"); \
+ break; \
+ case strongarm1110: \
+ C = ("strongarm1110"); \
+ break; \
+ case arm7tdmi: \
+ C = ("arm7tdmi"); \
+ break; \
+ case arm7tdmis: \
+ C = ("arm7tdmi-s"); \
+ break; \
+ case arm710t: \
+ C = ("arm710t"); \
+ break; \
+ case arm720t: \
+ C = ("arm720t"); \
+ break; \
+ case arm740t: \
+ C = ("arm740t"); \
+ break; \
+ case arm9: \
+ C = ("arm9"); \
+ break; \
+ case arm9tdmi: \
+ C = ("arm9tdmi"); \
+ break; \
+ case arm920: \
+ C = ("arm920"); \
+ break; \
+ case arm920t: \
+ C = ("arm920t"); \
+ break; \
+ case arm922t: \
+ C = ("arm922t"); \
+ break; \
+ case arm940t: \
+ C = ("arm940t"); \
+ break; \
+ case ep9312: \
+ C = ("ep9312"); \
+ break; \
+ case arm10tdmi: \
+ C = ("arm10tdmi"); \
+ break; \
+ case arm1020t: \
+ C = ("arm1020t"); \
+ break; \
+ case arm9e: \
+ C = ("arm9e"); \
+ break; \
+ case arm946es: \
+ C = ("arm946e-s"); \
+ break; \
+ case arm966es: \
+ C = ("arm966e-s"); \
+ break; \
+ case arm968es: \
+ C = ("arm968e-s"); \
+ break; \
+ case arm10e: \
+ C = ("arm10e"); \
+ break; \
+ case arm1020e: \
+ C = ("arm1020e"); \
+ break; \
+ case arm1022e: \
+ C = ("arm1022e"); \
+ break; \
+ case xscale: \
+ C = ("xscale"); \
+ break; \
+ case iwmmxt: \
+ C = ("iwmmxt"); \
+ break; \
+ case arm926ejs: \
+ C = ("arm926ej-s"); \
+ break; \
+ case arm1026ejs: \
+ C = ("arm1026ej-s"); \
+ break; \
+ case arm1136js: \
+ C = ("arm1136j-s"); \
+ break; \
+ case arm1136jfs: \
+ C = ("arm1136jf-s"); \
+ break; \
+ case arm1176jzs: \
+ C = ("arm1176jz-s"); \
+ break; \
+ case arm1176jzfs: \
+ C = ("arm1176jzf-s"); \
+ break; \
+ case mpcorenovfp: \
+ C = ("mpcorenovfp"); \
+ break; \
+ case mpcore: \
+ C = ("mpcore"); \
+ break; \
+ case arm1156t2s: \
+ C = ("arm1156t2-s"); \
+ break; \
+ case arm1156t2fs: \
+ C = ("arm1156t2f-s"); \
+ break; \
+ case cortexa8: \
+ C = ("cortex-a8"); \
+ break; \
+ case cortexa9: \
+ C = ("cortex-a9"); \
+ break; \
+ case cortexr4: \
+ C = ("cortex-r4"); \
+ break; \
+ case cortexm3: \
+ C = ("cortex-m3"); \
+ break; \
+ case cortexm4: \
+ C = ("cortex-m4"); \
+ break; \
+ case cortexm0: \
+ C = ("cortex-m0"); \
+ break; \
+ default: \
+ C = ("arm7tdmi"); \
+ break; \
+ } \
+ F.AddFeature("vfp3", TARGET_VFP3); \
+ if (!TARGET_VFP3) \
+ F.AddFeature("vfp2", TARGET_VFP && TARGET_HARD_FLOAT); \
+ F.AddFeature("neon", TARGET_NEON); \
+ F.AddFeature("fp16", TARGET_FP16); \
}
/* Encode arm / thumb modes and arm subversion number in the triplet. e.g.
* armv6-apple-darwin, thumbv5-apple-darwin. FIXME: Replace thumb triplets
* 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" : ""))))))))
+#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" : ""))))))))
#if 0
// Dragonegg should make flag_mkernel and flag_apple_kext option later on.
// We didn't decide place to make these flags.
-#define LLVM_SET_MACHINE_OPTIONS(argvec) \
- if (flag_mkernel || flag_apple_kext) { \
- argvec.push_back("-arm-long-calls"); \
- argvec.push_back("-arm-strict-align"); \
+#define LLVM_SET_MACHINE_OPTIONS(argvec) \
+ if (flag_mkernel || flag_apple_kext) { \
+ argvec.push_back("-arm-long-calls"); \
+ argvec.push_back("-arm-strict-align"); \
}
#endif
-#define LLVM_SET_TARGET_MACHINE_OPTIONS(options) \
- do { \
- options.UseSoftFloat = TARGET_SOFT_FLOAT; \
- if (TARGET_HARD_FLOAT_ABI) \
- options.FloatABIType = llvm::FloatABI::Hard; \
+#define LLVM_SET_TARGET_MACHINE_OPTIONS(options) \
+ do { \
+ options.UseSoftFloat = TARGET_SOFT_FLOAT; \
+ if (TARGET_HARD_FLOAT_ABI) \
+ options.FloatABIType = llvm::FloatABI::Hard; \
} while (0)
-
/* These are a couple of extensions to the asm formats
%@ prints out ASM_COMMENT_START
TODO: %r prints out REGISTER_PREFIX reg_names[arg] */
-#define LLVM_ASM_EXTENSIONS(ESCAPED_CHAR, ASM, RESULT) \
- else if ((ESCAPED_CHAR) == '@') { \
- (RESULT) += ASM_COMMENT_START; \
+#define LLVM_ASM_EXTENSIONS(ESCAPED_CHAR, ASM, RESULT) \
+ else if ((ESCAPED_CHAR) == '@') { \
+ (RESULT) += ASM_COMMENT_START; \
}
/* LLVM_TARGET_INTRINSIC_LOWER - To handle builtins, we want to expand the
@@ -243,9 +310,9 @@
return true. This macro is invoked from a method in the TreeToLLVM class. */
#if 0
// Because of data dependency, we will implement later on.
-#define LLVM_TARGET_INTRINSIC_LOWER(EXP, BUILTIN_CODE, DESTLOC, RESULT, \
- DESTTY, OPS) \
- TargetIntrinsicLower(EXP, BUILTIN_CODE, DESTLOC, RESULT, DESTTY, OPS);
+#define LLVM_TARGET_INTRINSIC_LOWER(EXP, BUILTIN_CODE, DESTLOC, RESULT, DESTTY,\
+ OPS) \
+ TargetIntrinsicLower(EXP, BUILTIN_CODE, DESTLOC, RESULT, DESTTY, OPS);
#endif
/* LLVM_GET_REG_NAME - The registers known to llvm as "r10", "r11", and "r12"
@@ -254,12 +321,10 @@
For VFP registers, GCC doesn't distinguish between the q and d registers
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])
+#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])
/* 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/darwin/dragonegg/OS.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/darwin/dragonegg/OS.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/darwin/dragonegg/OS.h (original)
+++ dragonegg/trunk/include/darwin/dragonegg/OS.h Wed Jan 23 03:38:51 2013
@@ -24,33 +24,33 @@
#define DRAGONEGG_OS_H
/* Darwin X86-64 only supports PIC code generation. */
-#if defined (TARGET_386)
-#define LLVM_SET_RELOC_MODEL(RelocModel) \
- if ((TARGET_64BIT) || flag_pic) \
- RelocModel = Reloc::PIC_; \
- else if (!MACHO_DYNAMIC_NO_PIC_P) \
+#if defined(TARGET_386)
+#define LLVM_SET_RELOC_MODEL(RelocModel) \
+ if ((TARGET_64BIT) || flag_pic) \
+ RelocModel = Reloc::PIC_; \
+ else if (!MACHO_DYNAMIC_NO_PIC_P) \
RelocModel = Reloc::Static;
-#elif defined (TARGET_ARM)
-#define LLVM_SET_RELOC_MODEL(RelocModel) \
- if (flag_pic) \
- RelocModel = Reloc::PIC_; \
- else if (!MACHO_DYNAMIC_NO_PIC_P) \
- RelocModel = Reloc::Static; \
-#else /* !TARGET_386 && !TARGET_ARM */
-#define LLVM_SET_RELOC_MODEL(RelocModel) \
- if (flag_pic) \
- RelocModel = Reloc::PIC_; \
- else if (!MACHO_DYNAMIC_NO_PIC_P) \
+#elif defined(TARGET_ARM)
+#define LLVM_SET_RELOC_MODEL(RelocModel) \
+ if (flag_pic) \
+ RelocModel = Reloc::PIC_; \
+ else if (!MACHO_DYNAMIC_NO_PIC_P) \
+ RelocModel = Reloc::Static; \
+ #else /* !TARGET_386 && !TARGET_ARM */
+#define LLVM_SET_RELOC_MODEL(RelocModel) \
+ if (flag_pic) \
+ RelocModel = Reloc::PIC_; \
+ else if (!MACHO_DYNAMIC_NO_PIC_P) \
RelocModel = Reloc::Static;
#endif /* !TARGET_386 && !TARGET_ARM */
/* Give a constant string a sufficient alignment for the platform. */
/* radar 7291825 */
-#define TARGET_ADJUST_CSTRING_ALIGN(GV) \
- do { \
- if (GV->hasInternalLinkage()) { \
- GV->setAlignment(TARGET_64BIT ? 8 : 4); \
- } \
+#define TARGET_ADJUST_CSTRING_ALIGN(GV) \
+ do { \
+ if (GV->hasInternalLinkage()) { \
+ GV->setAlignment(TARGET_64BIT ? 8 : 4); \
+ } \
} while (0)
#endif /* DRAGONEGG_OS_H */
Modified: dragonegg/trunk/include/dragonegg/ABI.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ABI.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/ABI.h (original)
+++ dragonegg/trunk/include/dragonegg/ABI.h Wed Jan 23 03:38:51 2013
@@ -34,9 +34,7 @@
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/LLVMContext.h"
-namespace llvm {
- class BasicBlock;
-}
+namespace llvm { class BasicBlock; }
/// DefaultABIClient - This is a simple implementation of the ABI client
/// interface that can be subclassed.
@@ -48,80 +46,80 @@
/// HandleScalarResult - This callback is invoked if the function returns a
/// simple scalar result value, which is of type RetTy.
- virtual void HandleScalarResult(Type * /*RetTy*/) {}
+ virtual void HandleScalarResult(Type */*RetTy*/) {}
/// HandleAggregateResultAsScalar - This callback is invoked if the function
/// returns an aggregate value by bit converting it to the specified scalar
/// type and returning that. The bit conversion should start at byte Offset
/// within the struct, and ScalarTy is not necessarily big enough to cover
/// the entire struct.
- virtual void HandleAggregateResultAsScalar(Type * /*ScalarTy*/,
- unsigned /*Offset*/ = 0) {}
+ virtual void HandleAggregateResultAsScalar(Type */*ScalarTy*/,
+ unsigned /*Offset*/ = 0) {
+ }
/// HandleAggregateResultAsAggregate - This callback is invoked if the function
/// returns an aggregate value using multiple return values.
- virtual void HandleAggregateResultAsAggregate(Type * /*AggrTy*/) {}
+ virtual void HandleAggregateResultAsAggregate(Type */*AggrTy*/) {}
/// HandleAggregateShadowResult - This callback is invoked if the function
/// returns an aggregate value by using a "shadow" first parameter, which is
/// a pointer to the aggregate, of type PtrArgTy. If RetPtr is set to true,
/// the pointer argument itself is returned from the function.
- virtual void HandleAggregateShadowResult(PointerType * /*PtrArgTy*/,
- bool /*RetPtr*/) {}
+ virtual void HandleAggregateShadowResult(PointerType */*PtrArgTy*/,
+ bool /*RetPtr*/) {
+ }
/// HandleScalarShadowResult - This callback is invoked if the function
/// returns a scalar value by using a "shadow" first parameter, which is a
/// pointer to the scalar, of type PtrArgTy. If RetPtr is set to true,
/// the pointer argument itself is returned from the function.
- virtual void HandleScalarShadowResult(PointerType * /*PtrArgTy*/,
- bool /*RetPtr*/) {}
-
+ virtual void HandleScalarShadowResult(PointerType */*PtrArgTy*/,
+ bool /*RetPtr*/) {
+ }
/// HandleScalarArgument - This is the primary callback that specifies an
/// LLVM argument to pass. It is only used for first class types.
/// If RealSize is non Zero then it specifies number of bytes to access
/// from LLVMTy.
- virtual void HandleScalarArgument(llvm::Type * /*LLVMTy*/,
- tree_node * /*type*/,
- unsigned /*RealSize*/ = 0) {}
+ virtual void HandleScalarArgument(llvm::Type */*LLVMTy*/, tree_node */*type*/,
+ unsigned /*RealSize*/ = 0) {
+ }
/// HandleByInvisibleReferenceArgument - This callback is invoked if a pointer
/// (of type PtrTy) to the argument is passed rather than the argument itself.
- virtual void HandleByInvisibleReferenceArgument(llvm::Type * /*PtrTy*/,
- tree_node * /*type*/) {}
+ virtual void HandleByInvisibleReferenceArgument(llvm::Type */*PtrTy*/,
+ tree_node */*type*/) {
+ }
/// HandleByValArgument - This callback is invoked if the aggregate function
/// argument is passed by value.
- virtual void HandleByValArgument(llvm::Type * /*LLVMTy*/,
- tree_node * /*type*/) {}
+ virtual void HandleByValArgument(llvm::Type */*LLVMTy*/,
+ tree_node */*type*/) {
+ }
/// HandleFCAArgument - This callback is invoked if the aggregate function
/// argument is passed by value as a first class aggregate.
- virtual void HandleFCAArgument(llvm::Type * /*LLVMTy*/,
- tree_node * /*type*/) {}
+ virtual void HandleFCAArgument(llvm::Type */*LLVMTy*/, tree_node */*type*/) {}
/// EnterField - Called when we're about the enter the field of a struct
/// or union. FieldNo is the number of the element we are entering in the
/// LLVM Struct, StructTy is the LLVM type of the struct we are entering.
- virtual void EnterField(unsigned /*FieldNo*/,
- llvm::Type * /*StructTy*/) {}
+ virtual void EnterField(unsigned /*FieldNo*/, llvm::Type */*StructTy*/) {}
virtual void ExitField() {}
- virtual void HandlePad(llvm::Type * /*LLVMTy*/) {}
+ virtual void HandlePad(llvm::Type */*LLVMTy*/) {}
};
// LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY - A hook to allow
// special _Complex handling. Return true if X should be returned using
// multiple value return instruction.
#ifndef LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY
-#define LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY(X) \
- false
+#define LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY(X) false
#endif
// LLVM_SHOULD_NOT_USE_SHADOW_RETURN - A hook to allow aggregates to be
// returned in registers.
#ifndef LLVM_SHOULD_NOT_USE_SHADOW_RETURN
-#define LLVM_SHOULD_NOT_USE_SHADOW_RETURN(X, CC) \
- false
+#define LLVM_SHOULD_NOT_USE_SHADOW_RETURN(X, CC) false
#endif
// doNotUseShadowReturn - Return true if the specified GCC type
@@ -135,9 +133,8 @@
/// struct (recursively) may include zero-length fields in addition to the
/// single element that has data. If rejectFatBitField, and the single element
/// is a bitfield of a type that's bigger than the struct, return null anyway.
-extern tree_node *isSingleElementStructOrArray(tree_node *type,
- bool ignoreZeroLength,
- bool rejectFatBitfield);
+extern tree_node *isSingleElementStructOrArray(
+ tree_node *type, bool ignoreZeroLength, bool rejectFatBitfield);
/// isZeroSizedStructOrUnion - Returns true if this is a struct or union
/// which is zero bits wide.
@@ -146,8 +143,8 @@
// 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;
@@ -172,44 +169,38 @@
// getLLVMAggregateTypeForStructReturn - Return LLVM type if TY can be
// returns as multiple values, otherwise return NULL. This is the default
// target independent implementation.
-inline
-Type* getLLVMAggregateTypeForStructReturn(tree_node * /*type*/) {
+inline Type *getLLVMAggregateTypeForStructReturn(tree_node */*type*/) {
return NULL;
}
#ifndef LLVM_TRY_PASS_AGGREGATE_CUSTOM
-#define LLVM_TRY_PASS_AGGREGATE_CUSTOM(T, E, CC, C) \
- false
+#define LLVM_TRY_PASS_AGGREGATE_CUSTOM(T, E, CC, C) false
#endif
// LLVM_SHOULD_PASS_VECTOR_IN_INTEGER_REGS - Return true if this vector
// type should be passed as integer registers. Generally vectors which are
// not part of the target architecture should do this.
#ifndef LLVM_SHOULD_PASS_VECTOR_IN_INTEGER_REGS
-#define LLVM_SHOULD_PASS_VECTOR_IN_INTEGER_REGS(TY) \
- false
+#define LLVM_SHOULD_PASS_VECTOR_IN_INTEGER_REGS(TY) false
#endif
// LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR - Return true if this vector
// type should be passed byval. Used for generic vectors on x86-64.
#ifndef LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR
-#define LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR(X) \
- false
+#define LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR(X) false
#endif
// LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR - Return true if this aggregate
// value should be passed by value, i.e. passing its address with the byval
// attribute bit set. The default is false.
#ifndef LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR
-#define LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(X, TY) \
- false
+#define LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(X, TY) false
#endif
// LLVM_SHOULD_PASS_AGGREGATE_AS_FCA - Return true if this aggregate value
// should be passed by value as a first class aggregate. The default is false.
#ifndef LLVM_SHOULD_PASS_AGGREGATE_AS_FCA
-#define LLVM_SHOULD_PASS_AGGREGATE_AS_FCA(X, TY) \
- false
+#define LLVM_SHOULD_PASS_AGGREGATE_AS_FCA(X, TY) false
#endif
// LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS - Return true if this aggregate
@@ -217,8 +208,7 @@
// registers. The routine should also return by reference a vector of the
// types of the registers being used. The default is false.
#ifndef LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS
-#define LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS(T, TY, CC, E) \
- false
+#define LLVM_SHOULD_PASS_AGGREGATE_IN_MIXED_REGS(T, TY, CC, E) false
#endif
// LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS - Only called if
@@ -227,8 +217,7 @@
// the aggregate. Note, this routine should return false if none of the needed
// registers are available.
#ifndef LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS
-#define LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(E, SE, ISR, CC) \
- false
+#define LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(E, SE, ISR, CC) false
#endif
// LLVM_BYVAL_ALIGNMENT - Returns the alignment of the type in bytes, if known,
@@ -237,7 +226,7 @@
// when the type is used within a struct, which may or may not be appropriate
// here.
#ifndef LLVM_BYVAL_ALIGNMENT
-#define LLVM_BYVAL_ALIGNMENT(T) 0
+#define LLVM_BYVAL_ALIGNMENT(T) 0
#endif
// LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS - Return true if this aggregate
@@ -248,8 +237,8 @@
// single element is a bitfield of a type bigger than the struct; the code
// for field-by-field struct passing does not handle this one right.
#ifndef LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS
-#define LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS(X, Y, Z) \
- !isSingleElementStructOrArray((X), false, true)
+#define LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS(X, Y, Z) \
+ !isSingleElementStructOrArray((X), false, true)
#endif
// LLVM_SHOULD_RETURN_SELT_STRUCT_AS_SCALAR - Return a TYPE tree if this single
@@ -259,7 +248,7 @@
// checked elsewhere. (Structs where this is not the case can be constructed
// by abusing the __aligned__ attribute.)
#ifndef LLVM_SHOULD_RETURN_SELT_STRUCT_AS_SCALAR
-#define LLVM_SHOULD_RETURN_SELT_STRUCT_AS_SCALAR(X) \
+#define LLVM_SHOULD_RETURN_SELT_STRUCT_AS_SCALAR(X) \
isSingleElementStructOrArray(X, false, false)
#endif
@@ -267,27 +256,27 @@
// should be returned using the convention for that scalar TYPE, 0 otherwise.
// X may be evaluated more than once.
#ifndef LLVM_SHOULD_RETURN_VECTOR_AS_SCALAR
-#define LLVM_SHOULD_RETURN_VECTOR_AS_SCALAR(X,Y) 0
+#define LLVM_SHOULD_RETURN_VECTOR_AS_SCALAR(X, Y) 0
#endif
// LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW - Return true if this vector type
// should be returned using the aggregate shadow (sret) convention, 0 otherwise.
// X may be evaluated more than once.
#ifndef LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW
-#define LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW(X,Y) 0
+#define LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW(X, Y) 0
#endif
// LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN - Return LLVM Type if X can be
// returned as a scalar, otherwise return NULL.
#ifndef LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN
-#define LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN(X, Y) \
+#define LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN(X, Y) \
getLLVMScalarTypeForStructReturn((X), (Y))
#endif
// LLVM_AGGR_TYPE_FOR_STRUCT_RETURN - Return LLVM Type if X can be
// returned as an aggregate, otherwise return NULL.
#ifndef LLVM_AGGR_TYPE_FOR_STRUCT_RETURN
-#define LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(X, CC) \
+#define LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(X, CC) \
getLLVMAggregateTypeForStructReturn(X)
#endif
@@ -295,13 +284,12 @@
// SRC and assign it to DEST. Each target that supports multiple return
// value must implement this hook.
#ifndef LLVM_EXTRACT_MULTIPLE_RETURN_VALUE
-#define LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Src,Dest,V,B) \
- llvm_default_extract_multiple_return_value((Src),(Dest),(V),(B))
+#define LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Src, Dest, V, B) \
+ llvm_default_extract_multiple_return_value((Src), (Dest), (V), (B))
#endif
-inline
-void llvm_default_extract_multiple_return_value(Value * /*Src*/, Value * /*Dest*/,
- bool /*isVolatile*/,
- LLVMBuilder &/*Builder*/) {
+inline void llvm_default_extract_multiple_return_value(
+ Value */*Src*/, Value */*Dest*/, bool /*isVolatile*/,
+ LLVMBuilder &/*Builder*/) {
llvm_unreachable("LLVM_EXTRACT_MULTIPLE_RETURN_VALUE is not implemented!");
}
@@ -328,25 +316,24 @@
/// argument and invokes methods on the client that indicate how its pieces
/// should be handled. This handles things like decimating structures into
/// their fields.
- void HandleArgument(tree_node *type, std::vector<Type*> &ScalarElts,
+ void HandleArgument(tree_node *type, std::vector<Type *> &ScalarElts,
AttrBuilder *AttrBuilder = NULL);
/// HandleUnion - Handle a UNION_TYPE or QUAL_UNION_TYPE tree.
///
- void HandleUnion(tree_node *type, std::vector<Type*> &ScalarElts);
+ void HandleUnion(tree_node *type, std::vector<Type *> &ScalarElts);
/// PassInIntegerRegisters - Given an aggregate value that should be passed in
/// integer registers, convert it to a structure containing ints and pass all
/// of the struct elements in. If Size is set we pass only that many bytes.
- void PassInIntegerRegisters(tree_node *type,
- std::vector<Type*> &ScalarElts,
+ void PassInIntegerRegisters(tree_node *type, std::vector<Type *> &ScalarElts,
unsigned origSize, bool DontCheckAlignment);
/// PassInMixedRegisters - Given an aggregate value that should be passed in
/// mixed integer, floating point, and vector registers, convert it to a
/// structure containing the specified struct elements in.
- void PassInMixedRegisters(Type *Ty, std::vector<Type*> &OrigElts,
- std::vector<Type*> &ScalarElts);
+ void PassInMixedRegisters(Type *Ty, std::vector<Type *> &OrigElts,
+ std::vector<Type *> &ScalarElts);
};
#endif /* DRAGONEGG_ABI_H */
Modified: dragonegg/trunk/include/dragonegg/ADT/IntervalList.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ADT/IntervalList.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/ADT/IntervalList.h (original)
+++ dragonegg/trunk/include/dragonegg/ADT/IntervalList.h Wed Jan 23 03:38:51 2013
@@ -36,8 +36,7 @@
/// and otherwise changing the shape of the interval; and JoinWith for replacing
/// the interval with the convex hull of its union with another interval (which
/// is guaranteed to be disjoint from the original).
-template <class T, typename U, unsigned N>
-class IntervalList {
+template <class T, typename U, unsigned N> class IntervalList {
typedef typename llvm::SmallVector<T, N> List;
typedef typename List::iterator iterator;
@@ -57,13 +56,13 @@
/// isSane - Return true if the intervals are non-empty, disjoint and
/// sorted.
bool isSane() const {
- if (Intervals.size() != (unsigned)Intervals.size())
+ if (Intervals.size() != (unsigned) Intervals.size())
return false; // Too many intervals.
- for (unsigned i = 0, e = (unsigned)Intervals.size(); i < e; ++i) {
+ 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())
+ Intervals[i - 1].getRange().getLast())
return false;
}
return true;
@@ -78,14 +77,10 @@
void AddInterval(const T &S);
/// getNumIntervals - Return the number of intervals in the list.
- unsigned getNumIntervals() const {
- return (unsigned)Intervals.size();
- }
+ unsigned getNumIntervals() const { return (unsigned) Intervals.size(); }
/// getInterval - Return the interval with the given index.
- T getInterval(unsigned Idx) {
- return Intervals[Idx];
- }
+ T getInterval(unsigned Idx) { return Intervals[Idx]; }
/// AlignBoundaries - Ensure that all intervals begin and end on a multiple of
/// the given value.
Modified: dragonegg/trunk/include/dragonegg/ADT/Range.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ADT/Range.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/ADT/Range.h (original)
+++ dragonegg/trunk/include/dragonegg/ADT/Range.h Wed Jan 23 03:38:51 2013
@@ -26,8 +26,7 @@
#include <cassert>
/// Range - Represents the interval [First, Last).
-template<typename T>
-class Range {
+template <typename T> class Range {
T First, Last;
public:
Range() : First(0), Last(0) {}
@@ -35,13 +34,11 @@
bool operator==(const Range &other) const {
return (empty() && other.empty()) ||
- (First == other.First && Last == other.Last);
+ (First == other.First && Last == other.Last);
}
/// empty - Return whether the range is empty.
- bool empty() const {
- return Last <= First;
- }
+ bool empty() const { return Last <= First; }
/// getFirst - Return the value defining the start of the range.
T getFirst() const {
@@ -56,9 +53,7 @@
}
/// getWidth - Return the number of values in the range.
- T getWidth() const {
- return empty() ? 0 : Last - First;
- }
+ T getWidth() const { return empty() ? 0 : Last - First; }
/// contains - Return true if the given range is contained in this one.
bool contains(Range r) const {
Modified: dragonegg/trunk/include/dragonegg/Aliasing.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Aliasing.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/Aliasing.h (original)
+++ dragonegg/trunk/include/dragonegg/Aliasing.h Wed Jan 23 03:38:51 2013
@@ -25,9 +25,7 @@
#define DRAGONEGG_ALIASING_H
// Forward declarations.
-namespace llvm {
- class MDNode;
-}
+namespace llvm { class MDNode; }
union tree_node;
/// describeAliasSet - Return TBAA metadata describing what a load from or store
Modified: dragonegg/trunk/include/dragonegg/Cache.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Cache.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/Cache.h (original)
+++ dragonegg/trunk/include/dragonegg/Cache.h Wed Jan 23 03:38:51 2013
@@ -28,8 +28,8 @@
// Forward declarations.
namespace llvm {
- class Type;
- class Value;
+class Type;
+class Value;
}
union tree_node;
Modified: dragonegg/trunk/include/dragonegg/ConstantConversion.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/ConstantConversion.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/ConstantConversion.h (original)
+++ dragonegg/trunk/include/dragonegg/ConstantConversion.h Wed Jan 23 03:38:51 2013
@@ -26,8 +26,8 @@
// Forward declarations.
namespace llvm {
- class Constant;
- class Type;
+class Constant;
+class Type;
}
union tree_node;
@@ -55,8 +55,7 @@
/// 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.
-extern llvm::Constant *ExtractRegisterFromConstant(llvm::Constant *C,
- tree_node *type,
- int StartingByte = 0);
+extern llvm::Constant *ExtractRegisterFromConstant(
+ llvm::Constant *C, tree_node *type, int StartingByte = 0);
#endif /* DRAGONEGG_CONSTANTS_H */
Modified: dragonegg/trunk/include/dragonegg/Debug.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Debug.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/Debug.h (original)
+++ dragonegg/trunk/include/dragonegg/Debug.h Wed Jan 23 03:38:51 2013
@@ -36,26 +36,29 @@
// Forward declarations
namespace llvm {
- class AllocaInst;
- class BasicBlock;
- class CallInst;
- class Function;
- class Module;
+class AllocaInst;
+class BasicBlock;
+class CallInst;
+class Function;
+class Module;
}
/// DIFactory - This object assists with the construction of the various
/// descriptors.
class DIFactory {
Module &M;
- LLVMContext& VMContext;
+ LLVMContext &VMContext;
- Function *DeclareFn; // llvm.dbg.declare
- Function *ValueFn; // llvm.dbg.value
+ Function *DeclareFn; // llvm.dbg.declare
+ Function *ValueFn; // llvm.dbg.value
- DIFactory(const DIFactory &) LLVM_DELETED_FUNCTION;
- void operator=(const DIFactory&) LLVM_DELETED_FUNCTION;
- public:
- enum ComplexAddrKind { OpPlus=1, OpDeref };
+ DIFactory(const DIFactory &)LLVM_DELETED_FUNCTION;
+ void operator=(const DIFactory &)LLVM_DELETED_FUNCTION;
+public:
+ enum ComplexAddrKind {
+ OpPlus = 1,
+ OpDeref
+ };
explicit DIFactory(Module &m);
@@ -73,69 +76,49 @@
/// CreateCompileUnit - Create a new descriptor for the specified compile
/// unit.
- DICompileUnit CreateCompileUnit(unsigned LangID,
- StringRef Filename,
- StringRef Directory,
- StringRef Producer,
- bool isMain = false,
- bool isOptimized = false,
- StringRef Flags = "",
- unsigned RunTimeVer = 0);
+ DICompileUnit 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,
- DICompileUnit CU);
+ DIFile CreateFile(StringRef Filename, StringRef Directory, DICompileUnit CU);
/// CreateEnumerator - Create a single enumerator value.
DIEnumerator CreateEnumerator(StringRef Name, uint64_t Val);
/// CreateBasicType - Create a basic type like int, float, etc.
- DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name,
- DIFile F, unsigned LineNumber,
- uint64_t SizeInBits, uint64_t AlignInBits,
- uint64_t OffsetInBits, unsigned Flags,
- unsigned Encoding);
+ DIBasicType CreateBasicType(DIDescriptor Context, StringRef Name, DIFile F,
+ unsigned LineNumber, uint64_t SizeInBits,
+ uint64_t AlignInBits, uint64_t OffsetInBits,
+ unsigned Flags, unsigned Encoding);
/// CreateBasicType - Create a basic type like int, float, etc.
- DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name,
- DIFile F, unsigned LineNumber,
- Constant *SizeInBits, Constant *AlignInBits,
- Constant *OffsetInBits, unsigned Flags,
- unsigned Encoding);
+ DIBasicType CreateBasicTypeEx(DIDescriptor Context, StringRef Name, DIFile F,
+ unsigned LineNumber, Constant *SizeInBits,
+ Constant *AlignInBits, Constant *OffsetInBits,
+ unsigned Flags, unsigned Encoding);
/// CreateDerivedType - Create a derived type like const qualified type,
/// pointer, typedef, etc.
- DIDerivedType CreateDerivedType(unsigned Tag, DIDescriptor Context,
- StringRef Name,
- DIFile F,
- unsigned LineNumber,
- uint64_t SizeInBits, uint64_t AlignInBits,
- uint64_t OffsetInBits, unsigned Flags,
- DIType DerivedFrom);
+ DIDerivedType CreateDerivedType(
+ unsigned Tag, DIDescriptor Context, StringRef Name, DIFile F,
+ unsigned LineNumber, uint64_t SizeInBits, uint64_t AlignInBits,
+ uint64_t OffsetInBits, unsigned Flags, DIType DerivedFrom);
/// CreateDerivedType - Create a derived type like const qualified type,
/// pointer, typedef, etc.
- DIDerivedType CreateDerivedTypeEx(unsigned Tag, DIDescriptor Context,
- StringRef Name,
- DIFile F,
- unsigned LineNumber,
- Constant *SizeInBits,
- Constant *AlignInBits,
- Constant *OffsetInBits, unsigned Flags,
- DIType DerivedFrom);
+ DIDerivedType CreateDerivedTypeEx(
+ unsigned Tag, DIDescriptor Context, StringRef Name, DIFile F,
+ unsigned LineNumber, Constant *SizeInBits, Constant *AlignInBits,
+ Constant *OffsetInBits, unsigned Flags, DIType DerivedFrom);
/// CreateCompositeType - Create a composite type like array, struct, etc.
- DICompositeType CreateCompositeType(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);
+ DICompositeType CreateCompositeType(
+ 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);
/// CreateTemporaryType - Create a temporary forward-declared type.
DIType CreateTemporaryType();
@@ -145,69 +128,47 @@
DIType CreateArtificialType(DIType Ty);
/// CreateCompositeType - Create a composite type like array, struct, etc.
- DICompositeType CreateCompositeTypeEx(unsigned Tag, DIDescriptor Context,
- StringRef Name,
- DIFile F,
- unsigned LineNumber,
- Constant *SizeInBits,
- Constant *AlignInBits,
- Constant *OffsetInBits,
- unsigned Flags,
- DIType DerivedFrom,
- DIArray Elements,
- unsigned RunTimeLang = 0,
- MDNode *ContainingType = 0);
+ DICompositeType CreateCompositeTypeEx(
+ unsigned Tag, DIDescriptor Context, StringRef Name, DIFile F,
+ unsigned LineNumber, Constant *SizeInBits, Constant *AlignInBits,
+ Constant *OffsetInBits, unsigned Flags, DIType DerivedFrom,
+ DIArray Elements, unsigned RunTimeLang = 0, MDNode * ContainingType = 0);
/// CreateSubprogram - Create a new descriptor for the specified subprogram.
/// See comments in DISubprogram for descriptions of these fields.
- DISubprogram CreateSubprogram(DIDescriptor Context, StringRef Name,
- StringRef DisplayName,
- 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);
+ DISubprogram CreateSubprogram(
+ DIDescriptor Context, StringRef Name, StringRef DisplayName,
+ 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);
/// CreateSubprogramDefinition - Create new subprogram descriptor for the
/// given declaration.
DISubprogram CreateSubprogramDefinition(DISubprogram &SPDeclaration);
/// CreateGlobalVariable - Create a new descriptor for the specified global.
- DIGlobalVariable
- CreateGlobalVariable(DIDescriptor Context, StringRef Name,
- StringRef DisplayName,
- StringRef LinkageName,
- DIFile F,
- unsigned LineNo, DIType Ty, bool isLocalToUnit,
- bool isDefinition, llvm::GlobalVariable *GV);
+ DIGlobalVariable CreateGlobalVariable(
+ DIDescriptor Context, StringRef Name, StringRef DisplayName,
+ StringRef LinkageName, DIFile F, unsigned LineNo, DIType Ty,
+ bool isLocalToUnit, bool isDefinition, llvm::GlobalVariable *GV);
/// CreateGlobalVariable - Create a new descriptor for the specified constant.
- DIGlobalVariable
- CreateGlobalVariable(DIDescriptor Context, StringRef Name,
- StringRef DisplayName,
- StringRef LinkageName,
- DIFile F,
- unsigned LineNo, DIType Ty, bool isLocalToUnit,
- bool isDefinition, llvm::Constant *C);
+ DIGlobalVariable CreateGlobalVariable(
+ DIDescriptor Context, StringRef Name, StringRef DisplayName,
+ StringRef LinkageName, DIFile F, unsigned LineNo, DIType Ty,
+ bool isLocalToUnit, bool isDefinition, llvm::Constant *C);
/// CreateVariable - Create a new descriptor for the specified variable.
- DIVariable CreateVariable(unsigned Tag, DIDescriptor Context,
- StringRef Name,
- DIFile F, unsigned LineNo,
- DIType Ty, bool AlwaysPreserve = false,
- unsigned Flags = 0);
+ DIVariable CreateVariable(unsigned Tag, DIDescriptor Context, StringRef Name,
+ DIFile F, unsigned LineNo, DIType Ty,
+ bool AlwaysPreserve = false, unsigned Flags = 0);
/// CreateComplexVariable - Create a new descriptor for the specified
/// variable which has a complex address expression for its address.
- DIVariable CreateComplexVariable(unsigned Tag, DIDescriptor Context,
- StringRef Name, DIFile F, unsigned LineNo,
- DIType Ty, Value *const *Addr,
- unsigned NumAddr);
+ DIVariable CreateComplexVariable(
+ unsigned Tag, DIDescriptor Context, StringRef Name, DIFile F,
+ unsigned LineNo, DIType Ty, Value *const *Addr, unsigned NumAddr);
/// CreateLexicalBlock - This creates a descriptor for a lexical block
/// with the specified parent context.
@@ -216,16 +177,16 @@
/// CreateNameSpace - This creates new descriptor for a namespace
/// with the specified parent context.
- DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name,
- DIFile F, unsigned LineNo);
+ DINameSpace CreateNameSpace(DIDescriptor Context, StringRef Name, DIFile F,
+ unsigned LineNo);
/// CreateLocation - Creates a debug info location.
- DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
- DIScope S, DILocation OrigLoc);
+ DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo, DIScope S,
+ DILocation OrigLoc);
/// CreateLocation - Creates a debug info location.
- DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo,
- DIScope S, MDNode *OrigLoc = 0);
+ DILocation CreateLocation(unsigned LineNo, unsigned ColumnNo, DIScope S,
+ MDNode *OrigLoc = 0);
/// InsertDeclare - Insert a new llvm.dbg.declare intrinsic call.
Instruction *InsertDeclare(llvm::Value *Storage, DIVariable D,
@@ -247,7 +208,7 @@
// it is not referenced through debug info anchors.
void RecordType(DIType T);
- private:
+private:
Constant *GetTagConstant(unsigned TAG);
};
@@ -256,28 +217,28 @@
class DebugInfo {
private:
SmallVector<WeakVH, 4> RegionStack;
- // Stack to track declarative scopes.
+ // Stack to track declarative scopes.
std::map<tree_node *, WeakVH> RegionMap;
DIFactory DebugFactory;
- const char *CurFullPath; // Previous location file encountered.
- const char *PrevFullPath; // Previous location file encountered.
- int CurLineNo; // Previous location line# encountered.
- int PrevLineNo; // Previous location line# encountered.
- BasicBlock *PrevBB; // Last basic block encountered.
-
- DICompileUnit TheCU; // The compile unit.
-
- std::map<tree_node *, WeakVH > TypeCache;
- // Cache of previously constructed
- // Types.
- std::map<tree_node *, WeakVH > SPCache;
- // Cache of previously constructed
- // Subprograms.
+ const char *CurFullPath; // Previous location file encountered.
+ const char *PrevFullPath; // Previous location file encountered.
+ int CurLineNo; // Previous location line# encountered.
+ int PrevLineNo; // Previous location line# encountered.
+ BasicBlock *PrevBB; // Last basic block encountered.
+
+ DICompileUnit TheCU; // The compile unit.
+
+ std::map<tree_node *, WeakVH> TypeCache;
+ // Cache of previously constructed
+ // Types.
+ std::map<tree_node *, WeakVH> SPCache;
+ // Cache of previously constructed
+ // Subprograms.
std::map<tree_node *, WeakVH> NameSpaceCache;
- // Cache of previously constructed name
- // spaces.
+ // Cache of previously constructed name
+ // spaces.
/// FunctionNames - This is a storage for function names that are
/// constructed on demand. For example, C++ destructors, C++ operators etc..
@@ -293,7 +254,7 @@
// Accessors.
void setLocationFile(const char *FullPath) { CurFullPath = FullPath; }
- void setLocationLine(int LineNo) { CurLineNo = LineNo; }
+ void setLocationLine(int LineNo) { CurLineNo = LineNo; }
/// EmitFunctionStart - Constructs the debug code for entering a function -
/// "llvm.dbg.func.start."
Modified: dragonegg/trunk/include/dragonegg/Internals.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Internals.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/Internals.h (original)
+++ dragonegg/trunk/include/dragonegg/Internals.h Wed Jan 23 03:38:51 2013
@@ -38,22 +38,22 @@
union tree_node;
namespace llvm {
- class Module;
- class GlobalVariable;
- class Function;
- class GlobalValue;
- class BasicBlock;
- class Instruction;
- class AllocaInst;
- class BranchInst;
- class Value;
- class Constant;
- class ConstantInt;
- class Type;
- class TargetMachine;
- class DataLayout;
- template<typename> class AssertingVH;
- template<typename> class TrackingVH;
+class Module;
+class GlobalVariable;
+class Function;
+class GlobalValue;
+class BasicBlock;
+class Instruction;
+class AllocaInst;
+class BranchInst;
+class Value;
+class Constant;
+class ConstantInt;
+class Type;
+class TargetMachine;
+class DataLayout;
+template <typename> class AssertingVH;
+template <typename> class TrackingVH;
}
class DebugInfo;
using namespace llvm;
@@ -96,9 +96,9 @@
extern bool flag_functions_from_args;
/// AttributeUsedGlobals - The list of globals that are marked attribute(used).
-extern SmallSetVector<Constant *,32> AttributeUsedGlobals;
+extern SmallSetVector<Constant *, 32> AttributeUsedGlobals;
-extern Constant* ConvertMetadataStringToGV(const char *str);
+extern Constant *ConvertMetadataStringToGV(const char *str);
/// AddAnnotateAttrsToGlobal - Adds decls that have a
/// annotate attribute to a vector to be emitted later.
@@ -140,14 +140,14 @@
/// Return true if and only if field no. N from struct type T is a padding
/// element added to match llvm struct type size and gcc struct type size.
-bool isPaddingElement(tree_node*, unsigned N);
+bool isPaddingElement(tree_node *, unsigned N);
/// getDefaultValue - Return the default value to use for a constant or global
/// 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
@@ -174,14 +174,12 @@
setAlignment(A);
}
- uint32_t getAlignment() const {
- return 1U << LogAlign;
- }
+ uint32_t getAlignment() const { return 1U << LogAlign; }
void setAlignment(uint32_t A) {
// Forbid alignment 0 along with non-power-of-2 alignment values.
assert(isPowerOf2_32(A) && "Alignment not a power of 2!");
- LogAlign = (unsigned char)Log2_32(A);
+ LogAlign = (unsigned char) Log2_32(A);
}
};
@@ -199,13 +197,13 @@
public:
explicit LValue() : BitStart(255), BitSize(255) {}
explicit LValue(MemRef &M) : MemRef(M), BitStart(255), BitSize(255) {}
- LValue(Value *P, uint32_t A, bool V = false) :
- MemRef(P, A, V), BitStart(255), BitSize(255) {}
- LValue(Value *P, uint32_t A, unsigned BSt, unsigned BSi, bool V = false) :
- MemRef(P, A, V), BitStart((unsigned char)BSt),
- BitSize((unsigned char)BSi) {
- assert(BitStart == BSt && BitSize == BSi &&
- "Bit values larger than 256?");
+ LValue(Value *P, uint32_t A, bool V = false)
+ : MemRef(P, A, V), BitStart(255), BitSize(255) {
+ }
+ LValue(Value *P, uint32_t A, unsigned BSt, unsigned BSi, bool V = false)
+ : MemRef(P, A, V), BitStart((unsigned char) BSt),
+ BitSize((unsigned char) BSi) {
+ assert(BitStart == BSt && BitSize == BSi && "Bit values larger than 256?");
}
bool isBitfield() const { return BitStart != 255; }
@@ -243,7 +241,7 @@
Instruction *SSAInsertionPoint;
/// BasicBlocks - Map from GCC to LLVM basic blocks.
- DenseMap<basic_block_def *, BasicBlock*> BasicBlocks;
+ DenseMap<basic_block_def *, BasicBlock *> BasicBlocks;
/// LocalDecls - Map from local declarations to their associated LLVM values.
DenseMap<tree_node *, AssertingVH<Value> > LocalDecls;
@@ -262,28 +260,27 @@
/// function. However DECL_LOCAL can be used with declarations local to the
/// current function as well as with global declarations.
Value *make_decl_local(tree_node *);
- #define DECL_LOCAL(NODE) make_decl_local(NODE)
+#define DECL_LOCAL(NODE) make_decl_local(NODE)
/// DEFINITION_LOCAL - Like DEFINITION_LLVM, ensures that the initial value or
/// body of a variable or function will be output. However DEFINITION_LOCAL
/// can be used with declarations local to the current function as well as
/// with global declarations.
Value *make_definition_local(tree_node *);
- #define DEFINITION_LOCAL(NODE) make_definition_local(NODE)
+#define DEFINITION_LOCAL(NODE) make_definition_local(NODE)
/// SET_DECL_LOCAL - Set the DECL_LOCAL for NODE to LLVM.
Value *set_decl_local(tree_node *, Value *);
- #define SET_DECL_LOCAL(NODE, LLVM) set_decl_local(NODE, LLVM)
+#define SET_DECL_LOCAL(NODE, LLVM) set_decl_local(NODE, LLVM)
/// DECL_LOCAL_IF_SET - The DECL_LOCAL for NODE, if it is set, or NULL, if it
/// is not set.
Value *get_decl_local(tree_node *);
- #define DECL_LOCAL_IF_SET(NODE) (HAS_RTL_P(NODE) ? get_decl_local(NODE) : NULL)
-
- /// DECL_LOCAL_SET_P - Returns nonzero if the DECL_LOCAL for NODE has already
- /// been set.
- #define DECL_LOCAL_SET_P(NODE) (DECL_LOCAL_IF_SET(NODE) != NULL)
+#define DECL_LOCAL_IF_SET(NODE) (HAS_RTL_P(NODE) ? get_decl_local(NODE) : NULL)
+/// DECL_LOCAL_SET_P - Returns nonzero if the DECL_LOCAL for NODE has already
+/// been set.
+#define DECL_LOCAL_SET_P(NODE) (DECL_LOCAL_IF_SET(NODE) != NULL)
private:
@@ -326,10 +323,10 @@
/// 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.
@@ -363,7 +360,7 @@
/// CreateTemporary - Create a new alloca instruction of the specified type,
/// inserting it into the entry block and returning it. The resulting
/// instruction's type is a pointer to the specified type.
- AllocaInst *CreateTemporary(Type *Ty, unsigned align=0);
+ AllocaInst *CreateTemporary(Type *Ty, unsigned align = 0);
/// CreateTempLoc - Like CreateTemporary, but returns a MemRef.
MemRef CreateTempLoc(Type *Ty);
@@ -376,7 +373,7 @@
/// DestLoc.
void EmitAggregate(tree_node *exp, const MemRef &DestLoc);
-private: // Helper functions.
+private : // Helper functions.
/// StartFunctionBody - Start the emission of 'fndecl', outputing all
/// declarations for parameters and setting things up.
@@ -423,7 +420,8 @@
/// 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.
@@ -437,7 +435,7 @@
/// function.
bool EmitDebugInfo();
-private: // Helpers for exception handling.
+private : // Helpers for exception handling.
/// getExceptionPtr - Return the local holding the exception pointer for the
/// given exception handling region, creating it if necessary.
@@ -594,7 +592,8 @@
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.
@@ -602,7 +601,7 @@
void EmitModifyOfRegisterVariable(tree_node *vardecl, Value *RHS);
// Helpers for Builtin Function Expansion.
- Value *BuildVector(const std::vector<Value*> &Elts);
+ Value *BuildVector(const std::vector<Value *> &Elts);
Value *BuildVector(Value *Elt, ...);
Value *BuildVectorShuffle(Value *InVec1, Value *InVec2, ...);
Value *BuildBinaryAtomic(gimple_statement_d *stmt, AtomicRMWInst::BinOp Kind,
@@ -690,7 +689,6 @@
Value *EmitREAL_CST(tree_node *exp);
Value *EmitCONSTRUCTOR(tree_node *exp, const MemRef *DestLoc);
-
// Emit helpers.
/// EmitMinInvariant - The given value is constant in this function. Return
@@ -744,12 +742,9 @@
private:
// Optional target defined builtin intrinsic expanding function.
- bool TargetIntrinsicLower(gimple_statement_d *stmt,
- tree_node *fndecl,
- const MemRef *DestLoc,
- Value *&Result,
- Type *ResultType,
- std::vector<Value*> &Ops);
+ bool TargetIntrinsicLower(gimple_statement_d *stmt, tree_node *fndecl,
+ const MemRef *DestLoc, Value *&Result,
+ Type *ResultType, std::vector<Value *> &Ops);
public:
// Helper for taking the address of a label.
Modified: dragonegg/trunk/include/dragonegg/Trees.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/Trees.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/Trees.h (original)
+++ dragonegg/trunk/include/dragonegg/Trees.h Wed Jan 23 03:38:51 2013
@@ -38,10 +38,9 @@
// The following properties must hold if dragonegg is to work correctly.
#if ((BITS_PER_UNIT & 7) != 0)
-#error BITS_PER_UNIT must be a multiple of 8
+#error BITS_PER_UNIT must be a multiple of 8
#endif
-
/// dragonegg_tree_code - Fake helper tree codes.
enum dragonegg_tree_code {
ACCESS_TYPE, // A pointer or reference type.
@@ -53,10 +52,10 @@
};
/// isa - Return true if the given tree has the specified code.
-template<enum tree_code code> bool isa(const_tree t) {
+template <enum tree_code code> bool isa(const_tree t) {
return TREE_CODE(t) == code;
}
-template<enum dragonegg_tree_code code> bool isa(const_tree t) {
+template <enum dragonegg_tree_code code> bool isa(const_tree t) {
switch (code) {
case ACCESS_TYPE:
return POINTER_TYPE_P(t);
@@ -79,9 +78,7 @@
std::string getDescriptiveName(const_tree t);
/// main_type - Return the main variant of the given tree's type.
-inline tree main_type(tree exp) {
- return TYPE_MAIN_VARIANT(TREE_TYPE(exp));
-}
+inline tree main_type(tree exp) { return TYPE_MAIN_VARIANT(TREE_TYPE(exp)); }
inline const_tree main_type(const_tree exp) {
return TYPE_MAIN_VARIANT(TREE_TYPE(exp));
}
Modified: dragonegg/trunk/include/dragonegg/TypeConversion.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/dragonegg/TypeConversion.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/dragonegg/TypeConversion.h (original)
+++ dragonegg/trunk/include/dragonegg/TypeConversion.h Wed Jan 23 03:38:51 2013
@@ -29,10 +29,10 @@
// Forward declarations.
namespace llvm {
- class AttributeSet;
- class FunctionType;
- class LLVMContext;
- class Type;
+class AttributeSet;
+class FunctionType;
+class LLVMContext;
+class Type;
}
union tree_node;
@@ -40,7 +40,7 @@
// Utilities
//===----------------------------------------------------------------------===//
-#define NO_LENGTH (~(uint64_t)0)
+#define NO_LENGTH (~(uint64_t) 0)
/// ArrayLengthOf - Returns the length of the given gcc array type, or NO_LENGTH
/// if the array has variable or unknown length.
@@ -88,19 +88,15 @@
/// 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
/// turning "T foo(...)" functions into "T foo(void)" functions.
-llvm::FunctionType *ConvertArgListToFnType(tree_node *type,
- ArrayRef<tree_node *> arglist,
- tree_node *static_chain,
- bool KNRPromotion,
- llvm::CallingConv::ID &CC,
- llvm::AttributeSet &PAL);
+llvm::FunctionType *ConvertArgListToFnType(
+ tree_node *type, ArrayRef<tree_node *> arglist, tree_node *static_chain,
+ bool KNRPromotion, llvm::CallingConv::ID &CC, llvm::AttributeSet &PAL);
#endif /* DRAGONEGG_TYPES_H */
Modified: dragonegg/trunk/include/freebsd/dragonegg/OS.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/freebsd/dragonegg/OS.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/freebsd/dragonegg/OS.h (original)
+++ dragonegg/trunk/include/freebsd/dragonegg/OS.h Wed Jan 23 03:38:51 2013
@@ -24,10 +24,10 @@
#define DRAGONEGG_OS_H
/* Yes, we support PIC codegen for FreeBSD targets! */
-#define LLVM_SET_RELOC_MODEL(RelocModel) \
- if (flag_pic) \
- RelocModel = Reloc::PIC_; \
- else \
+#define LLVM_SET_RELOC_MODEL(RelocModel) \
+ if (flag_pic) \
+ RelocModel = Reloc::PIC_; \
+ else \
RelocModel = Reloc::Static;
#endif /* DRAGONEGG_OS_H */
Modified: dragonegg/trunk/include/kfreebsd/dragonegg/OS.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/kfreebsd/dragonegg/OS.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/kfreebsd/dragonegg/OS.h (original)
+++ dragonegg/trunk/include/kfreebsd/dragonegg/OS.h Wed Jan 23 03:38:51 2013
@@ -24,10 +24,10 @@
#define DRAGONEGG_OS_H
/* Yes, we support PIC codegen for KFreeBSD targets! */
-#define LLVM_SET_RELOC_MODEL(RelocModel) \
- if (flag_pic) \
- RelocModel = Reloc::PIC_; \
- else \
+#define LLVM_SET_RELOC_MODEL(RelocModel) \
+ if (flag_pic) \
+ RelocModel = Reloc::PIC_; \
+ else \
RelocModel = Reloc::Static;
#endif /* DRAGONEGG_OS_H */
Modified: dragonegg/trunk/include/linux/dragonegg/OS.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/linux/dragonegg/OS.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/linux/dragonegg/OS.h (original)
+++ dragonegg/trunk/include/linux/dragonegg/OS.h Wed Jan 23 03:38:51 2013
@@ -24,10 +24,10 @@
#define DRAGONEGG_OS_H
/* Yes, we support PIC codegen for linux targets! */
-#define LLVM_SET_RELOC_MODEL(RelocModel) \
- if (flag_pic) \
- RelocModel = Reloc::PIC_; \
- else \
+#define LLVM_SET_RELOC_MODEL(RelocModel) \
+ if (flag_pic) \
+ RelocModel = Reloc::PIC_; \
+ else \
RelocModel = Reloc::Static;
#endif /* DRAGONEGG_OS_H */
Modified: dragonegg/trunk/include/openbsd/dragonegg/OS.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/openbsd/dragonegg/OS.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/openbsd/dragonegg/OS.h (original)
+++ dragonegg/trunk/include/openbsd/dragonegg/OS.h Wed Jan 23 03:38:51 2013
@@ -24,10 +24,10 @@
#define DRAGONEGG_OS_H
/* Yes, we support PIC codegen for OpenBSD targets! */
-#define LLVM_SET_RELOC_MODEL(RelocModel) \
- if (flag_pic) \
- RelocModel = Reloc::PIC_; \
- else \
+#define LLVM_SET_RELOC_MODEL(RelocModel) \
+ if (flag_pic) \
+ RelocModel = Reloc::PIC_; \
+ else \
RelocModel = Reloc::Static;
#endif /* DRAGONEGG_OS_H */
Modified: dragonegg/trunk/include/x86/dragonegg/Target.h
URL: http://llvm.org/viewvc/llvm-project/dragonegg/trunk/include/x86/dragonegg/Target.h?rev=173244&r1=173243&r2=173244&view=diff
==============================================================================
--- dragonegg/trunk/include/x86/dragonegg/Target.h (original)
+++ dragonegg/trunk/include/x86/dragonegg/Target.h Wed Jan 23 03:38:51 2013
@@ -23,27 +23,25 @@
#ifndef DRAGONEGG_TARGET_H
#define DRAGONEGG_TARGET_H
-namespace llvm {
-class SubtargetFeatures;
-}
+namespace llvm { class SubtargetFeatures; }
/* LLVM specific stuff for supporting calling convention output */
-#define TARGET_ADJUST_LLVM_CC(CC, type) \
- { \
- tree_node *type_attributes = TYPE_ATTRIBUTES (type); \
- if (lookup_attribute ("stdcall", type_attributes)) { \
- CC = CallingConv::X86_StdCall; \
- } else if (lookup_attribute("fastcall", type_attributes)) { \
- CC = CallingConv::X86_FastCall; \
- } \
+#define TARGET_ADJUST_LLVM_CC(CC, type) \
+ { \
+ tree_node *type_attributes = TYPE_ATTRIBUTES(type); \
+ if (lookup_attribute("stdcall", type_attributes)) { \
+ CC = CallingConv::X86_StdCall; \
+ } else if (lookup_attribute("fastcall", type_attributes)) { \
+ CC = CallingConv::X86_FastCall; \
+ } \
}
-#define TARGET_ADJUST_LLVM_RETATTR(type, AttrBuilder) \
- { \
- tree_node *type_attributes = TYPE_ATTRIBUTES (type); \
- if (!TARGET_64BIT && (TARGET_SSEREGPARM || \
- lookup_attribute("sseregparm", type_attributes))) \
- AttrBuilder.addAttribute(Attribute::InReg); \
+#define TARGET_ADJUST_LLVM_RETATTR(type, AttrBuilder) \
+ { \
+ tree_node *type_attributes = TYPE_ATTRIBUTES(type); \
+ if (!TARGET_64BIT && \
+ (TARGET_SSEREGPARM || lookup_attribute("sseregparm", type_attributes)))\
+ AttrBuilder.addAttribute(Attribute::InReg); \
}
/* LLVM specific stuff for converting gcc's `regparm` attribute to LLVM's
@@ -59,51 +57,44 @@
} // extern "C"
#endif
-#define LLVM_TARGET_INIT_REGPARM(local_regparm, local_fp_regparm, type) \
- { \
- tree_node *attr; \
- local_regparm = ix86_regparm; \
- local_fp_regparm = TARGET_SSEREGPARM ? 3 : 0; \
- attr = lookup_attribute ("regparm", \
- TYPE_ATTRIBUTES (type)); \
- if (attr) { \
- local_regparm = TREE_INT_CST_LOW (TREE_VALUE \
- (TREE_VALUE (attr))); \
- } \
- attr = lookup_attribute("sseregparm", \
- TYPE_ATTRIBUTES (type)); \
- if (attr) \
- local_fp_regparm = 3; \
+#define LLVM_TARGET_INIT_REGPARM(local_regparm, local_fp_regparm, type) \
+ { \
+ tree_node *attr; \
+ local_regparm = ix86_regparm; \
+ local_fp_regparm = TARGET_SSEREGPARM ? 3 : 0; \
+ attr = lookup_attribute("regparm", TYPE_ATTRIBUTES(type)); \
+ if (attr) { \
+ local_regparm = TREE_INT_CST_LOW(TREE_VALUE(TREE_VALUE(attr))); \
+ } \
+ attr = lookup_attribute("sseregparm", TYPE_ATTRIBUTES(type)); \
+ if (attr) \
+ local_fp_regparm = 3; \
}
-#define LLVM_ADJUST_REGPARM_ATTRIBUTE(AttrBuilder, Type, Size, \
- local_regparm, \
- local_fp_regparm) \
- { \
- if (!TARGET_64BIT) { \
- if (isa<REAL_TYPE>(Type) && \
- (TYPE_PRECISION(Type)==32 || \
- TYPE_PRECISION(Type)==64)) { \
- local_fp_regparm -= 1; \
- if (local_fp_regparm >= 0) \
- AttrBuilder.addAttribute(Attribute::InReg); \
- else \
- local_fp_regparm = 0; \
- } else if (isa<INTEGRAL_TYPE>(Type) || \
- isa<ACCESS_TYPE>(Type)) { \
- int words = \
- (Size + BITS_PER_WORD - 1) / BITS_PER_WORD; \
- local_regparm -= words; \
- if (local_regparm>=0) \
- AttrBuilder.addAttribute(Attribute::InReg); \
- else \
- local_regparm = 0; \
- } \
- } \
+#define LLVM_ADJUST_REGPARM_ATTRIBUTE(AttrBuilder, Type, Size, local_regparm, \
+ local_fp_regparm) \
+ { \
+ if (!TARGET_64BIT) { \
+ if (isa<REAL_TYPE>(Type) && \
+ (TYPE_PRECISION(Type) == 32 || TYPE_PRECISION(Type) == 64)) { \
+ local_fp_regparm -= 1; \
+ if (local_fp_regparm >= 0) \
+ AttrBuilder.addAttribute(Attribute::InReg); \
+ else \
+ local_fp_regparm = 0; \
+ } else if (isa<INTEGRAL_TYPE>(Type) || isa<ACCESS_TYPE>(Type)) { \
+ int words = (Size + BITS_PER_WORD - 1) / BITS_PER_WORD; \
+ local_regparm -= words; \
+ if (local_regparm >= 0) \
+ AttrBuilder.addAttribute(Attribute::InReg); \
+ else \
+ local_regparm = 0; \
+ } \
+ } \
}
-#define LLVM_SET_RED_ZONE_FLAG(disable_red_zone) \
- if (TARGET_64BIT && TARGET_NO_RED_ZONE) \
+#define LLVM_SET_RED_ZONE_FLAG(disable_red_zone) \
+ if (TARGET_64BIT && TARGET_NO_RED_ZONE) \
disable_red_zone = 1;
#ifdef DRAGONEGG_ABI_H
@@ -111,8 +102,7 @@
/* On x86-32 objects containing SSE vectors are 16 byte aligned, everything
else 4. On x86-64 vectors are 8-byte aligned, everything else can
be figured out by the back end. */
-#define LLVM_BYVAL_ALIGNMENT(T) \
- (TYPE_ALIGN(T) / 8)
+#define LLVM_BYVAL_ALIGNMENT(T) (TYPE_ALIGN(T) / 8)
extern tree_node *llvm_x86_should_return_selt_struct_as_scalar(tree_node *);
@@ -121,54 +111,53 @@
if the element type is an MMX vector, return it as double (which will
get it into XMM0). */
-#define LLVM_SHOULD_RETURN_SELT_STRUCT_AS_SCALAR(X) \
+#define LLVM_SHOULD_RETURN_SELT_STRUCT_AS_SCALAR(X) \
llvm_x86_should_return_selt_struct_as_scalar((X))
extern bool llvm_x86_should_pass_aggregate_in_integer_regs(tree_node *,
- unsigned*, bool*);
+ unsigned *, bool *);
/* LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS - Return true if this aggregate
value should be passed in integer registers. This differs from the usual
handling in that x86-64 passes 128-bit structs and unions which only
contain data in the first 64 bits, as 64-bit objects. (These can be
created by abusing __attribute__((aligned)). */
-#define LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS(X, Y, Z) \
+#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);
+ unsigned *Offset);
/* LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN - Return LLVM Type if X can be
returned as a scalar, otherwise return NULL. */
-#define LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN(X, Y) \
+#define LLVM_SCALAR_TYPE_FOR_STRUCT_RETURN(X, Y) \
llvm_x86_scalar_type_for_struct_return((X), (Y))
extern Type *llvm_x86_aggr_type_for_struct_return(tree_node *type);
/* LLVM_AGGR_TYPE_FOR_STRUCT_RETURN - Return LLVM Type if X can be
returned as an aggregate, otherwise return NULL. */
-#define LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(X, CC) \
+#define LLVM_AGGR_TYPE_FOR_STRUCT_RETURN(X, CC) \
llvm_x86_aggr_type_for_struct_return(X)
-extern void llvm_x86_extract_multiple_return_value(Value *Src, Value *Dest,
- bool isVolatile,
- LLVMBuilder &B);
+extern void llvm_x86_extract_multiple_return_value(
+ Value *Src, Value *Dest, bool isVolatile, LLVMBuilder &B);
/* LLVM_EXTRACT_MULTIPLE_RETURN_VALUE - Extract multiple return value from
SRC and assign it to DEST. */
-#define LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Src,Dest,V,B) \
- llvm_x86_extract_multiple_return_value((Src),(Dest),(V),(B))
+#define LLVM_EXTRACT_MULTIPLE_RETURN_VALUE(Src, Dest, V, B) \
+ llvm_x86_extract_multiple_return_value((Src), (Dest), (V), (B))
extern bool llvm_x86_should_pass_vector_using_byval_attr(tree_node *);
/* On x86-64, vectors which are not MMX nor SSE should be passed byval. */
-#define LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR(X) \
+#define LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR(X) \
llvm_x86_should_pass_vector_using_byval_attr((X))
extern bool llvm_x86_should_pass_vector_in_integer_regs(tree_node *);
/* On x86-32, vectors which are not MMX nor SSE should be passed as integers. */
-#define LLVM_SHOULD_PASS_VECTOR_IN_INTEGER_REGS(X) \
+#define LLVM_SHOULD_PASS_VECTOR_IN_INTEGER_REGS(X) \
llvm_x86_should_pass_vector_in_integer_regs((X))
extern tree_node *llvm_x86_should_return_vector_as_scalar(tree_node *, bool);
@@ -178,62 +167,54 @@
are returned in EAX.
On Darwin x86-64, MMX vectors are returned in XMM0. Communicate this by
returning f64. */
-#define LLVM_SHOULD_RETURN_VECTOR_AS_SCALAR(X,isBuiltin)\
+#define LLVM_SHOULD_RETURN_VECTOR_AS_SCALAR(X, isBuiltin) \
llvm_x86_should_return_vector_as_scalar((X), (isBuiltin))
extern bool llvm_x86_should_return_vector_as_shadow(tree_node *, bool);
/* MMX vectors v2i32, v4i16, v8i8, v2f32 are returned using sret on Darwin
32-bit. Vectors bigger than 128 are returned using sret. */
-#define LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW(X,isBuiltin)\
- llvm_x86_should_return_vector_as_shadow((X),(isBuiltin))
+#define LLVM_SHOULD_RETURN_VECTOR_AS_SHADOW(X, isBuiltin) \
+ llvm_x86_should_return_vector_as_shadow((X), (isBuiltin))
-extern bool
-llvm_x86_should_not_return_complex_in_memory(tree_node *type);
+extern bool llvm_x86_should_not_return_complex_in_memory(tree_node *type);
/* LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY - A hook to allow
special _Complex handling. Return true if X should be returned using
multiple value return instruction. */
-#define LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY(X) \
+#define LLVM_SHOULD_NOT_RETURN_COMPLEX_IN_MEMORY(X) \
llvm_x86_should_not_return_complex_in_memory((X))
-extern bool
-llvm_x86_should_pass_aggregate_as_fca(tree_node *type, Type *);
+extern bool llvm_x86_should_pass_aggregate_as_fca(tree_node *type, Type *);
/* LLVM_SHOULD_PASS_AGGREGATE_AS_FCA - Return true if an aggregate of the
specified type should be passed as a first-class aggregate. */
#ifndef LLVM_SHOULD_PASS_AGGREGATE_AS_FCA
-#define LLVM_SHOULD_PASS_AGGREGATE_AS_FCA(X, TY) \
+#define LLVM_SHOULD_PASS_AGGREGATE_AS_FCA(X, TY) \
llvm_x86_should_pass_aggregate_as_fca(X, TY)
#endif
extern bool llvm_x86_should_pass_aggregate_in_memory(tree_node *, Type *);
-#define LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(X, TY) \
+#define LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(X, TY) \
llvm_x86_should_pass_aggregate_in_memory(X, TY)
-
-extern bool
-llvm_x86_64_should_pass_aggregate_in_mixed_regs(tree_node *, Type *Ty,
- std::vector<Type*>&);
-extern bool
-llvm_x86_32_should_pass_aggregate_in_mixed_regs(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)))
-
-extern
-bool llvm_x86_64_aggregate_partially_passed_in_regs(std::vector<Type*>&,
- std::vector<Type*>&,
- bool);
-
-#define LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(E, SE, ISR, CC) \
- (TARGET_64BIT ? \
- llvm_x86_64_aggregate_partially_passed_in_regs((E), (SE), (ISR)) : \
- false)
+extern bool llvm_x86_64_should_pass_aggregate_in_mixed_regs(
+ tree_node *, Type *Ty, std::vector<Type *> &);
+extern bool llvm_x86_32_should_pass_aggregate_in_mixed_regs(
+ 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)))
+
+extern bool llvm_x86_64_aggregate_partially_passed_in_regs(
+ std::vector<Type *> &, std::vector<Type *> &, bool);
+
+#define LLVM_AGGREGATE_PARTIALLY_PASSED_IN_REGS(E, SE, ISR, CC) \
+ (TARGET_64BIT ? llvm_x86_64_aggregate_partially_passed_in_regs( \
+ (E), (SE), (ISR)) : false)
#endif /* DRAGONEGG_ABI_H */
@@ -245,20 +226,19 @@
Similarly we play games with INTEGERSI_CLASS to use cheaper SImode moves
whenever possible (upper half does contain padding).
*/
-enum x86_64_reg_class
- {
- X86_64_NO_CLASS,
- X86_64_INTEGER_CLASS,
- X86_64_INTEGERSI_CLASS,
- X86_64_SSE_CLASS,
- X86_64_SSESF_CLASS,
- X86_64_SSEDF_CLASS,
- X86_64_SSEUP_CLASS,
- X86_64_X87_CLASS,
- X86_64_X87UP_CLASS,
- X86_64_COMPLEX_X87_CLASS,
- X86_64_MEMORY_CLASS
- };
+enum x86_64_reg_class {
+ X86_64_NO_CLASS,
+ X86_64_INTEGER_CLASS,
+ X86_64_INTEGERSI_CLASS,
+ X86_64_SSE_CLASS,
+ X86_64_SSESF_CLASS,
+ X86_64_SSEDF_CLASS,
+ X86_64_SSEUP_CLASS,
+ X86_64_X87_CLASS,
+ X86_64_X87UP_CLASS,
+ X86_64_COMPLEX_X87_CLASS,
+ X86_64_MEMORY_CLASS
+};
/* LLVM_TARGET_INTRINSIC_PREFIX - Specify what prefix this target uses for its
* intrinsics.
@@ -274,13 +254,12 @@
*/
extern void llvm_x86_set_subtarget_features(std::string &C,
llvm::SubtargetFeatures &F);
-#define LLVM_SET_SUBTARGET_FEATURES(C, F) \
- llvm_x86_set_subtarget_features(C, F)
+#define LLVM_SET_SUBTARGET_FEATURES(C, F) llvm_x86_set_subtarget_features(C, F)
-#define LLVM_SET_IMPLICIT_FLOAT(flag_no_implicit_float) \
- if (!TARGET_80387) \
- flag_no_implicit_float = 1; \
- else \
+#define LLVM_SET_IMPLICIT_FLOAT(flag_no_implicit_float) \
+ if (!TARGET_80387) \
+ flag_no_implicit_float = 1; \
+ else \
flag_no_implicit_float = 0;
/* LLVM ABI definition macros. */
@@ -288,19 +267,18 @@
/* When -m64 is specified, set the architecture to x86_64-os-blah even if the
* compiler was configured for i[3456]86-os-blah.
*/
-#define LLVM_OVERRIDE_TARGET_ARCH() \
- (TARGET_64BIT ? "x86_64" : "i386")
+#define LLVM_OVERRIDE_TARGET_ARCH() (TARGET_64BIT ? "x86_64" : "i386")
extern const char *llvm_x86_override_target_environment();
-#define LLVM_OVERRIDE_TARGET_ENVIRONMENT() \
+#define LLVM_OVERRIDE_TARGET_ENVIRONMENT() \
llvm_x86_override_target_environment()
-#define LLVM_ASM_EXTENSIONS(ESCAPED_CHAR, ASM, RESULT) \
- else if ((ESCAPED_CHAR) == 'v') { \
- /* %v means to use the AVX prefix 'v' if TARGET_AVX is true. */ \
- if (TARGET_AVX) \
- Result += 'v'; \
+#define LLVM_ASM_EXTENSIONS(ESCAPED_CHAR, ASM, RESULT) \
+ else if ((ESCAPED_CHAR) == 'v') { \
+ /* %v means to use the AVX prefix 'v' if TARGET_AVX is true. */ \
+ if (TARGET_AVX) \
+ Result += 'v'; \
}
/* LLVM_TARGET_INTRINSIC_LOWER - To handle builtins, we want to expand the
@@ -308,17 +286,20 @@
* macro should call the target TreeToLLVM::TargetIntrinsicLower method and
* return true.This macro is invoked from a method in the TreeToLLVM class.
*/
-#define LLVM_TARGET_INTRINSIC_LOWER(STMT, FNDECL, DESTLOC, RESULT, DESTTY, OPS) \
- TargetIntrinsicLower(STMT, FNDECL, DESTLOC, RESULT, DESTTY, OPS);
+#define LLVM_TARGET_INTRINSIC_LOWER(STMT, FNDECL, DESTLOC, RESULT, DESTTY, OPS)\
+ TargetIntrinsicLower(STMT, FNDECL, DESTLOC, RESULT, DESTTY, OPS);
/* LLVM_GET_REG_NAME - When extracting a register name for a constraint, use
the string extracted from the magic symbol built for that register, rather
than reg_names. The latter maps both AH and AL to the same thing, which
means we can't distinguish them. */
-#define LLVM_GET_REG_NAME(REG_NAME, REG_NUM) __extension__ \
- ({ const char *nm = (REG_NAME); \
- if (nm && (*nm == '%' || *nm == '#')) ++nm; \
- ((!nm || ISDIGIT (*nm)) ? reg_names[REG_NUM] : nm); })
+#define LLVM_GET_REG_NAME(REG_NAME, REG_NUM) \
+ __extension__({ \
+ const char *nm = (REG_NAME); \
+ if (nm && (*nm == '%' || *nm == '#')) \
+ ++nm; \
+ ((!nm || ISDIGIT(*nm)) ? reg_names[REG_NUM] : nm); \
+ })
/* LLVM_CANONICAL_ADDRESS_CONSTRAINTS - Valid x86 memory addresses include
symbolic values and immediates. Canonicalize GCC's "p" constraint for
@@ -326,40 +307,40 @@
#define LLVM_CANONICAL_ADDRESS_CONSTRAINTS "im"
/* Propagate code model setting to backend */
-#define LLVM_SET_CODE_MODEL(CMModel) \
- switch (ix86_cmodel) { \
- case CM_32: \
- CMModel = CodeModel::Default; \
- break; \
- case CM_SMALL: \
- case CM_SMALL_PIC: \
- CMModel = CodeModel::Small; \
- break; \
- case CM_KERNEL: \
- CMModel = CodeModel::Kernel; \
- break; \
- case CM_MEDIUM: \
- case CM_MEDIUM_PIC: \
- CMModel = CodeModel::Medium; \
- break; \
- case CM_LARGE: \
- case CM_LARGE_PIC: \
- CMModel = CodeModel::Large; \
- break; \
+#define LLVM_SET_CODE_MODEL(CMModel) \
+ switch (ix86_cmodel) { \
+ case CM_32: \
+ CMModel = CodeModel::Default; \
+ break; \
+ case CM_SMALL: \
+ case CM_SMALL_PIC: \
+ CMModel = CodeModel::Small; \
+ break; \
+ case CM_KERNEL: \
+ CMModel = CodeModel::Kernel; \
+ break; \
+ case CM_MEDIUM: \
+ case CM_MEDIUM_PIC: \
+ CMModel = CodeModel::Medium; \
+ break; \
+ case CM_LARGE: \
+ case CM_LARGE_PIC: \
+ CMModel = CodeModel::Large; \
+ break; \
}
-#define LLVM_SET_MACHINE_OPTIONS(argvec) \
- do { \
- if (ix86_force_align_arg_pointer) \
- argvec.push_back("-force-align-stack"); \
+#define LLVM_SET_MACHINE_OPTIONS(argvec) \
+ do { \
+ if (ix86_force_align_arg_pointer) \
+ argvec.push_back("-force-align-stack"); \
} while (0)
-#define LLVM_SET_TARGET_MACHINE_OPTIONS(O) \
- do { \
- if (TARGET_OMIT_LEAF_FRAME_POINTER) { \
- O.NoFramePointerElim = false; \
- O.NoFramePointerElimNonLeaf = true; \
- } \
+#define LLVM_SET_TARGET_MACHINE_OPTIONS(O) \
+ do { \
+ if (TARGET_OMIT_LEAF_FRAME_POINTER) { \
+ O.NoFramePointerElim = false; \
+ O.NoFramePointerElimNonLeaf = true; \
+ } \
} while (0)
#endif /* DRAGONEGG_TARGET_H */
More information about the llvm-commits
mailing list