[PATCH] D43700: Emit proper CodeView even when not using the cl driver.

[Colden Cullen via Phabricator via cfe-commits]

colden added a comment.

Seems good to me! I'll give it a test on my end.

One alternate implementation idea though, what if you defaulted EmitCodeView to 
the hasArg check instead of false, then removed the `else *EmitCodeView = 
false;` block on line 4999?


https://reviews.llvm.org/D43700



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D43700: Emit proper CodeView even when not using the cl driver.

[Colden Cullen via Phabricator via cfe-commits]

colden added a comment.

In https://reviews.llvm.org/D43700#1018087, @zturner wrote:

> In https://reviews.llvm.org/D43700#1018042, @colden wrote:
>
> > Seems good to me! I'll give it a test on my end.
> >
> > One alternate implementation idea though, what if you defaulted 
> > EmitCodeView to the hasArg check instead of false, then removed the `else 
> > *EmitCodeView = false;` block on line 4999?
>
>
> That would actually change the behavior of the cl driver, which I kind of 
> don't want to do since it's not necessary.  It would whitelist an additional 
> clang option to be recognized by the cl driver.  Specifically, you could then 
> get debug info via the cl driver without specifying /Z7 or /Zi.  It makes the 
> possibilities more confusing, and someone will invariably try to do it and 
> screw something up.  We already whitelist some dash options so that the cl 
> driver will recognize them, but it's on a case by case basis and only when 
> there's a strong need for it.


Good point, that's a pretty good reason not to.


https://reviews.llvm.org/D43700



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D43700: Emit proper CodeView even when not using the cl driver.

[Colden Cullen via Phabricator via cfe-commits]

colden added a comment.

In https://reviews.llvm.org/D43700#1019505, @aganea wrote:

> Thanks for fixing this @zturner. I simply want to back-up what @probinson 
> says above - most of the games we do at Ubisoft are currently using a 
> different compilation toolchains for each platform (we ship at least 4-5 
> platforms for each top game). It can be clang or it can be MSVC; and most of 
> the time it's different versions of clang. Our long-term goal is to 
> preferably have only one toolchain for all our platforms & all our targets - 
> that means one set of common g++ like flags, including Windows.


+1, this is what we're going for on Lumberyard as well. Well put.


https://reviews.llvm.org/D43700



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D43700: Emit proper CodeView even when not using the cl driver.

[Colden Cullen via Phabricator via cfe-commits]

colden added a comment.

In https://reviews.llvm.org/D43700#1019506, @zturner wrote:

> @rnk by "in an MSVC environment" do you mean "when -fms-compatibility is 
> present"?


It looks like other places in this file are using 
`Triple.isWindowsMSVCEnvironment()`, which I think would make sense to use for 
this too. It's implemented as:

  bool isWindowsMSVCEnvironment() const {
return getOS() == Triple::Win32 &&
   (getEnvironment() == Triple::UnknownEnvironment ||
getEnvironment() == Triple::MSVC);
  }

This appears to default to true from a normal Windows cmd (on my Win10 machine, 
the default triple is `x86_64-pc-windows-msvc`).


https://reviews.llvm.org/D43700



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D41032: [CodeGen] Implement _InterlockedCompareExchange128 intrinsic

[Colden Cullen via Phabricator via cfe-commits]

colden created this revision.

InterlockedCompareExchange128 is a bit more complicated than the other 
InterlockedCompareExchange functions, so it requires a bit more work. It 
doesn't directly refer to 128bit ints, instead it takes pointers to 64bit ints 
for Destination and ComparandResult, and exchange is taken as two 64bit ints 
(high & low). The previous value is written to ComparandResult, and success is 
returned. This implementation does the following in order to produce a cmpxchg 
instruction:

1. Cast everything to 128bit ints or int pointers, and glues together the 
Exchange values
2. Reads from CompareandResult to get the comparand
3. Calls cmpxchg volatile (on X86 this will produce a lock cmpxchg16b 
instruction)
  1. Result 0 (previous value) is written back to ComparandResult
  2. Result 1 (success bool) is zext'ed to a uchar and returned

Resolves bug 35251 


https://reviews.llvm.org/D41032

Files:
  llvm/tools/clang/include/clang/Basic/Builtins.def
  llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
  llvm/tools/clang/test/CodeGen/ms-intrinsics.c


Index: llvm/tools/clang/test/CodeGen/ms-intrinsics.c
===
--- llvm/tools/clang/test/CodeGen/ms-intrinsics.c
+++ llvm/tools/clang/test/CodeGen/ms-intrinsics.c
@@ -329,6 +329,25 @@
 // CHECK: ret i64 [[RESULT]]
 // CHECK: }
 
