[llvm-commits] CVS: llvm/lib/ExecutionEngine/Interpreter/Execution.cpp ExternalFunctions.cpp Interpreter.cpp Interpreter.h
Misha Brukman
brukman at cs.uiuc.edu
Thu Apr 21 15:43:19 PDT 2005
Changes in directory llvm/lib/ExecutionEngine/Interpreter:
Execution.cpp updated: 1.136 -> 1.137
ExternalFunctions.cpp updated: 1.83 -> 1.84
Interpreter.cpp updated: 1.22 -> 1.23
Interpreter.h updated: 1.68 -> 1.69
---
Log message:
* Remove trailing whitespace
* Convert tabs to spaces
---
Diffs of the changes: (+113 -113)
Execution.cpp | 192 +++++++++++++++++++++++++-------------------------
ExternalFunctions.cpp | 14 +--
Interpreter.cpp | 10 +-
Interpreter.h | 10 +-
4 files changed, 113 insertions(+), 113 deletions(-)
Index: llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
diff -u llvm/lib/ExecutionEngine/Interpreter/Execution.cpp:1.136 llvm/lib/ExecutionEngine/Interpreter/Execution.cpp:1.137
--- llvm/lib/ExecutionEngine/Interpreter/Execution.cpp:1.136 Mon Mar 14 22:54:19 2005
+++ llvm/lib/ExecutionEngine/Interpreter/Execution.cpp Thu Apr 21 17:43:08 2005
@@ -1,12 +1,12 @@
//===-- Execution.cpp - Implement code to simulate the program ------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
-//
+//
// This file contains the actual instruction interpreter.
//
//===----------------------------------------------------------------------===//
@@ -34,39 +34,39 @@
// Value Manipulation code
//===----------------------------------------------------------------------===//
-static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty);
-static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
+static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeShlInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeShrInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty);
+static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
GenericValue Src3);
GenericValue Interpreter::getConstantExprValue (ConstantExpr *CE,
@@ -179,8 +179,8 @@
#define IMPLEMENT_BINARY_OPERATOR(OP, TY) \
case Type::TY##TyID: Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; break
-static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeAddInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(+, UByte);
@@ -200,8 +200,8 @@
return Dest;
}
-static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeSubInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(-, UByte);
@@ -221,8 +221,8 @@
return Dest;
}
-static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeMulInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(*, UByte);
@@ -242,8 +242,8 @@
return Dest;
}
-static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeDivInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(/, UByte);
@@ -263,8 +263,8 @@
return Dest;
}
-static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeRemInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(%, UByte);
@@ -288,8 +288,8 @@
return Dest;
}
-static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeAndInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_BINARY_OPERATOR(&, Bool);
@@ -308,7 +308,7 @@
return Dest;
}
-static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
+static GenericValue executeOrInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
@@ -328,7 +328,7 @@
return Dest;
}
-static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
+static GenericValue executeXorInst(GenericValue Src1, GenericValue Src2,
const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
@@ -360,8 +360,8 @@
Dest.BoolVal = (void*)(intptr_t)Src1.PointerVal OP \
(void*)(intptr_t)Src2.PointerVal; break
-static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeSetEQInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(==, UByte);
@@ -382,8 +382,8 @@
return Dest;
}
-static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeSetNEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(!=, UByte);
@@ -405,8 +405,8 @@
return Dest;
}
-static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeSetLEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(<=, UByte);
@@ -427,8 +427,8 @@
return Dest;
}
-static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeSetGEInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(>=, UByte);
@@ -449,8 +449,8 @@
return Dest;
}
-static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeSetLTInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(<, UByte);
@@ -471,8 +471,8 @@
return Dest;
}
-static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
- const Type *Ty) {
+static GenericValue executeSetGTInst(GenericValue Src1, GenericValue Src2,
+ const Type *Ty) {
GenericValue Dest;
switch (Ty->getTypeID()) {
IMPLEMENT_SETCC(>, UByte);
@@ -523,7 +523,7 @@
SetValue(&I, R, SF);
}
-static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
+static GenericValue executeSelectInst(GenericValue Src1, GenericValue Src2,
GenericValue Src3) {
return Src1.BoolVal ? Src2 : Src3;
}
@@ -564,15 +564,15 @@
// Pop the current stack frame.
ECStack.pop_back();
- if (ECStack.empty()) { // Finished main. Put result into exit code...
- if (RetTy && RetTy->isIntegral()) { // Nonvoid return type?
- ExitCode = Result.IntVal; // Capture the exit code of the program
- } else {
- ExitCode = 0;
- }
- } else {
- // If we have a previous stack frame, and we have a previous call,
- // fill in the return value...
+ if (ECStack.empty()) { // Finished main. Put result into exit code...
+ if (RetTy && RetTy->isIntegral()) { // Nonvoid return type?
+ ExitCode = Result.IntVal; // Capture the exit code of the program
+ } else {
+ ExitCode = 0;
+ }
+ } else {
+ // If we have a previous stack frame, and we have a previous call,
+ // fill in the return value...
ExecutionContext &CallingSF = ECStack.back();
if (Instruction *I = CallingSF.Caller.getInstruction()) {
if (CallingSF.Caller.getType() != Type::VoidTy) // Save result...
@@ -629,7 +629,7 @@
if (!I.isUnconditional()) {
Value *Cond = I.getCondition();
if (getOperandValue(Cond, SF).BoolVal == 0) // If false cond...
- Dest = I.getSuccessor(1);
+ Dest = I.getSuccessor(1);
}
SwitchToNewBasicBlock(Dest, SF);
}
@@ -647,7 +647,7 @@
Dest = cast<BasicBlock>(I.getOperand(i+1));
break;
}
-
+
if (!Dest) Dest = I.getDefaultDest(); // No cases matched: use default
SwitchToNewBasicBlock(Dest, SF);
}
@@ -677,7 +677,7 @@
int i = PN->getBasicBlockIndex(PrevBB);
assert(i != -1 && "PHINode doesn't contain entry for predecessor??");
Value *IncomingValue = PN->getIncomingValue(i);
-
+
// Save the incoming value for this PHI node...
ResultValues.push_back(getOperandValue(IncomingValue, SF));
}
@@ -724,8 +724,8 @@
// getElementOffset - The workhorse for getelementptr.
//
GenericValue Interpreter::executeGEPOperation(Value *Ptr, gep_type_iterator I,
- gep_type_iterator E,
- ExecutionContext &SF) {
+ gep_type_iterator E,
+ ExecutionContext &SF) {
assert(isa<PointerType>(Ptr->getType()) &&
"Cannot getElementOffset of a nonpointer type!");
@@ -734,10 +734,10 @@
for (; I != E; ++I) {
if (const StructType *STy = dyn_cast<StructType>(*I)) {
const StructLayout *SLO = TD.getStructLayout(STy);
-
+
const ConstantUInt *CPU = cast<ConstantUInt>(I.getOperand());
unsigned Index = unsigned(CPU->getValue());
-
+
Total += (PointerTy)SLO->MemberOffsets[Index];
} else {
const SequentialType *ST = cast<SequentialType>(*I);
@@ -845,23 +845,23 @@
const Type *Ty = V->getType();
if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4) {
if (Ty == Type::ShortTy)
- ArgVals.back().IntVal = ArgVals.back().ShortVal;
+ ArgVals.back().IntVal = ArgVals.back().ShortVal;
else if (Ty == Type::UShortTy)
- ArgVals.back().UIntVal = ArgVals.back().UShortVal;
+ ArgVals.back().UIntVal = ArgVals.back().UShortVal;
else if (Ty == Type::SByteTy)
- ArgVals.back().IntVal = ArgVals.back().SByteVal;
+ ArgVals.back().IntVal = ArgVals.back().SByteVal;
else if (Ty == Type::UByteTy)
- ArgVals.back().UIntVal = ArgVals.back().UByteVal;
+ ArgVals.back().UIntVal = ArgVals.back().UByteVal;
else if (Ty == Type::BoolTy)
- ArgVals.back().UIntVal = ArgVals.back().BoolVal;
+ ArgVals.back().UIntVal = ArgVals.back().BoolVal;
else
- assert(0 && "Unknown type!");
+ assert(0 && "Unknown type!");
}
}
- // To handle indirect calls, we must get the pointer value from the argument
+ // To handle indirect calls, we must get the pointer value from the argument
// and treat it as a function pointer.
- GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
+ GenericValue SRC = getOperandValue(SF.Caller.getCalledValue(), SF);
callFunction((Function*)GVTOP(SRC), ArgVals);
}
@@ -958,7 +958,7 @@
IMPLEMENT_CAST_CASE_END()
GenericValue Interpreter::executeCastOperation(Value *SrcVal, const Type *Ty,
- ExecutionContext &SF) {
+ ExecutionContext &SF) {
const Type *SrcTy = SrcVal->getType();
GenericValue Dest, Src = getOperandValue(SrcVal, SF);
@@ -994,7 +994,7 @@
// Get the incoming valist parameter. LLI treats the valist as a
// (ec-stack-depth var-arg-index) pair.
GenericValue VAList = getOperandValue(I.getOperand(0), SF);
-
+
// Move the pointer to the next vararg.
++VAList.UIntPairVal.second;
SetValue(&I, VAList, SF);
@@ -1011,7 +1011,7 @@
GenericValue VAList = getOperandValue(I.getOperand(0), SF);
GenericValue Dest;
GenericValue Src = ECStack[VAList.UIntPairVal.first]
- .VarArgs[VAList.UIntPairVal.second];
+ .VarArgs[VAList.UIntPairVal.second];
const Type *Ty = I.getType();
switch (Ty->getTypeID()) {
IMPLEMENT_VAARG(UByte);
@@ -1030,7 +1030,7 @@
std::cout << "Unhandled dest type for vaarg instruction: " << *Ty << "\n";
abort();
}
-
+
// Set the Value of this Instruction.
SetValue(&I, Dest, SF);
}
@@ -1044,9 +1044,9 @@
//
void Interpreter::callFunction(Function *F,
const std::vector<GenericValue> &ArgVals) {
- assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
- ECStack.back().Caller.arg_size() == ArgVals.size()) &&
- "Incorrect number of arguments passed into function call!");
+ assert((ECStack.empty() || ECStack.back().Caller.getInstruction() == 0 ||
+ ECStack.back().Caller.arg_size() == ArgVals.size()) &&
+ "Incorrect number of arguments passed into function call!");
// Make a new stack frame... and fill it in.
ECStack.push_back(ExecutionContext());
ExecutionContext &StackFrame = ECStack.back();
@@ -1066,7 +1066,7 @@
// Run through the function arguments and initialize their values...
assert((ArgVals.size() == F->arg_size() ||
- (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg())) &&
+ (ArgVals.size() > F->arg_size() && F->getFunctionType()->isVarArg()))&&
"Invalid number of values passed to function invocation!");
// Handle non-varargs arguments...
@@ -1083,7 +1083,7 @@
// Interpret a single instruction & increment the "PC".
ExecutionContext &SF = ECStack.back(); // Current stack frame
Instruction &I = *SF.CurInst++; // Increment before execute
-
+
// Track the number of dynamic instructions executed.
++NumDynamicInsts;
Index: llvm/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
diff -u llvm/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp:1.83 llvm/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp:1.84
--- llvm/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp:1.83 Fri Jan 21 13:59:37 2005
+++ llvm/lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp Thu Apr 21 17:43:08 2005
@@ -1,16 +1,16 @@
//===-- ExternalFunctions.cpp - Implement External Functions --------------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
-//
+//
// This file contains both code to deal with invoking "external" functions, but
// also contains code that implements "exported" external functions.
//
-// External functions in the interpreter are implemented by
+// External functions in the interpreter are implemented by
// using the system's dynamic loader to look up the address of the function
// we want to invoke. If a function is found, then one of the
// many lle_* wrapper functions in this file will translate its arguments from
@@ -301,7 +301,7 @@
Last = *FB++ = *FmtStr++;
}
*FB = 0;
-
+
switch (Last) {
case '%':
sprintf(Buffer, FmtBuf); break;
@@ -328,7 +328,7 @@
sprintf(Buffer, FmtBuf, Args[ArgNo++].DoubleVal); break;
case 'p':
sprintf(Buffer, FmtBuf, (void*)GVTOP(Args[ArgNo++])); break;
- case 's':
+ case 's':
sprintf(Buffer, FmtBuf, (char*)GVTOP(Args[ArgNo++])); break;
default: std::cout << "<unknown printf code '" << *FmtStr << "'!>";
ArgNo++; break;
@@ -504,7 +504,7 @@
return Ret;
}
-static size_t GV_to_size_t (GenericValue GV) {
+static size_t GV_to_size_t (GenericValue GV) {
size_t count;
if (sizeof (size_t) == sizeof (uint64_t)) {
count = (size_t)GV.ULongVal;
Index: llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp
diff -u llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp:1.22 llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp:1.23
--- llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp:1.22 Sun Jun 20 02:46:33 2004
+++ llvm/lib/ExecutionEngine/Interpreter/Interpreter.cpp Thu Apr 21 17:43:08 2005
@@ -1,10 +1,10 @@
//===- Interpreter.cpp - Top-Level LLVM Interpreter Implementation --------===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This file implements the top-level functionality for the LLVM interpreter.
@@ -50,7 +50,7 @@
//
Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
IntrinsicLowering *il)
- : ExecutionEngine(M), ExitCode(0),
+ : ExecutionEngine(M), ExitCode(0),
TD("lli", isLittleEndian, isLongPointer ? 8 : 4, isLongPointer ? 8 : 4,
isLongPointer ? 8 : 4), IL(il) {
@@ -92,13 +92,13 @@
const unsigned ArgCount = F->getFunctionType()->getNumParams();
for (unsigned i = 0; i < ArgCount; ++i)
ActualArgs.push_back(ArgValues[i]);
-
+
// Set up the function call.
callFunction(F, ActualArgs);
// Start executing the function.
run();
-
+
GenericValue rv;
rv.IntVal = ExitCode;
return rv;
Index: llvm/lib/ExecutionEngine/Interpreter/Interpreter.h
diff -u llvm/lib/ExecutionEngine/Interpreter/Interpreter.h:1.68 llvm/lib/ExecutionEngine/Interpreter/Interpreter.h:1.69
--- llvm/lib/ExecutionEngine/Interpreter/Interpreter.h:1.68 Sun Nov 7 17:58:44 2004
+++ llvm/lib/ExecutionEngine/Interpreter/Interpreter.h Thu Apr 21 17:43:08 2005
@@ -1,10 +1,10 @@
//===-- Interpreter.h ------------------------------------------*- C++ -*--===//
-//
+//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
+//
//===----------------------------------------------------------------------===//
//
// This header file defines the interpreter structure
@@ -123,7 +123,7 @@
/// freeMachineCodeForFunction - The interpreter does not generate any code.
///
void freeMachineCodeForFunction(Function *F) { }
-
+
// Methods used to execute code:
// Place a call on the stack
void callFunction(Function *F, const std::vector<GenericValue> &ArgVals);
@@ -160,7 +160,7 @@
assert(0 && "Instruction not interpretable yet!");
}
- GenericValue callExternalFunction(Function *F,
+ GenericValue callExternalFunction(Function *F,
const std::vector<GenericValue> &ArgVals);
void exitCalled(GenericValue GV);
@@ -181,7 +181,7 @@
// SwitchToNewBasicBlock - Start execution in a new basic block and run any
// PHI nodes in the top of the block. This is used for intraprocedural
// control flow.
- //
+ //
void SwitchToNewBasicBlock(BasicBlock *Dest, ExecutionContext &SF);
void *getPointerToFunction(Function *F) { return (void*)F; }
More information about the llvm-commits
mailing list