llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang-driver Author: None (student433) <details> <summary>Changes</summary> Fixes #<!-- -->114979, adding support for the cl2000 compiler to the clang frontend to get clangd working as discussed in https://discourse.llvm.org/t/ti-c2000-target-not-supported-in-clangd-lsp/83015 --- Patch is 39.21 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/125663.diff 15 Files Affected: - (modified) clang/include/clang/Driver/Driver.h (+5-1) - (modified) clang/include/clang/Driver/Options.h (+1) - (modified) clang/include/clang/Driver/Options.td (+64-10) - (modified) clang/lib/Basic/CMakeLists.txt (+1) - (modified) clang/lib/Basic/Targets.cpp (+4) - (added) clang/lib/Basic/Targets/C2000.cpp (+356) - (added) clang/lib/Basic/Targets/C2000.h (+100) - (modified) clang/lib/Driver/CMakeLists.txt (+1) - (modified) clang/lib/Driver/Driver.cpp (+13) - (modified) clang/lib/Driver/ToolChain.cpp (+1) - (added) clang/lib/Driver/ToolChains/Arch/C2000.cpp (+85) - (added) clang/lib/Driver/ToolChains/Arch/C2000.h (+22) - (modified) clang/lib/Driver/ToolChains/CommonArgs.cpp (+5) - (modified) llvm/include/llvm/TargetParser/Triple.h (+1) - (modified) llvm/lib/TargetParser/Triple.cpp (+7) ``````````diff diff --git a/clang/include/clang/Driver/Driver.h b/clang/include/clang/Driver/Driver.h index f4a52cc529b79c..55da823598f9b1 100644 --- a/clang/include/clang/Driver/Driver.h +++ b/clang/include/clang/Driver/Driver.h @@ -107,7 +107,8 @@ class Driver { CPPMode, CLMode, FlangMode, - DXCMode + DXCMode, + C2000Mode } Mode; enum SaveTempsMode { @@ -253,6 +254,9 @@ class Driver { /// Whether the driver should follow dxc.exe like behavior. bool IsDXCMode() const { return Mode == DXCMode; } + // Whether the driver should follow cl2000.exe like behaviour. + bool IsC2000Mode() const { return Mode == C2000Mode; } + /// Only print tool bindings, don't build any jobs. LLVM_PREFERRED_TYPE(bool) unsigned CCCPrintBindings : 1; diff --git a/clang/include/clang/Driver/Options.h b/clang/include/clang/Driver/Options.h index 0797410e9940e2..1613810a5bf741 100644 --- a/clang/include/clang/Driver/Options.h +++ b/clang/include/clang/Driver/Options.h @@ -39,6 +39,7 @@ enum ClangVisibility { FlangOption = (1 << 4), FC1Option = (1 << 5), DXCOption = (1 << 6), + CL2000Option = (1 << 7) }; enum ID { diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index d38dd2b4e3cf09..44ce3c3413b09b 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -97,6 +97,10 @@ def FC1Option : OptionVisibility; // are made available when the driver is running in DXC compatibility mode. def DXCOption : OptionVisibility; +// CL2000Option - This is a cl2000.exe compatibility option. Options with this flag +// are made available when the driver is running in cl2000 compatibility mode. +def CL2000Option : OptionVisibility; + ///////// // Docs @@ -201,6 +205,9 @@ def hlsl_Group : OptionGroup<"<HLSL group>">, Group<f_Group>, DocName<"HLSL options">, Visibility<[ClangOption]>; +def cl2000_group : OptionGroup<"<cl2000 group>">, + Visibility<[CL2000Option]>; + // Feature groups - these take command line options that correspond directly to // target specific features and can be translated directly from command line // options. @@ -672,7 +679,7 @@ class InternalDriverOpt : Group<internal_driver_Group>, Flags<[NoXarchOption, HelpHidden]>; def driver_mode : Joined<["--"], "driver-mode=">, Group<internal_driver_Group>, Flags<[NoXarchOption, HelpHidden]>, - Visibility<[ClangOption, FlangOption, CLOption, DXCOption]>, + Visibility<[ClangOption, FlangOption, CLOption, DXCOption, CL2000Option]>, HelpText<"Set the driver mode to either 'gcc', 'g++', 'cpp', 'cl' or 'flang'">; def rsp_quoting : Joined<["--"], "rsp-quoting=">, Group<internal_driver_Group>, Flags<[NoXarchOption, HelpHidden]>, @@ -843,7 +850,7 @@ def C : Flag<["-"], "C">, Visibility<[ClangOption, CC1Option]>, HelpText<"Include comments in preprocessed output">, MarshallingInfoFlag<PreprocessorOutputOpts<"ShowComments">>; def D : JoinedOrSeparate<["-"], "D">, Group<Preprocessor_Group>, - Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, DXCOption]>, + Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, DXCOption, CL2000Option]>, MetaVarName<"<macro>=<value>">, HelpText<"Define <macro> to <value> (or 1 if <value> omitted)">; def E : Flag<["-"], "E">, Flags<[NoXarchOption]>, @@ -929,7 +936,7 @@ def ObjCXX : Flag<["-"], "ObjC++">, Flags<[NoXarchOption]>, def ObjC : Flag<["-"], "ObjC">, Flags<[NoXarchOption]>, HelpText<"Treat source input files as Objective-C inputs">; def O : Joined<["-"], "O">, Group<O_Group>, - Visibility<[ClangOption, CC1Option, FC1Option, FlangOption]>; + Visibility<[ClangOption, CC1Option, FC1Option, FlangOption, CL2000Option]>; def O_flag : Flag<["-"], "O">, Visibility<[ClangOption, CC1Option, FC1Option]>, Alias<O>, AliasArgs<["1"]>; def Ofast : Joined<["-"], "Ofast">, Group<O_Group>, @@ -1035,10 +1042,10 @@ def Xassembler : Separate<["-"], "Xassembler">, Group<CompileOnly_Group>; def Xclang : Separate<["-"], "Xclang">, HelpText<"Pass <arg> to clang -cc1">, MetaVarName<"<arg>">, - Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption]>, + Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption, CL2000Option]>, Group<CompileOnly_Group>; def : Joined<["-"], "Xclang=">, Group<CompileOnly_Group>, - Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption]>, + Flags<[NoXarchOption]>, Visibility<[ClangOption, CLOption, DXCOption, CL2000Option]>, Alias<Xclang>, HelpText<"Alias for -Xclang">, MetaVarName<"<arg>">; def Xcuda_fatbinary : Separate<["-"], "Xcuda-fatbinary">, @@ -4023,7 +4030,7 @@ def fdriver_only : Flag<["-"], "fdriver-only">, Flags<[NoXarchOption]>, Group<Action_Group>, HelpText<"Only run the driver.">; def fsyntax_only : Flag<["-"], "fsyntax-only">, Flags<[NoXarchOption]>, - Visibility<[ClangOption, CLOption, DXCOption, CC1Option, FC1Option, FlangOption]>, + Visibility<[ClangOption, CLOption, DXCOption, CC1Option, FC1Option, FlangOption, CL2000Option]>, Group<Action_Group>, HelpText<"Run the preprocessor, parser and semantic analysis stages">; def ftabstop_EQ : Joined<["-"], "ftabstop=">, Group<f_Group>; @@ -4470,7 +4477,7 @@ defm emit_compact_unwind_non_canonical : BoolFOption<"emit-compact-unwind-non-ca "Try emitting Compact-Unwind for non-canonical entries. Maybe overridden by other constraints">, NegFlag<SetFalse>>; def g_Flag : Flag<["-"], "g">, Group<g_Group>, - Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, + Visibility<[ClangOption, CLOption, DXCOption, FlangOption, CL2000Option]>, HelpText<"Generate source-level debug information">; def gline_tables_only : Flag<["-"], "gline-tables-only">, Group<gN_Group>, Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, @@ -5817,11 +5824,11 @@ def rdynamic : Flag<["-"], "rdynamic">, Group<Link_Group>, Visibility<[ClangOption, FlangOption]>; def resource_dir : Separate<["-"], "resource-dir">, Flags<[NoXarchOption, HelpHidden]>, - Visibility<[ClangOption, CC1Option, CLOption, DXCOption, FlangOption, FC1Option]>, + Visibility<[ClangOption, CC1Option, CLOption, DXCOption, FlangOption, FC1Option, CL2000Option]>, HelpText<"The directory which holds the compiler resource files">, MarshallingInfoString<HeaderSearchOpts<"ResourceDir">>; def resource_dir_EQ : Joined<["-"], "resource-dir=">, Flags<[NoXarchOption]>, - Visibility<[ClangOption, CLOption, DXCOption, FlangOption]>, + Visibility<[ClangOption, CLOption, DXCOption, FlangOption, CL2000Option]>, Alias<resource_dir>; def rpath : Separate<["-"], "rpath">, Flags<[LinkerInput]>, Group<Link_Group>, Visibility<[ClangOption, FlangOption]>; @@ -6020,7 +6027,7 @@ def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, MarshallingInfoFlag<DiagnosticOpts<"IgnoreWarnings">>; def x : JoinedOrSeparate<["-"], "x">, Flags<[NoXarchOption]>, - Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, CLOption]>, + Visibility<[ClangOption, CC1Option, FlangOption, FC1Option, CLOption, CL2000Option]>, HelpText<"Treat subsequent input files as having type <language>">, MetaVarName<"<language>">; def y : Joined<["-"], "y">; @@ -9111,3 +9118,50 @@ def wasm_opt : Flag<["--"], "wasm-opt">, Group<m_Group>, HelpText<"Enable the wasm-opt optimizer (default)">, MarshallingInfoNegativeFlag<LangOpts<"NoWasmOpt">>; + + + +//===----------------------------------------------------------------------===// +// cl2000 Options +//===----------------------------------------------------------------------===// + + + + +def cl2000_include_path : Joined<["--"], "include_path=">, Group<cl2000_group>, + HelpText<"specify include search paths for cl2000 driver mode">, Alias<isystem>; + +def eabi : Joined<["--"], "abi=">, Group<cl2000_group>, + HelpText<"abi">; +def strict_ansi : Joined<["--"], "strict_ansi">, Group<cl2000_group>, + HelpText<"strict ANSI/ISO Mode">; +def fp_mode : Joined<["--"], "fp_mode=">, Group<cl2000_group>, + HelpText<"fp mode">; +def cla_support : Joined<["--"], "cla_support=">, Group<cl2000_group>, + HelpText<"cla Support">; +def float_support : Joined<["--"], "float_support=">, Group<cl2000_group>, + HelpText<"Float Support">; +def idiv_support : Joined<["--"], "idiv_support=">, Group<cl2000_group>, + HelpText<"idiv Support">; +def tmu_support : Joined<["--"], "tmu_support=">, Group<cl2000_group>, + HelpText<"tmu Support">; +def vcu_support : Joined<["--"], "vcu_support=">, Group<cl2000_group>, + HelpText<"vcu Support">; +def opt_level : Joined<["--"], "opt_level=">, Group<cl2000_group>, + HelpText<"opt level">, Alias<O>; +def silicon_version : Joined<["-"], "v28">, Group<cl2000_group>, + HelpText<"silicon version">; +def large_model : Joined<["-"], "ml">, Group<cl2000_group>, + HelpText<"large model">; +def unified_memory : Joined<["-"], "mt">, Group<cl2000_group>, + HelpText<"unified memory">; +def output_file : Joined<["--"], "output_file=">, Group<cl2000_group>, + HelpText<"output file">, Alias<o>; +def source_file : Joined<["--"], "">, Group<cl2000_group>, + HelpText<"source file">; +def symdebug_dwarf : Joined<["--"], "symdebug:dwarf">, Group<cl2000_group>, + HelpText<"Alias for -g">, Alias<g_Flag>; +def relaxed_ansi : Joined<["--"], "relaxed_ansi">, Group<cl2000_group>, + HelpText<"relaxed ansi mode">; +def compile_only : Joined<["--"], "compile_only">, Group<cl2000_group>, + HelpText<"compile only">, Alias<c>; diff --git a/clang/lib/Basic/CMakeLists.txt b/clang/lib/Basic/CMakeLists.txt index 331dfbb3f4b67e..bc71f93fe101a2 100644 --- a/clang/lib/Basic/CMakeLists.txt +++ b/clang/lib/Basic/CMakeLists.txt @@ -99,6 +99,7 @@ add_clang_library(clangBasic Targets/ARM.cpp Targets/AVR.cpp Targets/BPF.cpp + Targets/C2000.cpp Targets/CSKY.cpp Targets/DirectX.cpp Targets/Hexagon.cpp diff --git a/clang/lib/Basic/Targets.cpp b/clang/lib/Basic/Targets.cpp index 281aebdb1c35d3..9f5045a73b2d83 100644 --- a/clang/lib/Basic/Targets.cpp +++ b/clang/lib/Basic/Targets.cpp @@ -19,6 +19,7 @@ #include "Targets/ARM.h" #include "Targets/AVR.h" #include "Targets/BPF.h" +#include "Targets/C2000.h" #include "Targets/CSKY.h" #include "Targets/DirectX.h" #include "Targets/Hexagon.h" @@ -272,6 +273,9 @@ std::unique_ptr<TargetInfo> AllocateTarget(const llvm::Triple &Triple, case llvm::Triple::msp430: return std::make_unique<MSP430TargetInfo>(Triple, Opts); + case llvm::Triple::c2000: + return std::make_unique<C2000TargetInfo>(Triple, Opts); + case llvm::Triple::mips: switch (os) { case llvm::Triple::Linux: diff --git a/clang/lib/Basic/Targets/C2000.cpp b/clang/lib/Basic/Targets/C2000.cpp new file mode 100644 index 00000000000000..5fe53377f10878 --- /dev/null +++ b/clang/lib/Basic/Targets/C2000.cpp @@ -0,0 +1,356 @@ +#include "C2000.h" +#include "Targets.h" +#include "clang/Basic/Builtins.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/MacroBuilder.h" +#include "clang/Basic/TargetBuiltins.h" + +using namespace clang; +using namespace clang::targets; + +const char *const C2000TargetInfo::GCCRegNames[] = { + "ACC", "XAR0", "XAR1", "XAR2", "XAR3", "XAR4", "XAR5", "XAR6", "XAR7"}; + +ArrayRef<const char *> C2000TargetInfo::getGCCRegNames() const { + return llvm::ArrayRef(GCCRegNames); +} + +bool C2000TargetInfo::handleTargetFeatures(std::vector<std::string> &Features, + DiagnosticsEngine &Diags) { + + for (const auto &Feature : Features) { + if (Feature == "+eabi") { + eabi = true; + continue; + } + if (Feature == "+strict_ansi") { + strict = true; + continue; + } + if (Feature == "+cla_support") { + cla_support = true; + } + if (Feature == "+cla0") { + cla0 = true; + continue; + } + if (Feature == "+cla1") { + cla1 = true; + continue; + } + if (Feature == "+cla2") { + cla2 = true; + continue; + } + if (Feature == "+relaxed") { + relaxed = true; + continue; + } + if (Feature == "+fpu64") { + fpu64 = true; + continue; + } + if (Feature == "+fpu32") { + fpu32 = true; + continue; + } + if (Feature == "+tmu_support") { + tmu_support = true; + } + if (Feature == "+tmu1") { + tmu1 = true; + continue; + } + if (Feature == "+idiv0") { + idiv0 = true; + continue; + } + if (Feature == "+vcu_support") { + vcu_support = true; + } + if (Feature == "+vcu2") { + vcu2 = true; + continue; + } + if (Feature == "+vcrc") { + vcrc = true; + continue; + } + if (Feature == "+opt_level") { + opt = true; + continue; + } + } + return true; +} + +bool C2000TargetInfo::hasFeature(StringRef Feature) const { + return llvm::StringSwitch<bool>(Feature) + .Case("eabi", eabi) + .Case("strict_ansi", strict) + .Case("cla-support", cla_support) + .Case("cla0", cla0) + .Case("cla1", cla1) + .Case("cla2", cla2) + .Case("relaxed", relaxed) + .Case("fpu64", fpu64) + .Case("fpu32", fpu32) + .Case("tmu-support", tmu_support) + .Case("tmu1", tmu1) + .Case("vcu-support", vcu_support) + .Case("vcu2", vcu2) + .Case("vcrc", vcrc) + .Case("opt-level", opt) + .Default(false); +} + +void C2000TargetInfo::getTargetDefines(const LangOptions &Opts, + MacroBuilder &Builder) const { + Builder.undefineMacro("__CHAR_BIT__"); // FIXME: Implement 16-bit char + Builder.defineMacro("__CHAR_BIT__", "16"); + Builder.defineMacro("__TMS320C2000__"); + Builder.defineMacro("_TMS320C2000"); + Builder.defineMacro("__TMS320C28XX__"); + Builder.defineMacro("_TMS320C28XX"); + Builder.defineMacro("__TMS320C28X__"); + Builder.defineMacro("_TMS320C28X"); + Builder.defineMacro("__TI_STRICT_FP_MODE__"); + Builder.defineMacro("__COMPILER_VERSION__"); + Builder.defineMacro("__TI_COMPILER_VERSION__"); + Builder.defineMacro("__TI_COMPILER_VERSION__QUAL_ID"); + Builder.defineMacro("__TI_COMPILER_VERSION__QUAL__", "QUAL_LETTER"); + Builder.defineMacro("__little_endian__"); + Builder.defineMacro("__PTRDIFF_T_TYPE__", "signed long"); + Builder.defineMacro("__SIZE_T_TYPE__", "unsigned long"); + Builder.defineMacro("__WCHAR_T_TYPE__", "long unsigned"); + Builder.defineMacro("__TI_WCHAR_T_BITS", "16"); + Builder.defineMacro("__TI_C99_COMPLEX_ENABLED"); + Builder.defineMacro("__TI_GNU_ATTRIBUTE_SUPPORT__"); + Builder.defineMacro("__LARGE_MODEL__"); + Builder.defineMacro("__signed_chars__"); + Builder.defineMacro("__OPTIMIZE_FOR_SPACE"); + + if (hasFeature("eabi")) + Builder.defineMacro("__TI_EABI__"); + if (hasFeature("strict_ansi")) + Builder.defineMacro("__TI_STRICT_ANSI_MODE__"); + if (hasFeature("cla-support")) + Builder.defineMacro("__TMS320C28XX_CLA__"); + + if (hasFeature("cla0")) + Builder.defineMacro("__TMS320C28XX_CLA0__"); + else if (hasFeature("cla1")) + Builder.defineMacro("__TMS320C28XX_CLA1__"); + else if (hasFeature("cla2")) + Builder.defineMacro("__TMS320C28XX_CLA2__"); + + if (hasFeature("fpu64")) { + Builder.defineMacro("__TMS320C28XX_FPU64__"); + Builder.defineMacro("__TMS320C28XX_FPU32__"); + } else if (hasFeature("fpu32")) + Builder.defineMacro("__TMS320C28XX_FPU32__"); + if (hasFeature("idiv0")) + Builder.defineMacro("__TMS320C28XX_IDIV__"); + if (hasFeature("tmu1")) + Builder.defineMacro("__TMS320C28XX_TMU1__"); + if (hasFeature("tmu-support")) { + Builder.defineMacro("__TMS320C28XX_TMU0__"); + Builder.defineMacro("__TMS320C28XX_TMU__"); + } + if (hasFeature("vcu-support")) + Builder.defineMacro("__TMS320C28XX_VCU0__"); + if (hasFeature("vcu2")) + Builder.defineMacro("__TMS320C28XX_VCU2__"); + else if (hasFeature("vcrc")) + Builder.defineMacro("__TMS320C28XX_VCRC__"); + if (hasFeature("opt-level")) + Builder.defineMacro("_INLINE"); + if (hasFeature("relaxed")) + Builder.undefineMacro("__TI_STRICT_FP_MODE__"); + + Builder.defineMacro("__cregister", ""); + Builder.defineMacro("interrupt", ""); + Builder.defineMacro("__interrupt", ""); + + // Assembly Instrinsics + + Builder.append("int __abs16_sat( int src );"); + Builder.append("void __add( int *m, int b );"); + Builder.append("long __addcu( long src1, unsigned int src2 );"); + Builder.append("void __addl( long *m, long b );"); + Builder.append("void __and(int *m, int b);"); + Builder.append("int *__byte_func( int *array, unsigned int byte_index );"); + Builder.defineMacro("__byte(array, byte_index)", + "*__byte_func(array, byte_index)"); + Builder.append("unsigned long *__byte_peripheral_32_func(unsigned long *x);"); + Builder.defineMacro("__byte_peripheral_32(x)", + "*__byte_peripheral_32_func(x)"); + Builder.append("void __dec( int *m );"); + + // dmac needs macro magic + Builder.append("unsigned int __disable_interrupts( );"); + Builder.append("void __eallow( void );"); + Builder.append("void __edis( void );"); + Builder.append("unsigned int __enable_interrupts( );"); + Builder.append("int __flip16(int src);"); + Builder.append("long __flip32(long src);"); + Builder.append("long long __flip64(long long src);"); + Builder.append("void __inc( int *m );"); + Builder.append("long __IQ( long double A , int N );"); + Builder.append("long __IQmpy( long A, long B , int N );"); + Builder.append("long __IQsat( long A, long max, long min );"); + Builder.append("long __IQxmpy(long A , long B, int N);"); + Builder.append("long long __llmax(long long dst, long long src);"); + Builder.append("long long __llmin(long long dst, long long src);"); + Builder.append("long __lmax(long dst, long src);"); + Builder.append("long __lmin(long dst, long src);"); + Builder.append("int __max(int dst, int src);"); + Builder.append("int __min(int dst, int src);"); + Builder.append("int __mov_byte( int *src, unsigned int n );"); + Builder.append("long __mpy( int src1, int src2 );"); + Builder.append("long __mpyb( int src1, unsigned int src2 );"); + Builder.append("long __mpy_mov_t( int src1, int src2, int * dst2 );"); + Builder.append("unsigned long __mpyu(unsigned int src2, unsigned int srt2);"); + Builder.append("long __mpyxu( int src1, unsigned int src2 );"); + Builder.append("long __norm32(long src, int * shift );"); + Builder.append("long long __norm64(long long src, int * shift );"); + Builder.append("void __or(int *m, int b);"); + Builder.append("long __qmpy32( long src32a, long src32b, int q );"); + Builder.append("long __qmpy32by16(long src32, int src16, int q);"); + Builder.append("void __restore_interrupts(unsigned int val );"); + Builder.append("long __rol( long src );"); + Builder.append("long __ror( long src );"); + Builder.append("void * __rpt_mov_imm(void * dst , int src ,int count );"); + Builder.append("int __rpt_norm_inc( long src, int dst, int count );"); + Builder.append("int __rpt_norm_dec(long src, int dst, int count);"); + Builder.append("long __rpt_rol(long src, int count);"); + Builder.append("long __rpt_ror(long src, int count);"); + Builder.append("long __rpt_subcu(long dst, int src, int count);"); + Builder.append("unsigned long __rpt_subcul(unsigned long num, unsigned long " + "den, unsigned long remainder, int count);"); + Builder.append("long __sat( long src );"); + Builder.append("long __sat32( long src, long limit );"); + Builder.append("long __sathigh16(long src, int limit);"); + Builder.append("long __satlow16( long src );"); + Builder.append("long __sbbu( long src1 , unsigned int src2 );"); + Builder.append("void __sub( int * m, int b );"); + Builder.append("long __subcu( long src1, int src2 );"); + Builder.append("unsigned long __subcul(unsigned long num, unsigned long den, " + "unsigned long remainder);"); + Builder.append("void __subl( long * m, long b )... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/125663 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