+unsigned char test_InterlockedCompareExchange128(__int64 volatile 
*Destination, __int64 ExchangeHigh, __int64 ExchangeLow, __int64* 
ComparandResult) {
+  return _InterlockedCompareExchange128(Destination, ExchangeHigh, 
ExchangeLow, ComparandResult);
+}
+// CHECK-X64: define{{.*}}i8 @test_InterlockedCompareExchange128(i64*{{[a-z_ 
]*}}%Destination, i64{{[a-z_ ]*}}%ExchangeHigh, i64{{[a-z_ ]*}}%ExchangeLow, 
i64*{{[a-z_ ]*}}%ComparandResult){{.*}}{
+// CHECK-X64: [[DST:%[0-9]+]] = bitcast i64* %Destination to i128*
+// CHECK-X64: [[EH:%[0-9]+]] = zext i64 %ExchangeHigh to i128
+// CHECK-X64: [[EL:%[0-9]+]] = zext i64 %ExchangeLow to i128
+// CHECK-X64: [[CNR:%[0-9]+]] = bitcast i64* %ComparandResult to i128*
+// CHECK-X64: [[EHS:%[0-9]+]] = shl nuw i128 [[EH]], 64
+// CHECK-X64: [[EXP:%[0-9]+]] = or i128 [[EHS]], [[EL]]
+// CHECK-X64: [[ORG:%[0-9]+]] = load i128, i128* [[CNR]], align 16
+// CHECK-X64: [[RES:%[0-9]+]] = cmpxchg volatile i128* [[DST]], i128 [[ORG]], 
i128 [[EXP]] seq_cst seq_cst
+// CHECK-X64: [[OLD:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 0
+// CHECK-X64: store i128 [[OLD]], i128* [[CNR]], align 16
+// CHECK-X64: [[SUC1:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 1
+// CHECK-X64: [[SUC8:%[0-9]+]] = zext i1 [[SUC1]] to i8
+// CHECK-X64: ret i8 [[SUC8]]
+// CHECK-X64: }
+
 short test_InterlockedIncrement16(short volatile *Addend) {
   return _InterlockedIncrement16(Addend);
 }
Index: llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
===
--- llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
+++ llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
@@ -2521,6 +2521,47 @@
   CXI->setVolatile(true);
   return RValue::get(Builder.CreateExtractValue(CXI, 0));
   }
+  case Builtin::BI_InterlockedCompareExchange128: {
+// InterlockedCompareExchange128 doesn't directly refer to 128bit ints,
+// instead it takes pointers to 64bit ints for Destination and
+// ComparandResult, and exchange is taken as two 64bit ints (high & low).
+// The previous value is written to ComparandResult, and success is 
returned.
+
+llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
+llvm::Type *Int128PtrTy = Int128Ty->getPointerTo();
+
+Value *Destination = Builder.CreateBitCast(
+  EmitScalarExpr(E->getArg(0)), Int128PtrTy);
+Value *ExchangeHigh128 = Builder.CreateZExt(
+  EmitScalarExpr(E->getArg(1)), Int128Ty);
+Value *ExchangeLow128 = Builder.CreateZExt(
+  EmitScalarExpr(E->getArg(2)), Int128Ty);
+Address ComparandResult(
+  Builder.CreateBitCast(EmitScalarExpr(E->getArg(3)), Int128PtrTy),
+  getContext().toCharUnitsFromBits(128));
+
+Value *Exchange = Builder.CreateOr(
+  Builder.CreateShl(ExchangeHigh128, 64, "", false, false),
+  ExchangeLow128);
+
+Value *Comparand = Builder.CreateLoad(ComparandResult);
+
+AtomicCmpXchgInst *CXI = Builder.CreateAtomicCmpXchg(
+  Destination, Comparand, Exchange,
+  AtomicOrdering::SequentiallyConsistent,
+  AtomicOrdering::SequentiallyConsistent);
+CXI->setVolatile(true);
+
+// Write the result back to the inout pointer
+Builder.CreateStore(Builder.CreateExtractValue(CXI, 0), ComparandResult);
+
+// Get success boolean
+Value *Success = Builder.CreateExtractValue(CXI, 1);
+
+// zext the success boolean and return it
+return RValue::get(
+  Builder.CreateZExt(Success, ConvertType(E->getType(;
+  }
   case Builtin::BI_InterlockedIncrement16:
   case Builtin::BI_InterlockedIncrement:
 return RVal

[PATCH] D41032: [CodeGen][X86] Implement _InterlockedCompareExchange128 intrinsic

[Colden Cullen via Phabricator via cfe-commits]

colden updated this revision to Diff 126634.
colden retitled this revision from "[CodeGen] Implement 
_InterlockedCompareExchange128 intrinsic" to "[CodeGen][X86] Implement 
_InterlockedCompareExchange128 intrinsic".
colden added a comment.

Moved implementation to X86_64 specific code, as according to Microsoft docs 
this function isn't supported on X86 or ARM.


https://reviews.llvm.org/D41032

Files:
  llvm/tools/clang/include/clang/Basic/BuiltinsX86_64.def
  llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
  llvm/tools/clang/test/CodeGen/ms-intrinsics.c

Index: llvm/tools/clang/test/CodeGen/ms-intrinsics.c
===
--- llvm/tools/clang/test/CodeGen/ms-intrinsics.c
+++ llvm/tools/clang/test/CodeGen/ms-intrinsics.c
@@ -5,7 +5,7 @@
 // RUN: -triple thumbv7--windows -Oz -emit-llvm %s -o - \
 // RUN: | FileCheck %s --check-prefixes CHECK,CHECK-ARM,CHECK-ARM-X64
 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
-// RUN: -triple x86_64--windows -Oz -emit-llvm %s -o - \
+// RUN: -triple x86_64--windows -Oz -emit-llvm -target-feature +cx16 %s -o - \
 // RUN: | FileCheck %s --check-prefixes CHECK,CHECK-X64,CHECK-ARM-X64,CHECK-INTEL
 
 // intrin.h needs size_t, but -ffreestanding prevents us from getting it from
@@ -328,6 +328,27 @@
 // CHECK: [[RESULT:%[0-9]+]] = extractvalue { i64, i1 } [[TMP]], 0
 // CHECK: ret i64 [[RESULT]]
 // CHECK: }
+
+#if defined(__x86_64__)
+unsigned char test_InterlockedCompareExchange128(__int64 volatile *Destination, __int64 ExchangeHigh, __int64 ExchangeLow, __int64* ComparandResult) {
+  return _InterlockedCompareExchange128(Destination, ExchangeHigh, ExchangeLow, ComparandResult);
+}
+// CHECK-X64: define{{.*}}i8 @test_InterlockedCompareExchange128(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%ExchangeHigh, i64{{[a-z_ ]*}}%ExchangeLow, i64*{{[a-z_ ]*}}%ComparandResult){{.*}}{
+// CHECK-X64: [[DST:%[0-9]+]] = bitcast i64* %Destination to i128*
+// CHECK-X64: [[EH:%[0-9]+]] = zext i64 %ExchangeHigh to i128
+// CHECK-X64: [[EL:%[0-9]+]] = zext i64 %ExchangeLow to i128
+// CHECK-X64: [[CNR:%[0-9]+]] = bitcast i64* %ComparandResult to i128*
+// CHECK-X64: [[EHS:%[0-9]+]] = shl nuw i128 [[EH]], 64
+// CHECK-X64: [[EXP:%[0-9]+]] = or i128 [[EHS]], [[EL]]
+// CHECK-X64: [[ORG:%[0-9]+]] = load i128, i128* [[CNR]], align 16
+// CHECK-X64: [[RES:%[0-9]+]] = cmpxchg volatile i128* [[DST]], i128 [[ORG]], i128 [[EXP]] seq_cst seq_cst
+// CHECK-X64: [[OLD:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 0
+// CHECK-X64: store i128 [[OLD]], i128* [[CNR]], align 16
+// CHECK-X64: [[SUC1:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 1
+// CHECK-X64: [[SUC8:%[0-9]+]] = zext i1 [[SUC1]] to i8
+// CHECK-X64: ret i8 [[SUC8]]
+// CHECK-X64: }
+#endif
 
 short test_InterlockedIncrement16(short volatile *Addend) {
   return _InterlockedIncrement16(Addend);
Index: llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
===
--- llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
+++ llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
@@ -8430,6 +8430,46 @@
 return EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedDecrement, E);
   case X86::BI_InterlockedIncrement64:
 return EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedIncrement, E);
+  case X86::BI_InterlockedCompareExchange128: {
+// InterlockedCompareExchange128 doesn't directly refer to 128bit ints,
+// instead it takes pointers to 64bit ints for Destination and
+// ComparandResult, and exchange is taken as two 64bit ints (high & low).
+// The previous value is written to ComparandResult, and success is returned.
+
+llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
+llvm::Type *Int128PtrTy = Int128Ty->getPointerTo();
+
+Value *Destination = Builder.CreateBitCast(
+  EmitScalarExpr(E->getArg(0)), Int128PtrTy);
+Value *ExchangeHigh128 = Builder.CreateZExt(
+  EmitScalarExpr(E->getArg(1)), Int128Ty);
+Value *ExchangeLow128 = Builder.CreateZExt(
+  EmitScalarExpr(E->getArg(2)), Int128Ty);
+Address ComparandResult(
+  Builder.CreateBitCast(EmitScalarExpr(E->getArg(3)), Int128PtrTy),
+  getContext().toCharUnitsFromBits(128));
+
+Value *Exchange = Builder.CreateOr(
+  Builder.CreateShl(ExchangeHigh128, 64, "", false, false),
+  ExchangeLow128);
+
+Value *Comparand = Builder.CreateLoad(ComparandResult);
+
+AtomicCmpXchgInst *CXI = Builder.CreateAtomicCmpXchg(
+  Destination, Comparand, Exchange,
+  AtomicOrdering::SequentiallyConsistent,
+  AtomicOrdering::SequentiallyConsistent);
+CXI->setVolatile(true);
+
+// Write the result back to the inout pointer
+Builder.CreateStore(Builder.CreateExtractValue(CXI, 0), ComparandResult);
+
+// Get success boolean
+Value *Success = Builder.CreateExtractValue(CXI, 1);
+
+// zext the success boolean and retur

[PATCH] D41032: [CodeGen][X86] Implement _InterlockedCompareExchange128 intrinsic

[Colden Cullen via Phabricator via cfe-commits]

colden updated this revision to Diff 126641.
colden added a comment.

llvm::IntegerType::get(getLLVMContext(), 128) -> Builder.getInt128Ty()


https://reviews.llvm.org/D41032

Files:
  llvm/tools/clang/include/clang/Basic/BuiltinsX86_64.def
  llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
  llvm/tools/clang/test/CodeGen/ms-intrinsics.c

Index: llvm/tools/clang/test/CodeGen/ms-intrinsics.c
===
--- llvm/tools/clang/test/CodeGen/ms-intrinsics.c
+++ llvm/tools/clang/test/CodeGen/ms-intrinsics.c
@@ -5,7 +5,7 @@
 // RUN: -triple thumbv7--windows -Oz -emit-llvm %s -o - \
 // RUN: | FileCheck %s --check-prefixes CHECK,CHECK-ARM,CHECK-ARM-X64
 // RUN: %clang_cc1 -ffreestanding -fms-extensions -fms-compatibility -fms-compatibility-version=17.00 \
-// RUN: -triple x86_64--windows -Oz -emit-llvm %s -o - \
+// RUN: -triple x86_64--windows -Oz -emit-llvm -target-feature +cx16 %s -o - \
 // RUN: | FileCheck %s --check-prefixes CHECK,CHECK-X64,CHECK-ARM-X64,CHECK-INTEL
 
 // intrin.h needs size_t, but -ffreestanding prevents us from getting it from
@@ -328,6 +328,27 @@
 // CHECK: [[RESULT:%[0-9]+]] = extractvalue { i64, i1 } [[TMP]], 0
 // CHECK: ret i64 [[RESULT]]
 // CHECK: }
+
+#if defined(__x86_64__)
+unsigned char test_InterlockedCompareExchange128(__int64 volatile *Destination, __int64 ExchangeHigh, __int64 ExchangeLow, __int64* ComparandResult) {
+  return _InterlockedCompareExchange128(Destination, ExchangeHigh, ExchangeLow, ComparandResult);
+}
+// CHECK-X64: define{{.*}}i8 @test_InterlockedCompareExchange128(i64*{{[a-z_ ]*}}%Destination, i64{{[a-z_ ]*}}%ExchangeHigh, i64{{[a-z_ ]*}}%ExchangeLow, i64*{{[a-z_ ]*}}%ComparandResult){{.*}}{
+// CHECK-X64: [[DST:%[0-9]+]] = bitcast i64* %Destination to i128*
+// CHECK-X64: [[EH:%[0-9]+]] = zext i64 %ExchangeHigh to i128
+// CHECK-X64: [[EL:%[0-9]+]] = zext i64 %ExchangeLow to i128
+// CHECK-X64: [[CNR:%[0-9]+]] = bitcast i64* %ComparandResult to i128*
+// CHECK-X64: [[EHS:%[0-9]+]] = shl nuw i128 [[EH]], 64
+// CHECK-X64: [[EXP:%[0-9]+]] = or i128 [[EHS]], [[EL]]
+// CHECK-X64: [[ORG:%[0-9]+]] = load i128, i128* [[CNR]], align 16
+// CHECK-X64: [[RES:%[0-9]+]] = cmpxchg volatile i128* [[DST]], i128 [[ORG]], i128 [[EXP]] seq_cst seq_cst
+// CHECK-X64: [[OLD:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 0
+// CHECK-X64: store i128 [[OLD]], i128* [[CNR]], align 16
+// CHECK-X64: [[SUC1:%[0-9]+]] = extractvalue { i128, i1 } [[RES]], 1
+// CHECK-X64: [[SUC8:%[0-9]+]] = zext i1 [[SUC1]] to i8
+// CHECK-X64: ret i8 [[SUC8]]
+// CHECK-X64: }
+#endif
 
 short test_InterlockedIncrement16(short volatile *Addend) {
   return _InterlockedIncrement16(Addend);
Index: llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
===
--- llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
+++ llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp
@@ -8430,6 +8430,46 @@
 return EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedDecrement, E);
   case X86::BI_InterlockedIncrement64:
 return EmitMSVCBuiltinExpr(MSVCIntrin::_InterlockedIncrement, E);
+  case X86::BI_InterlockedCompareExchange128: {
+// InterlockedCompareExchange128 doesn't directly refer to 128bit ints,
+// instead it takes pointers to 64bit ints for Destination and
+// ComparandResult, and exchange is taken as two 64bit ints (high & low).
+// The previous value is written to ComparandResult, and success is returned.
+
+llvm::Type *Int128Ty = Builder.getInt128Ty();
+llvm::Type *Int128PtrTy = Int128Ty->getPointerTo();
+
+Value *Destination = Builder.CreateBitCast(
+  EmitScalarExpr(E->getArg(0)), Int128PtrTy);
+Value *ExchangeHigh128 = Builder.CreateZExt(
+  EmitScalarExpr(E->getArg(1)), Int128Ty);
+Value *ExchangeLow128 = Builder.CreateZExt(
+  EmitScalarExpr(E->getArg(2)), Int128Ty);
+Address ComparandResult(
+  Builder.CreateBitCast(EmitScalarExpr(E->getArg(3)), Int128PtrTy),
+  getContext().toCharUnitsFromBits(128));
+
+Value *Exchange = Builder.CreateOr(
+  Builder.CreateShl(ExchangeHigh128, 64, "", false, false),
+  ExchangeLow128);
+
+Value *Comparand = Builder.CreateLoad(ComparandResult);
+
+AtomicCmpXchgInst *CXI = Builder.CreateAtomicCmpXchg(
+  Destination, Comparand, Exchange,
+  AtomicOrdering::SequentiallyConsistent,
+  AtomicOrdering::SequentiallyConsistent);
+CXI->setVolatile(true);
+
+// Write the result back to the inout pointer
+Builder.CreateStore(Builder.CreateExtractValue(CXI, 0), ComparandResult);
+
+// Get success boolean
+Value *Success = Builder.CreateExtractValue(CXI, 1);
+
+// zext the success boolean and return it
+return Builder.CreateZExt(Success, ConvertType(E->getType()));
+  }
 
   case X86::BI_AddressOfReturnAddress: {
 Value *F = CGM.getIntrinsic(Intrinsic::addressofreturnaddress);
Index: llvm/tools/clang/include/clang/Basic/BuiltinsX86_6

[PATCH] D41032: [CodeGen][X86] Implement _InterlockedCompareExchange128 intrinsic

[Colden Cullen via Phabricator via cfe-commits]

colden marked an inline comment as done.
colden added inline comments.



Comment at: llvm/tools/clang/lib/CodeGen/CGBuiltin.cpp:8439
+
+llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
+llvm::Type *Int128PtrTy = Int128Ty->getPointerTo();

majnemer wrote:
> Builder.getInt128Ty()
Oh nice, that's way cleaner.


https://reviews.llvm.org/D41032



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D41032: [CodeGen][X86] Implement _InterlockedCompareExchange128 intrinsic

[Colden Cullen via Phabricator via cfe-commits]

colden added a comment.

Thanks Reid! Would you mind submitting this for me?


https://reviews.llvm.org/D41032



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[PATCH] D42455: Don't create hidden dllimport global values

[Colden Cullen via Phabricator via cfe-commits]

colden added a comment.

Confirmed, this fixes my issue! Thanks!


https://reviews.llvm.org/D42455



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits