strongly · really

/cygdrive/c/llvm
/cygdrive/c/llvm
/cygdrive/c/llvm-cfrontend
ld
ld --version
GNU ld version 2.15
GNU ld version 2.15.91 20040725
svn co svn://anonsvn.opensource.apple.com/svn/llvm/trunk
-dst-directory
+svn co svn://anonsvn.opensource.apple.com/svn/llvm/trunk dst-directory
+
svn update
svn update
README.LLVM
- % cd objdir
- % srcdir/configure --prefix=/some/path/you/can/install/to [options...]
- % gmake tools-only
-  
- % cd llvm
- % ./configure --prefix=/some/path/you/can/install/to [options...]
- % gmake tools-only
-  
--prefix
--prefix=/home/user/llvm
- % set path = ( `cd llvm/Debug/bin && pwd` $path )
-
- % pwd
- /usr/local/example/cfrontend/src
- % cd ..
- % mkdir build install
- % set CFEINSTALL = `pwd`/install
-
objdir == srcdir
objdir != srcdir
srcdir
objdir
srcdir !=
+         objdir
objdir != srcdir
+% cd objdir
+% srcdir/configure --prefix=/some/path/you/can/install/to [options...]
+% gmake tools-only
+
objdir == srcdir
+% cd llvm
+% ./configure --prefix=/some/path/you/can/install/to [options...]
+% gmake tools-only
+
--prefix
/usr/local
--prefix=/home/user/llvm
+  % set path = ( `cd llvm/Debug/bin && pwd` $path )
+
+  % export PATH=`cd llvm/Debug/bin && pwd`:$PATH
+
+  % pwd
+  /usr/local/example/cfrontend/src
+  % cd ..
+  % mkdir build install
+  % set CFEINSTALL = `pwd`/install
+
- % cd build
- % ../src/configure --prefix=$CFEINSTALL --disable-threads --disable-nls \
-   --disable-shared --enable-languages=c,c++ --program-prefix=llvm-
- % gmake all; gmake install
+  % pwd
+  /usr/local/example/cfrontend/src
+  % cd ..
+  % mkdir build install
+  % export CFEINSTALL=`pwd`/install
 
- % cd build
- % ../src/configure --prefix=$CFEINSTALL --disable-threads --disable-nls \
-   --disable-shared --enable-languages=c,c++ --disable-c-mbchar \
-   --program-prefix=llvm-
- % gmake all; gmake install
+% cd build
+% ../src/configure --prefix=$CFEINSTALL --disable-threads --disable-nls \
+  --disable-shared --enable-languages=c,c++ --program-prefix=llvm-
+% gmake all; gmake install
 
+% cd build
+% ../src/configure --prefix=$CFEINSTALL --disable-threads --disable-nls \
+  --disable-shared --enable-languages=c,c++ --disable-c-mbchar \
+  --program-prefix=llvm-
+% gmake all; gmake install
+
- % cd build
- % ../src/configure --prefix=$CFEINSTALL --disable-threads --disable-nls \
-   --disable-shared --enable-languages=c,c++ --host=sparc-sun-solaris2.8 \
-   --disable-c-mbchar --program-prefix=llvm-
- % gmake all; gmake install
-
gccas
gccld
.init
.fini
-L
gccld
MULTILIB_OPTIONS
$CFEINSTALL/bin
PATH
export PATH=$CFEINSTALL/bin:$PATH
setenv PATH $CFEINSTALL/bin:$PATH
- % gmake
- % gmake -C runtime install-bytecode
-
llvm-ranlib
- % cd $CFEINSTALL/lib
- % llvm-ranlib libiberty.a
- % llvm-ranlib libstdc++.a
- % llvm-ranlib libsupc++.a
- % cd $CFEINSTALL/lib/gcc/target-triplet/3.4-llvm
- % llvm-ranlib libgcc.a
- % llvm-ranlib libgcov.a
-
make check
llvm-test
gccas
gccld
.init
.fini
-L
gccld
MULTILIB_OPTIONS
$CFEINSTALL/bin
PATH
+  % setenv PATH $CFEINSTALL/bin:$PATH
+
+  % export PATH=$CFEINSTALL/bin:$PATH
+
+% gmake
+% gmake -C runtime install-bytecode
+
llvm-ranlib
+% cd $CFEINSTALL/lib
+% llvm-ranlib libiberty.a
+% llvm-ranlib libstdc++.a
+% llvm-ranlib libsupc++.a
+% cd $CFEINSTALL/lib/gcc/target-triplet/3.4-llvm
+% llvm-ranlib libgcc.a
+% llvm-ranlib libgcov.a
+
make
+            check
llvm-test
${:foo}
getelementptr
-find-bugs
Div
UDiv
SDiv
FDiv
Rem
URem
SRem
FRem
ConstantBool::True
ConstantBool::False
ConstantBool::getTrue()
ConstantBool::getFalse()
-cee
-filetype=asm
-filetype
-fno-strict-aliasing
llvm.stacksave
llvm.stackrestore
setjmp
-    for (i = 0; i != 1000000; ++i) {
-      int X[n];
-      foo(X);
-    }
-
sigsetjmp
siglongjmp
invoke
unwind
setjmp
longjmp
getcontext
setcontext
makecontext
longjmp
longjmp
-fno-strict-aliasing
llvm.stacksave
llvm.stackrestore
setjmp
format
format_arg
non_null
noreturn
constructor
destructor
unused
used
deprecated
warn_unused_result
weak
constructor
destructor
deprecated
fastcall
format
format_arg
non_null
noreturn
stdcall
unused
used
warn_unused_result
weak
noinline
always_inline
pure
const
nothrow
malloc
no_instrument_function
cdecl
section
alias
visibility
regparm
stdcall
fastcall
visibility
regparm
cleanup
common
nocommon
deprecated
transparent_union
deprecated
dllimport
dllexport
transparent_union
unused
used
weak
aligned
mode
packed
section
shared
tls_model
vector_size
dllimport
dllexport
vector_size
transparent_union
unused
urem
srem
frem
setcc
ashr
extractelement
icmp
fcmp
phi
select
call
  <result> = frem float 4.0, %var          ; yields {float}:result = 4.0 % %var
 
setcc
  <result> = seteq <ty> <var1>, <var2>   ; yields {bool}:result
-  <result> = setne <ty> <var1>, <var2>   ; yields {bool}:result
-  <result> = setlt <ty> <var1>, <var2>   ; yields {bool}:result
-  <result> = setgt <ty> <var1>, <var2>   ; yields {bool}:result
-  <result> = setle <ty> <var1>, <var2>   ; yields {bool}:result
-  <result> = setge <ty> <var1>, <var2>   ; yields {bool}:result
-
setcc
setcc
label
array
structure
void
seteq
true
bool
setne
true
bool
setlt
true
bool
setgt
true
bool
setle
true
bool
setge
true
bool
  <result> = seteq int   4, 5        ; yields {bool}:result = false
-  <result> = setne float 4, 5        ; yields {bool}:result = true
-  <result> = setlt uint  4, 5        ; yields {bool}:result = true
-  <result> = setgt sbyte 4, 5        ; yields {bool}:result = false
-  <result> = setle sbyte 4, 5        ; yields {bool}:result = true
-  <result> = setge sbyte 4, 5        ; yields {bool}:result = false
-
uint
int
long
int
long
ulong
getelementptr
uint
int
int
ulong
long
uint
icmp
  <result> = icmp <cond> <ty> <var1>, <var2>   ; yields {bool}:result
+
icmp
icmp
eq
ne
ugt
uge
ult
ule
sgt
sge
slt
sle
icmp
var1
var2
cond
eq
true
false
ne
true
false
ugt
true
var1
var2
uge
true
var1
var2
ult
true
var1
var2
ule
true
var1
var2
sgt
true
var1
var2
sge
true
var1
var2
slt
true
var1
var2
sle
true
var1
var2
eq
ne
  <result> = icmp eq int 4, 5           ; yields: result=false
+  <result> = icmp ne float* %X, %X      ; yields: result=false
+  <result> = icmp ult short 4, 5        ; yields: result=true
+  <result> = icmp sgt sbyte 4, 5        ; yields: result=false
+  <result> = icmp ule sbyte -4, 5       ; yields: result=false
+  <result> = icmp sge sbyte 4, 5        ; yields: result=false
+
fcmp
  <result> = fcmp <cond> <ty> <var1>, <var2>   ; yields {bool}:result
+
fcmp
fcmp
false
oeq
ogt
oge
olt
ole
one
ord
ueq
ugt
uge
ult
ule
une
uno
true
val1
val2
fcmp
var1
var2
cond
false
false
oeq
true
var1
var2
ogt
true
var1
var2
oge
true
var1
var2
olt
true
var1
var2
ole
true
var1
var2
one
true
var1
var2
ord
true
ueq
true
var1
var2
ugt
true
var1
var2
uge
true
var1
var2
ult
true
var1
var2
ule
true
var1
var2
une
true
var1
var2
uno
true
true
true
eq
ne
  <result> = fcmp oeq float 4.0, 5.0    ; yields: result=false
+  <result> = icmp one float 4.0, 5.0    ; yields: result=true
+  <result> = icmp olt float 4.0, 5.0    ; yields: result=true
+  <result> = icmp ueq double 1.0, 2.0   ; yields: result=false
+
phi
iftrue
label
false
iffalse
label
Test:
  %cond = seteq int %a, %b
  br bool %cond, label %IfEqual, label %IfUnequal
IfEqual:
  Test:
  %cond = icmp eq, int %a, %b
  br bool %cond, label %IfEqual, label %IfUnequal
IfEqual:
  ret int 1
IfUnequal:
  ret int 0

eq
ne
  <result> = icmp eq int 4, 5           ; yields: result=false
@@ -3130,7 +3129,7 @@
 the condition code which indicates the kind of comparison to perform. It is not
 a value, just a keyword. The possibilities for the condition code are:
 
-  false: no comparison, always false (always folded)
+  false: no comparison, always returns false
   oeq: ordered and equal
   ogt: ordered and greater than 
   oge: ordered and greater than or equal
@@ -3145,49 +3144,50 @@
   ule: unordered or less than or equal
   une: unordered or not equal
   uno: unordered (either nans)
-  true: no comparison, always true (always folded)
+  true: no comparison, always returns true
 
 The val1 and val2 arguments must be of 
 floating point, or a packed 
 floating point type. They must have identical types.
+In the foregoing, ordered means that neither operand is a QNAN and 
+unordered means that either operand is a QNAN.
 Semantics:
 The 'fcmp' compares var1 and var2 according to 
 the condition code given as cond. The comparison performed always
 yields a bool result, as follows: 
 

   false: always yields false, regardless of operands.
-  oeq: yields true if both operands are ordered and 
+  
oeq: yields true if both operands are not a QNAN and 
   var1 is equal to var2.
-  ogt: yields true if both operands are ordered and
+  
ogt: yields true if both operands are not a QNAN and
   var1 is greather than var2.
-  oge: yields true if both operands are ordered and 
+  
oge: yields true if both operands are not a QNAN and 
   var1 is greater than or equal to var2.
-  olt: yields true if both operands are ordered and 
+  
olt: yields true if both operands are not a QNAN and 
   var1 is less than var2.
-  ole: yields true if both operands are ordered and 
+  
ole: yields true if both operands are not a QNAN and 
   var1 is less than or equal to var2.
-  one: yields true if both operands are ordered and 
+  
one: yields true if both operands are not a QNAN and 
   var1 is not equal to var2.
-  ord: yields true if both operands are ordered.
-  ueq: yields true if either operand is unordered or 
+  
ord: yields true if both operands are not a QNAN.
+  ueq: yields true if either operand is a QNAN or 
   var1 is equal to var2.
-  ugt: yields true if either operand is unordered or 
+  
ugt: yields true if either operand is a QNAN or 
   var1 is greater than var2.
-  uge: yields true if either operand is unordered or 
+  
uge: yields true if either operand is a QNAN or 
   var1 is greater than or equal to var2.
-  ult: yields true if either operand is unordered or 
+  
ult: yields true if either operand is a QNAN or 
   var1 is less than var2.
-  ule: yields true if either operand is unordered or 
+  
ule: yields true if either operand is a QNAN or 
   var1 is less than or equal to var2.
-  une: yields true if either operand is unordered or 
+  
une: yields true if either operand is a QNAN or 
   var1 is not equal to var2.
-  uno: yields true if either operand is unordered.
+  uno: yields true if either operand is a QNAN.
   true: always yields true, regardless of operands.
 
 If the operands are packed typed, the elements of 
 the vector are compared in turn and the predicate must hold for all elements.
-While this is of dubious use for predicates other than eq and 
-ne, the other predicates can be used with packed types.
+
 
 Example:
   <result> = fcmp oeq float 4.0, 5.0    ; yields: result=false
@@ -4427,7 +4427,7 @@
 
   Chris Lattner

   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/11/18 21:55:45 $
+  Last modified: $Date: 2006/11/19 03:00:14 $
 
 
 





From rspencer at reidspencer.com  Sun Nov 19 01:36:36 2006
From: rspencer at reidspencer.com (Reid Spencer)
Date: Sat, 18 Nov 2006 23:36:36 -0800
Subject: [llvm-commits] SETCC Patch [For Review Only]
Message-ID: <1163921796.27629.24.camel@bashful.x10sys.com>

This is the first in a series of patches to split the SETCC instructions
into just two instructions: icmp (integer compare) and fcmp (floating
point compare). This patch is a no-op. It introduces code that will be
used in subsequent patches. The new instruction codes are reserved, the
instruction classes are defined, and the InstVisitor class (and users)
is updated to recognize the new instructions. However, nothing else in
LLVM will produce these instructions (yet). The patch passes all tests.

Reid.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: SETCC.patch
Type: text/x-patch
Size: 30087 bytes
Desc: not available
Url : http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20061118/7a0b3c1b/attachment.bin 

From clattner at apple.com  Sun Nov 19 16:55:52 2006
From: clattner at apple.com (Chris Lattner)
Date: Sun, 19 Nov 2006 14:55:52 -0800
Subject: [llvm-commits] SETCC Patch [For Review Only]
In-Reply-To: <1163921796.27629.24.camel@bashful.x10sys.com>
References: <1163921796.27629.24.camel@bashful.x10sys.com>
Message-ID: 


On Nov 18, 2006, at 11:36 PM, Reid Spencer wrote:

> This is the first in a series of patches to split the SETCC  
> instructions
> into just two instructions: icmp (integer compare) and fcmp (floating
> point compare). This patch is a no-op. It introduces code that will be
> used in subsequent patches. The new instruction codes are reserved,  
> the
> instruction classes are defined, and the InstVisitor class (and users)
> is updated to recognize the new instructions. However, nothing else in
> LLVM will produce these instructions (yet). The patch passes all  
> tests.

The comments on fcmpinst are not correct in some cases:
+  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, etc.
+  /// @returns the inverse predicate for the instructions current  
predicate.
+  /// @brief Return the inverse of the predicate

These refer to SLT which isn't valid for fcmp, similarly for others.

--- include/llvm/Support/InstVisitor.h	9 Oct 2006 18:33:08 -0000	1.41
+++ include/llvm/Support/InstVisitor.h	19 Nov 2006 07:32:51 -0000
@@ -167,10 +167,12 @@ public:
    RetTy visitSwitchInst(SwitchInst &I)              { DELEGATE 
(TerminatorInst);}
    RetTy visitInvokeInst(InvokeInst &I)              { DELEGATE 
(TerminatorInst);}
    RetTy visitUnwindInst(UnwindInst &I)              { DELEGATE 
(TerminatorInst);}
    RetTy visitUnreachableInst(UnreachableInst &I)    { DELEGATE 
(TerminatorInst);}
    RetTy visitSetCondInst(SetCondInst &I)            { DELEGATE 
(BinaryOperator);}
+  RetTy visitICmpInst(ICmpInst &I)                  { DELEGATE 
(Instruction);}
+  RetTy visitFCmpInst(FCmpInst &I)                  { DELEGATE 
(Instruction);}
    RetTy visitMallocInst(MallocInst &I)              { DELEGATE 
(AllocationInst);}
    RetTy visitAllocaInst(AllocaInst &I)              { DELEGATE 
(AllocationInst);}
    RetTy visitFreeInst(FreeInst     &I)              { DELEGATE 
(Instruction); }
    RetTy visitLoadInst(LoadInst     &I)              { DELEGATE 
(Instruction); }
    RetTy visitStoreInst(StoreInst   &I)              { DELEGATE 
(Instruction); }

This should delegate to CmpInst, which delegates to Instruction.


+void CmpInst::swapOperands() {
+  if (ICmpInst* IC = dyn_cast(this)) {
+    IC->swapOperands();
+  } else if (FCmpInst* FC = dyn_cast(this)) {
+    FC->swapOperands();
+  }
+  assert(!"Unknown CmpInst type");
+}

I'd write this as:

+void CmpInst::swapOperands() {
+  if (ICmpInst* IC = dyn_cast(this)) {
+    IC->swapOperands();
+  } else {
+    cast(this)->swapOperands();
+  }

which is faster in release builds.  Besides, the assert will always  
trigger above.  Please
use 0 && "foo", which is the standard idiom instead of !"foo".


+FCmpInst::Predicate FCmpInst::getInversePredicate(Predicate pred) {
+  switch (pred) {
+    default:
+      assert(!"Unknown icmp predicate!");
+    case OEQ: return ONE;
+    case ONE: return OEQ;
+    case OGT: return OLE;
+    case OLT: return OGE;
+    case OGE: return OLT;
+    case OLE: return OGT;
+    case UEQ: return UNE;
+    case UNE: return UEQ;
+    case UGT: return ULE;
+    case ULT: return UGE;
+    case UGE: return ULT;
+    case ULE: return UGT;
+    case TRUE: return FALSE;
+    case FALSE: return TRUE;
+  }
+}

These aren't right, for example, !OEQ = UNE


+void Verifier::visitICmpInst(ICmpInst& IC) {
+  // Check that icmp instructions return bool
+  Assert1(IC.getType() == Type::BoolTy,
+         "ICmp instructions must return boolean values!", &IC);
+  // Check that the operands are the same type
+  const Type* Op0Ty = IC.getOperand(0)->getType();
+  const Type* Op1Ty = IC.getOperand(0)->getType();
+  Assert1(Op0Ty == Op1Ty,
+          "Both operands to ICmp instruction are not of the same  
type!", &IC);
+  // Check that the operands are the right type
+  Assert1(Op0Ty->isIntegral() || Op0Ty->getTypeID() ==  
Type::PointerTyID ||
+          (isa(Op0Ty) &&
+           cast(Op0Ty)->getElementType()->isIntegral()),
+          "Invalid operand types for ICmp instruction", &IC);

Most of these check should also happen in the ctors.  The check for  
the result of bool should just be in the ctor.  Once an instruction  
is created, you can't change its result type.


+void  BVNImpl::visitCmpInst(CmpInst &CI1) {
+  Value *LHS = CI1.getOperand(0);
+  for (Value::use_iterator UI = LHS->use_begin(), UE = LHS->use_end();
+       UI != UE; ++UI)
+    if (CmpInst *CI2 = dyn_cast(*UI))
+      // Check to see if this comparinstruction is not CI, but same  
opcode,
+      // same predicate, and in the same function.

typo comparinstruction

+            // And its commutative (equal or not equal)
+             ((isa(CI1) && cast 
(CI1).isCommutative()) ||
+              (isa(CI1) && cast 
(CI1).isCommutative()))))

The second line has a typo (ICmp -> FCmp).  The second line begs for  
a CmpInst::isCommutative()

Go ahead and commit after tweaking these,

-Chris

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20061119/d483377f/attachment.html 

From reid at x10sys.com  Sun Nov 19 17:07:15 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Nov 2006 17:07:15 -0600
Subject: [llvm-commits] CVS: llvm/lib/AsmParser/Lexer.l ParserInternals.h
	llvmAsmParser.y
Message-ID: <200611192307.kAJN7F60010436@zion.cs.uiuc.edu>



Changes in directory llvm/lib/AsmParser:

Lexer.l updated: 1.82 -> 1.83
ParserInternals.h updated: 1.46 -> 1.47
llvmAsmParser.y updated: 1.275 -> 1.276
---
Log message:

For PR950: http://llvm.org/PR950 :
Retain the signedness of the old integer types in a new TypeInfo structure
so that it can be used in the grammar to implement auto-upgrade of things
that depended on signedness of types. This doesn't implement any new 
functionality in the AsmParser, its just plumbing for future changes.


---
Diffs of the changes:  (+277 -215)

 Lexer.l           |   37 +++-
 ParserInternals.h |   26 +++
 llvmAsmParser.y   |  429 ++++++++++++++++++++++++++++--------------------------
 3 files changed, 277 insertions(+), 215 deletions(-)


Index: llvm/lib/AsmParser/Lexer.l
diff -u llvm/lib/AsmParser/Lexer.l:1.82 llvm/lib/AsmParser/Lexer.l:1.83
--- llvm/lib/AsmParser/Lexer.l:1.82	Wed Nov  8 00:47:33 2006
+++ llvm/lib/AsmParser/Lexer.l	Sun Nov 19 17:07:00 2006
@@ -51,6 +51,17 @@
   llvmAsmlval.type.obsolete = true; \
   return sym
 
+// Construct a token value for a non-obsolete type
+#define RET_TY(CType, sym) \
+  llvmAsmlval.TypeVal.type = new PATypeHolder(CType); \
+  llvmAsmlval.TypeVal.signedness = isSignless; \
+  return sym
+
+// Construct a token value for an obsolete token
+#define RET_TY_OBSOLETE(CType, sign, sym) \
+  llvmAsmlval.TypeVal.type = new PATypeHolder(CType); \
+  llvmAsmlval.TypeVal.signedness = sign; \
+  return sym
 
 namespace llvm {
 
@@ -238,19 +249,19 @@
 x86_stdcallcc   { return X86_STDCALLCC_TOK; }
 x86_fastcallcc  { return X86_FASTCALLCC_TOK; }
 
-void            { llvmAsmlval.PrimType = Type::VoidTy  ; return VOID;   }
-bool            { llvmAsmlval.PrimType = Type::BoolTy  ; return BOOL;   }
-sbyte           { llvmAsmlval.PrimType = Type::SByteTy ; return SBYTE;  }
-ubyte           { llvmAsmlval.PrimType = Type::UByteTy ; return UBYTE;  }
-short           { llvmAsmlval.PrimType = Type::ShortTy ; return SHORT;  }
-ushort          { llvmAsmlval.PrimType = Type::UShortTy; return USHORT; }
-int             { llvmAsmlval.PrimType = Type::IntTy   ; return INT;    }
-uint            { llvmAsmlval.PrimType = Type::UIntTy  ; return UINT;   }
-long            { llvmAsmlval.PrimType = Type::LongTy  ; return LONG;   }
-ulong           { llvmAsmlval.PrimType = Type::ULongTy ; return ULONG;  }
-float           { llvmAsmlval.PrimType = Type::FloatTy ; return FLOAT;  }
-double          { llvmAsmlval.PrimType = Type::DoubleTy; return DOUBLE; }
-label           { llvmAsmlval.PrimType = Type::LabelTy ; return LABEL;  }
+void            { RET_TY(Type::VoidTy, VOID);  }
+bool            { RET_TY(Type::BoolTy, BOOL);  }
+sbyte           { RET_TY_OBSOLETE(Type::SByteTy, isSigned,   SBYTE); }
+ubyte           { RET_TY_OBSOLETE(Type::UByteTy, isUnsigned, UBYTE); }
+short           { RET_TY_OBSOLETE(Type::ShortTy, isSigned,   SHORT); }
+ushort          { RET_TY_OBSOLETE(Type::UShortTy,isUnsigned, USHORT); }
+int             { RET_TY_OBSOLETE(Type::IntTy,   isSigned,   INT);    }
+uint            { RET_TY_OBSOLETE(Type::UIntTy,  isUnsigned, UINT);   }
+long            { RET_TY_OBSOLETE(Type::LongTy,  isSigned,   LONG);   }
+ulong           { RET_TY_OBSOLETE(Type::ULongTy, isUnsigned, ULONG);  }
+float           { RET_TY(Type::FloatTy, FLOAT);  }
+double          { RET_TY(Type::DoubleTy, DOUBLE); }
+label           { RET_TY(Type::LabelTy,  LABEL);  }
 type            { return TYPE;   }
 opaque          { return OPAQUE; }
 


Index: llvm/lib/AsmParser/ParserInternals.h
diff -u llvm/lib/AsmParser/ParserInternals.h:1.46 llvm/lib/AsmParser/ParserInternals.h:1.47
--- llvm/lib/AsmParser/ParserInternals.h:1.46	Thu Oct 26 01:15:43 2006
+++ llvm/lib/AsmParser/ParserInternals.h	Sun Nov 19 17:07:00 2006
@@ -217,4 +217,30 @@
 typedef OpcodeInfo  MemOpInfo;
 typedef OpcodeInfo   OtherOpInfo;
 
+/// This enumeration is used to indicate if a type is signed, signless or
+/// unsigned. It is used for backwards compatibility with assembly code that
+/// pre-dates the signless types conversion.
+enum Signedness {
+  isSigned,
+  isUnsigned,
+  isSignless
+};
+
+/// This structure is used to keep track of the signedness of the obsolete
+/// integer types. Instead of creating an llvm::Type directly, the Lexer will
+/// create instances of TypeInfo which retains the signedness indication so
+/// it can be used by the parser for upgrade decisions.
+/// For example if "uint" is encountered then the type will be set "int32" 
+/// and the "signedness" will be "isUnsigned".  If the type is not obsolete 
+/// then "signedness" will be "isSignless".
+struct TypeInfo {
+  llvm::PATypeHolder *type;
+  Signedness signedness;
+};
+
+struct ValueInfo {
+  std::vector valuelist;
+  std::vector   signlist;
+};
+
 #endif


Index: llvm/lib/AsmParser/llvmAsmParser.y
diff -u llvm/lib/AsmParser/llvmAsmParser.y:1.275 llvm/lib/AsmParser/llvmAsmParser.y:1.276
--- llvm/lib/AsmParser/llvmAsmParser.y:1.275	Sun Nov 12 05:10:39 2006
+++ llvm/lib/AsmParser/llvmAsmParser.y	Sun Nov 19 17:07:00 2006
@@ -83,8 +83,8 @@
   Module *CurrentModule;
   std::map Values; // Module level numbered definitions
   std::map LateResolveValues;
-  std::vector    Types;
-  std::map LateResolveTypes;
+  std::vector    Types;
+  std::map LateResolveTypes;
 
   /// PlaceHolderInfo - When temporary placeholder objects are created, remember
   /// how they were referenced and on which line of the input they came from so
@@ -217,7 +217,7 @@
   case ValID::NumberVal:               // Is it a numbered definition?
     // Module constants occupy the lowest numbered slots...
     if ((unsigned)D.Num < CurModule.Types.size())
-      return CurModule.Types[(unsigned)D.Num];
+      return CurModule.Types[(unsigned)D.Num].type->get();
     break;
   case ValID::NameVal:                 // Is it a named definition?
     if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
@@ -247,13 +247,15 @@
     }
   }
 
-  std::map::iterator I =CurModule.LateResolveTypes.find(D);
+  std::map::iterator I =CurModule.LateResolveTypes.find(D);
   if (I != CurModule.LateResolveTypes.end())
-    return I->second;
+    return I->second.type->get();
 
-  Type *Typ = OpaqueType::get();
-  CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
-  return Typ;
+  TypeInfo TI;
+  TI.type = new PATypeHolder(OpaqueType::get());
+  TI.signedness = isSignless;
+  CurModule.LateResolveTypes.insert(std::make_pair(D, TI));
+  return TI.type->get();
  }
 
 static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
@@ -557,10 +559,10 @@
   if (Name) D = ValID::create(Name);
   else      D = ValID::create((int)CurModule.Types.size());
 
-  std::map::iterator I =
+  std::map::iterator I =
     CurModule.LateResolveTypes.find(D);
   if (I != CurModule.LateResolveTypes.end()) {
-    ((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
+    ((DerivedType*)I->second.type->get())->refineAbstractTypeTo(ToTy);
     CurModule.LateResolveTypes.erase(I);
   }
 }
@@ -822,14 +824,13 @@
 /// instruction. This function handles converting div -> [usf]div appropriately.
 /// @brief Convert obsolete BinaryOps opcodes to new values
 static void 
-sanitizeOpCode(OpcodeInfo &OI, const PATypeHolder& PATy)
+sanitizeOpCode(OpcodeInfo &OI, const Type *Ty)
 {
   // If its not obsolete, don't do anything
   if (!OI.obsolete) 
     return;
 
   // If its a packed type we want to use the element type
-  const Type* Ty = PATy;
   if (const PackedType* PTy = dyn_cast(Ty))
     Ty = PTy->getElementType();
 
@@ -860,13 +861,12 @@
 /// operates on Instruction::OtherOps instead of Instruction::BinaryOps.
 /// @brief Convert obsolete OtherOps opcodes to new values
 static void 
-sanitizeOpCode(OpcodeInfo &OI, const PATypeHolder& PATy)
+sanitizeOpCode(OpcodeInfo &OI, const Type *Ty)
 {
   // If its not obsolete, don't do anything
   if (!OI.obsolete) 
     return;
 
-  const Type* Ty = PATy; // type conversion
   switch (OI.opcode) {
   default:
     GenerateError("Invalid obsolete opcode (check Lexer.l)");
@@ -1040,19 +1040,18 @@
 %union {
   llvm::Module                           *ModuleVal;
   llvm::Function                         *FunctionVal;
-  std::pair  *ArgVal;
+  std::pair             *ArgVal;
   llvm::BasicBlock                       *BasicBlockVal;
   llvm::TerminatorInst                   *TermInstVal;
   llvm::Instruction                      *InstVal;
   llvm::Constant                         *ConstVal;
 
-  const llvm::Type                       *PrimType;
-  llvm::PATypeHolder                     *TypeVal;
+  TypeInfo                                TypeVal;
   llvm::Value                            *ValueVal;
 
-  std::vector > *ArgList;
+  std::vector >*ArgList;
   std::vector              *ValueList;
-  std::list          *TypeList;
+  std::list                    *TypeList;
   // Represent the RHS of PHI node
   std::list > *PHIList;
@@ -1117,9 +1116,9 @@
 
 // Built in types...
 %type   Types TypesV UpRTypes UpRTypesV
-%type   SIntType UIntType IntType FPType PrimType   // Classifications
-%token  VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
-%token  FLOAT DOUBLE TYPE LABEL
+%type   SIntType UIntType IntType FPType PrimType   // Classifications
+%token  VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
+%token  FLOAT DOUBLE TYPE LABEL
 
 %token  VAR_ID LABELSTR STRINGCONSTANT
 %type   Name OptName OptAssign
@@ -1279,15 +1278,22 @@
 //
 
 // TypesV includes all of 'Types', but it also includes the void type.
-TypesV    : Types    | VOID { $$ = new PATypeHolder($1); };
-UpRTypesV : UpRTypes | VOID { $$ = new PATypeHolder($1); };
+TypesV    : Types    | VOID { 
+    $$.type = new PATypeHolder($1.type->get());
+    $$.signedness = $1.signedness;
+};
+UpRTypesV : UpRTypes | VOID { 
+    $$.type = new PATypeHolder($1.type->get()); 
+    $$.signedness = $1.signedness;
+};
 
 Types     : UpRTypes {
     if (!UpRefs.empty())
-      GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
+      GEN_ERROR("Invalid upreference in type: " + 
+        ($1.type->get())->getDescription());
     $$ = $1;
     CHECK_FOR_ERROR
-  };
+};
 
 
 // Derived types are added later...
@@ -1295,17 +1301,19 @@
 PrimType : BOOL | SBYTE | UBYTE | SHORT  | USHORT | INT   | UINT ;
 PrimType : LONG | ULONG | FLOAT | DOUBLE | TYPE   | LABEL;
 UpRTypes : OPAQUE {
-    $$ = new PATypeHolder(OpaqueType::get());
+    $$.type = new PATypeHolder(OpaqueType::get());
+    $$.signedness = isSignless;
     CHECK_FOR_ERROR
   }
   | PrimType {
-    $$ = new PATypeHolder($1);
+    $$ = $1;
     CHECK_FOR_ERROR
   };
 UpRTypes : SymbolicValueRef {            // Named types are also simple types...
   const Type* tmp = getTypeVal($1);
   CHECK_FOR_ERROR
-  $$ = new PATypeHolder(tmp);
+  $$.type = new PATypeHolder(tmp);
+  $$.signedness = isSignless;
 };
 
 // Include derived types in the Types production.
@@ -1314,59 +1322,69 @@
     if ($2 > (uint64_t)~0U) GEN_ERROR("Value out of range!");
     OpaqueType *OT = OpaqueType::get();        // Use temporary placeholder
     UpRefs.push_back(UpRefRecord((unsigned)$2, OT));  // Add to vector...
-    $$ = new PATypeHolder(OT);
+    $$.type = new PATypeHolder(OT);
+    $$.signedness = isSignless;
     UR_OUT("New Upreference!\n");
     CHECK_FOR_ERROR
   }
   | UpRTypesV '(' ArgTypeListI ')' {           // Function derived type?
     std::vector Params;
-    for (std::list::iterator I = $3->begin(),
+    for (std::list::iterator I = $3->begin(),
            E = $3->end(); I != E; ++I)
-      Params.push_back(*I);
+      Params.push_back(I->type->get());
     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
     if (isVarArg) Params.pop_back();
 
-    $$ = new PATypeHolder(HandleUpRefs(FunctionType::get(*$1,Params,isVarArg)));
+    $$.type = new PATypeHolder(HandleUpRefs(
+               FunctionType::get($1.type->get(),Params,isVarArg)));
+    $$.signedness = isSignless;
     delete $3;      // Delete the argument list
-    delete $1;      // Delete the return type handle
+    delete $1.type;
     CHECK_FOR_ERROR
   }
   | '[' EUINT64VAL 'x' UpRTypes ']' {          // Sized array type?
-    $$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2)));
-    delete $4;
+    $$.type = new PATypeHolder(HandleUpRefs(
+      ArrayType::get($4.type->get(), (unsigned)$2)));
+    $$.signedness = isSignless;
+    delete $4.type;
     CHECK_FOR_ERROR
   }
   | '<' EUINT64VAL 'x' UpRTypes '>' {          // Packed array type?
-     const llvm::Type* ElemTy = $4->get();
-     if ((unsigned)$2 != $2)
-        GEN_ERROR("Unsigned result not equal to signed result");
-     if (!ElemTy->isPrimitiveType())
-        GEN_ERROR("Elemental type of a PackedType must be primitive");
-     if (!isPowerOf2_32($2))
-       GEN_ERROR("Vector length should be a power of 2!");
-     $$ = new PATypeHolder(HandleUpRefs(PackedType::get(*$4, (unsigned)$2)));
-     delete $4;
-     CHECK_FOR_ERROR
+    const llvm::Type* ElemTy = $4.type->get();
+    if ((unsigned)$2 != $2)
+      GEN_ERROR("Unsigned result not equal to signed result");
+    if (!ElemTy->isPrimitiveType())
+      GEN_ERROR("Elemental type of a PackedType must be primitive");
+    if (!isPowerOf2_32($2))
+      GEN_ERROR("Vector length should be a power of 2!");
+    $$.type = new PATypeHolder(HandleUpRefs(
+                PackedType::get($4.type->get(), (unsigned)$2)));
+    $$.signedness = isSignless;
+    delete $4.type;
+    CHECK_FOR_ERROR
   }
   | '{' TypeListI '}' {                        // Structure type?
     std::vector Elements;
-    for (std::list::iterator I = $2->begin(),
+    for (std::list::iterator I = $2->begin(),
            E = $2->end(); I != E; ++I)
-      Elements.push_back(*I);
+      Elements.push_back(I->type->get());
 
-    $$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    $$.type = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
+    $$.signedness = isSignless;
     delete $2;
     CHECK_FOR_ERROR
   }
   | '{' '}' {                                  // Empty structure type?
-    $$ = new PATypeHolder(StructType::get(std::vector()));
+    $$.type = new PATypeHolder(StructType::get(std::vector()));
+    $$.signedness = isSignless;
     CHECK_FOR_ERROR
   }
   | UpRTypes '*' {                             // Pointer type?
-    if (*$1 == Type::LabelTy)
+    if ($1.type->get() == Type::LabelTy)
       GEN_ERROR("Cannot form a pointer to a basic block");
-    $$ = new PATypeHolder(HandleUpRefs(PointerType::get(*$1)));
-    delete $1;
+    $$.type = new PATypeHolder(HandleUpRefs(PointerType::get($1.type->get())));
+    $$.signedness = $1.signedness;
+    delete $1.type;
     CHECK_FOR_ERROR
   };
 
@@ -1374,27 +1392,31 @@
 // declaration type lists
 //
 TypeListI : UpRTypes {
-    $$ = new std::list();
-    $$->push_back(*$1); delete $1;
+    $$ = new std::list();
+    $$->push_back($1);
     CHECK_FOR_ERROR
   }
   | TypeListI ',' UpRTypes {
-    ($$=$1)->push_back(*$3); delete $3;
+    ($$=$1)->push_back($3);
     CHECK_FOR_ERROR
   };
 
 // ArgTypeList - List of types for a function type declaration...
 ArgTypeListI : TypeListI
   | TypeListI ',' DOTDOTDOT {
-    ($$=$1)->push_back(Type::VoidTy);
+    TypeInfo TI; 
+    TI.type = new PATypeHolder(Type::VoidTy); TI.signedness = isSignless;
+    ($$=$1)->push_back(TI);
     CHECK_FOR_ERROR
   }
   | DOTDOTDOT {
-    ($$ = new std::list())->push_back(Type::VoidTy);
+    TypeInfo TI; 
+    TI.type = new PATypeHolder(Type::VoidTy); TI.signedness = isSignless;
+    ($$ = new std::list())->push_back(TI);
     CHECK_FOR_ERROR
   }
   | /*empty*/ {
-    $$ = new std::list();
+    $$ = new std::list();
     CHECK_FOR_ERROR
   };
 
@@ -1405,10 +1427,10 @@
 // ResolvedVal, ValueRef and ConstValueRef productions.
 //
 ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
-    const ArrayType *ATy = dyn_cast($1->get());
+    const ArrayType *ATy = dyn_cast($1.type->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*$1)->getDescription() + "'!");
+                     ($1.type->get())->getDescription() + "'!");
     const Type *ETy = ATy->getElementType();
     int NumElements = ATy->getNumElements();
 
@@ -1427,28 +1449,28 @@
     }
 
     $$ = ConstantArray::get(ATy, *$3);
-    delete $1; delete $3;
+    delete $1.type; delete $3;
     CHECK_FOR_ERROR
   }
   | Types '[' ']' {
-    const ArrayType *ATy = dyn_cast($1->get());
+    const ArrayType *ATy = dyn_cast($1.type->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*$1)->getDescription() + "'!");
+                     ($1.type->get())->getDescription() + "'!");
 
     int NumElements = ATy->getNumElements();
     if (NumElements != -1 && NumElements != 0) 
       GEN_ERROR("Type mismatch: constant sized array initialized with 0"
                      " arguments, but has size of " + itostr(NumElements) +"!");
     $$ = ConstantArray::get(ATy, std::vector());
-    delete $1;
+    delete $1.type;
     CHECK_FOR_ERROR
   }
   | Types 'c' STRINGCONSTANT {
-    const ArrayType *ATy = dyn_cast($1->get());
+    const ArrayType *ATy = dyn_cast($1.type->get());
     if (ATy == 0)
       GEN_ERROR("Cannot make array constant with type: '" + 
-                     (*$1)->getDescription() + "'!");
+                     ($1.type->get())->getDescription() + "'!");
 
     int NumElements = ATy->getNumElements();
     const Type *ETy = ATy->getElementType();
@@ -1471,14 +1493,14 @@
     }
     free($3);
     $$ = ConstantArray::get(ATy, Vals);
-    delete $1;
+    delete $1.type;
     CHECK_FOR_ERROR
   }
   | Types '<' ConstVector '>' { // Nonempty unsized arr
-    const PackedType *PTy = dyn_cast($1->get());
+    const PackedType *PTy = dyn_cast($1.type->get());
     if (PTy == 0)
       GEN_ERROR("Cannot make packed constant with type: '" + 
-                     (*$1)->getDescription() + "'!");
+                     $1.type->get()->getDescription() + "'!");
     const Type *ETy = PTy->getElementType();
     int NumElements = PTy->getNumElements();
 
@@ -1497,14 +1519,14 @@
     }
 
     $$ = ConstantPacked::get(PTy, *$3);
-    delete $1; delete $3;
+    delete $1.type; delete $3;
     CHECK_FOR_ERROR
   }
   | Types '{' ConstVector '}' {
-    const StructType *STy = dyn_cast($1->get());
+    const StructType *STy = dyn_cast($1.type->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*$1)->getDescription() + "'!");
+                     $1.type->get()->getDescription() + "'!");
 
     if ($3->size() != STy->getNumContainedTypes())
       GEN_ERROR("Illegal number of initializers for structure type!");
@@ -1518,39 +1540,39 @@
                        " of structure initializer!");
 
     $$ = ConstantStruct::get(STy, *$3);
-    delete $1; delete $3;
+    delete $1.type; delete $3;
     CHECK_FOR_ERROR
   }
   | Types '{' '}' {
-    const StructType *STy = dyn_cast($1->get());
+    const StructType *STy = dyn_cast($1.type->get());
     if (STy == 0)
       GEN_ERROR("Cannot make struct constant with type: '" + 
-                     (*$1)->getDescription() + "'!");
+                     $1.type->get()->getDescription() + "'!");
 
     if (STy->getNumContainedTypes() != 0)
       GEN_ERROR("Illegal number of initializers for structure type!");
 
     $$ = ConstantStruct::get(STy, std::vector());
-    delete $1;
+    delete $1.type;
     CHECK_FOR_ERROR
   }
   | Types NULL_TOK {
-    const PointerType *PTy = dyn_cast($1->get());
+    const PointerType *PTy = dyn_cast($1.type->get());
     if (PTy == 0)
       GEN_ERROR("Cannot make null pointer constant with type: '" + 
-                     (*$1)->getDescription() + "'!");
+                     $1.type->get()->getDescription() + "'!");
 
     $$ = ConstantPointerNull::get(PTy);
-    delete $1;
+    delete $1.type;
     CHECK_FOR_ERROR
   }
   | Types UNDEF {
-    $$ = UndefValue::get($1->get());
-    delete $1;
+    $$ = UndefValue::get($1.type->get());
+    delete $1.type;
     CHECK_FOR_ERROR
   }
   | Types SymbolicValueRef {
-    const PointerType *Ty = dyn_cast($1->get());
+    const PointerType *Ty = dyn_cast($1.type->get());
     if (Ty == 0)
       GEN_ERROR("Global const reference must be a pointer type!");
 
@@ -1607,35 +1629,35 @@
     }
 
     $$ = cast(V);
-    delete $1;            // Free the type handle
+    delete $1.type;            // Free the type handle
     CHECK_FOR_ERROR
   }
   | Types ConstExpr {
-    if ($1->get() != $2->getType())
+    if ($1.type->get() != $2->getType())
       GEN_ERROR("Mismatched types for constant expression!");
     $$ = $2;
-    delete $1;
+    delete $1.type;
     CHECK_FOR_ERROR
   }
   | Types ZEROINITIALIZER {
-    const Type *Ty = $1->get();
+    const Type *Ty = $1.type->get();
     if (isa(Ty) || Ty == Type::LabelTy || isa(Ty))
       GEN_ERROR("Cannot create a null initialized value of this type!");
     $$ = Constant::getNullValue(Ty);
-    delete $1;
+    delete $1.type;
     CHECK_FOR_ERROR
   };
 
 ConstVal : SIntType EINT64VAL {      // integral constants
-    if (!ConstantInt::isValueValidForType($1, $2))
+    if (!ConstantInt::isValueValidForType($1.type->get(), $2))
       GEN_ERROR("Constant value doesn't fit in type!");
-    $$ = ConstantInt::get($1, $2);
+    $$ = ConstantInt::get($1.type->get(), $2);
     CHECK_FOR_ERROR
   }
   | UIntType EUINT64VAL {            // integral constants
-    if (!ConstantInt::isValueValidForType($1, $2))
+    if (!ConstantInt::isValueValidForType($1.type->get(), $2))
       GEN_ERROR("Constant value doesn't fit in type!");
-    $$ = ConstantInt::get($1, $2);
+    $$ = ConstantInt::get($1.type->get(), $2);
     CHECK_FOR_ERROR
   }
   | BOOL TRUETOK {                      // Boolean constants
@@ -1647,9 +1669,9 @@
     CHECK_FOR_ERROR
   }
   | FPType FPVAL {                   // Float & Double constants
-    if (!ConstantFP::isValueValidForType($1, $2))
+    if (!ConstantFP::isValueValidForType($1.type->get(), $2))
       GEN_ERROR("Floating point constant invalid for type!!");
-    $$ = ConstantFP::get($1, $2);
+    $$ = ConstantFP::get($1.type->get(), $2);
     CHECK_FOR_ERROR
   };
 
@@ -1658,11 +1680,11 @@
     if (!$3->getType()->isFirstClassType())
       GEN_ERROR("cast constant expression from a non-primitive type: '" +
                      $3->getType()->getDescription() + "'!");
-    if (!$5->get()->isFirstClassType())
+    if (!$5.type->get()->isFirstClassType())
       GEN_ERROR("cast constant expression to a non-primitive type: '" +
-                     $5->get()->getDescription() + "'!");
-    $$ = ConstantExpr::getCast($3, $5->get());
-    delete $5;
+                     $5.type->get()->getDescription() + "'!");
+    $$ = ConstantExpr::getCast($3, $5.type->get());
+    delete $5.type;
     CHECK_FOR_ERROR
   }
   | GETELEMENTPTR '(' ConstVal IndexList ')' {
@@ -1853,16 +1875,16 @@
     // If types are not resolved eagerly, then the two types will not be
     // determined to be the same type!
     //
-    ResolveTypeTo($2, *$4);
+    ResolveTypeTo($2, $4.type->get());
 
-    if (!setTypeName(*$4, $2) && !$2) {
+    if (!setTypeName($4.type->get(), $2) && !$2) {
       CHECK_FOR_ERROR
       // If this is a named type that is not a redefinition, add it to the slot
       // table.
-      CurModule.Types.push_back(*$4);
+      CurModule.Types.push_back($4);
+    } else {
+      delete $4.type;
     }
-
-    delete $4;
     CHECK_FOR_ERROR
   }
   | ConstPool FunctionProto {       // Function prototypes can be in const pool
@@ -1880,26 +1902,29 @@
     CurGV = 0;
   }
   | ConstPool OptAssign EXTERNAL GlobalType Types {
-    CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4, *$5, 0);
+    CurGV = ParseGlobalVariable($2, GlobalValue::ExternalLinkage, $4,
+      $5.type->get(), 0);
     CHECK_FOR_ERROR
-    delete $5;
+    delete $5.type;
   } GlobalVarAttributes {
     CurGV = 0;
     CHECK_FOR_ERROR
   }
   | ConstPool OptAssign DLLIMPORT GlobalType Types {
-    CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4, *$5, 0);
+    CurGV = ParseGlobalVariable($2, GlobalValue::DLLImportLinkage, $4,
+      $5.type->get(), 0);
     CHECK_FOR_ERROR
-    delete $5;
+    delete $5.type;
   } GlobalVarAttributes {
     CurGV = 0;
     CHECK_FOR_ERROR
   }
   | ConstPool OptAssign EXTERN_WEAK GlobalType Types {
     CurGV = 
-      ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4, *$5, 0);
+      ParseGlobalVariable($2, GlobalValue::ExternalWeakLinkage, $4,
+        $5.type->get(), 0);
     CHECK_FOR_ERROR
-    delete $5;
+    delete $5.type;
   } GlobalVarAttributes {
     CurGV = 0;
     CHECK_FOR_ERROR
@@ -1977,9 +2002,9 @@
 OptName : Name | /*empty*/ { $$ = 0; };
 
 ArgVal : Types OptName {
-  if (*$1 == Type::VoidTy)
+  if ($1.type->get() == Type::VoidTy)
     GEN_ERROR("void typed arguments are invalid!");
-  $$ = new std::pair($1, $2);
+  $$ = new std::pair($1, $2);
   CHECK_FOR_ERROR
 };
 
@@ -1990,7 +2015,7 @@
     CHECK_FOR_ERROR
   }
   | ArgVal {
-    $$ = new std::vector >();
+    $$ = new std::vector >();
     $$->push_back(*$1);
     delete $1;
     CHECK_FOR_ERROR
@@ -2002,13 +2027,18 @@
   }
   | ArgListH ',' DOTDOTDOT {
     $$ = $1;
-    $$->push_back(std::pair(new PATypeHolder(Type::VoidTy), 0));
+    TypeInfo TI;
+    TI.type = new PATypeHolder(Type::VoidTy);
+    TI.signedness = isSignless;
+    $$->push_back(std::pair(TI,(char*)0));
     CHECK_FOR_ERROR
   }
   | DOTDOTDOT {
-    $$ = new std::vector >();
-    $$->push_back(std::make_pair(new PATypeHolder(Type::VoidTy), (char*)0));
+    $$ = new std::vector >();
+    TypeInfo TI;
+    TI.type = new PATypeHolder(Type::VoidTy);
+    TI.signedness = isSignless;
+    $$->push_back(std::make_pair(TI, (char*)0));
     CHECK_FOR_ERROR
   }
   | /* empty */ {
@@ -2022,22 +2052,23 @@
   std::string FunctionName($3);
   free($3);  // Free strdup'd memory!
   
-  if (!(*$2)->isFirstClassType() && *$2 != Type::VoidTy)
+  if (!($2.type->get())->isFirstClassType() && $2.type->get() != Type::VoidTy)
     GEN_ERROR("LLVM functions cannot return aggregate types!");
 
   std::vector ParamTypeList;
   if ($5) {   // If there are arguments...
-    for (std::vector >::iterator I = $5->begin();
+    for (std::vector >::iterator I = $5->begin();
          I != $5->end(); ++I)
-      ParamTypeList.push_back(I->first->get());
+      ParamTypeList.push_back(I->first.type->get());
   }
 
   bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
   if (isVarArg) ParamTypeList.pop_back();
 
-  const FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg);
+  const FunctionType *FT = FunctionType::get($2.type->get(), ParamTypeList, 
+    isVarArg);
   const PointerType *PFT = PointerType::get(FT);
-  delete $2;
+  delete $2.type;
 
   ValID ID;
   if (!FunctionName.empty()) {
@@ -2091,21 +2122,19 @@
   // Add all of the arguments we parsed to the function...
   if ($5) {                     // Is null if empty...
     if (isVarArg) {  // Nuke the last entry
-      assert($5->back().first->get() == Type::VoidTy && $5->back().second == 0&&
-             "Not a varargs marker!");
-      delete $5->back().first;
+      assert($5->back().first.type->get() == Type::VoidTy && 
+             $5->back().second == 0 && "Not a varargs marker!");
+      delete $5->back().first.type;
       $5->pop_back();  // Delete the last entry
     }
     Function::arg_iterator ArgIt = Fn->arg_begin();
-    for (std::vector >::iterator I = $5->begin();
+    for (std::vector >::iterator I = $5->begin();
          I != $5->end(); ++I, ++ArgIt) {
-      delete I->first;                          // Delete the typeholder...
-
+      delete I->first.type;                     // Delete the typeholder...
       setValueName(ArgIt, I->second);           // Insert arg into symtab...
       CHECK_FOR_ERROR
       InsertValue(ArgIt);
     }
-
     delete $5;                     // We're now done with the argument list
   }
   CHECK_FOR_ERROR
@@ -2189,12 +2218,7 @@
     
     PackedType* pt = PackedType::get(ETy, NumElements);
     PATypeHolder* PTy = new PATypeHolder(
-                                         HandleUpRefs(
-                                            PackedType::get(
-                                                ETy, 
-                                                NumElements)
-                                            )
-                                         );
+       HandleUpRefs(PackedType::get( ETy, NumElements)));
     
     // Verify all elements are correct type!
     for (unsigned i = 0; i < $2->size(); i++) {
@@ -2243,7 +2267,7 @@
 // type immediately preceeds the value reference, and allows complex constant
 // pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
 ResolvedVal : Types ValueRef {
-    $$ = getVal(*$1, $2); delete $1;
+    $$ = getVal($1.type->get(), $2); delete $1.type;
     CHECK_FOR_ERROR
   };
 
@@ -2324,7 +2348,7 @@
     $$ = new BranchInst(tmpBBA, tmpBBB, tmpVal);
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
-    Value* tmpVal = getVal($2, $3);
+    Value* tmpVal = getVal($2.type->get(), $3);
     CHECK_FOR_ERROR
     BasicBlock* tmpBB = getBBVal($6);
     CHECK_FOR_ERROR
@@ -2343,7 +2367,7 @@
     CHECK_FOR_ERROR
   }
   | SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
-    Value* tmpVal = getVal($2, $3);
+    Value* tmpVal = getVal($2.type->get(), $3);
     CHECK_FOR_ERROR
     BasicBlock* tmpBB = getBBVal($6);
     CHECK_FOR_ERROR
@@ -2356,7 +2380,7 @@
     const PointerType *PFTy;
     const FunctionType *Ty;
 
-    if (!(PFTy = dyn_cast($3->get())) ||
+    if (!(PFTy = dyn_cast($3.type->get())) ||
         !(Ty = dyn_cast(PFTy->getElementType()))) {
       // Pull out the types of all of the arguments...
       std::vector ParamTypes;
@@ -2369,7 +2393,7 @@
       bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
       if (isVarArg) ParamTypes.pop_back();
 
-      Ty = FunctionType::get($3->get(), ParamTypes, isVarArg);
+      Ty = FunctionType::get($3.type->get(), ParamTypes, isVarArg);
       PFTy = PointerType::get(Ty);
     }
 
@@ -2403,7 +2427,7 @@
     }
     cast($$)->setCallingConv($2);
   
-    delete $3;
+    delete $3.type;
     delete $6;
     CHECK_FOR_ERROR
   }
@@ -2420,7 +2444,7 @@
 
 JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
     $$ = $1;
-    Constant *V = cast(getValNonImprovising($2, $3));
+    Constant *V = cast(getValNonImprovising($2.type->get(), $3));
     CHECK_FOR_ERROR
     if (V == 0)
       GEN_ERROR("May only switch on a constant pool value!");
@@ -2431,7 +2455,7 @@
   }
   | IntType ConstValueRef ',' LABEL ValueRef {
     $$ = new std::vector >();
-    Constant *V = cast(getValNonImprovising($1, $2));
+    Constant *V = cast(getValNonImprovising($1.type->get(), $2));
     CHECK_FOR_ERROR
 
     if (V == 0)
@@ -2453,12 +2477,12 @@
 
 PHIList : Types '[' ValueRef ',' ValueRef ']' {    // Used for PHI nodes
     $$ = new std::list >();
-    Value* tmpVal = getVal(*$1, $3);
+    Value* tmpVal = getVal($1.type->get(), $3);
     CHECK_FOR_ERROR
     BasicBlock* tmpBB = getBBVal($5);
     CHECK_FOR_ERROR
     $$->push_back(std::make_pair(tmpVal, tmpBB));
-    delete $1;
+    delete $1.type;
   }
   | PHIList ',' '[' ValueRef ',' ValueRef ']' {
     $$ = $1;
@@ -2493,55 +2517,55 @@
   };
 
 InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
-    if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint() && 
-        !isa((*$2).get()))
+    if (!$2.type->get()->isInteger() && !$2.type->get()->isFloatingPoint() && 
+        !isa($2.type->get()))
       GEN_ERROR(
         "Arithmetic operator requires integer, FP, or packed operands!");
-    if (isa((*$2).get()) && 
+    if (isa($2.type->get()) && 
         ($1.opcode == Instruction::URem || 
          $1.opcode == Instruction::SRem ||
          $1.opcode == Instruction::FRem))
       GEN_ERROR("U/S/FRem not supported on packed types!");
     // Upgrade the opcode from obsolete versions before we do anything with it.
-    sanitizeOpCode($1,*$2);
+    sanitizeOpCode($1,$2.type->get());
     CHECK_FOR_ERROR;
-    Value* val1 = getVal(*$2, $3); 
+    Value* val1 = getVal($2.type->get(), $3); 
     CHECK_FOR_ERROR
-    Value* val2 = getVal(*$2, $5);
+    Value* val2 = getVal($2.type->get(), $5);
     CHECK_FOR_ERROR
     $$ = BinaryOperator::create($1.opcode, val1, val2);
     if ($$ == 0)
       GEN_ERROR("binary operator returned null!");
-    delete $2;
+    delete $2.type;
   }
   | LogicalOps Types ValueRef ',' ValueRef {
-    if (!(*$2)->isIntegral()) {
-      if (!isa($2->get()) ||
-          !cast($2->get())->getElementType()->isIntegral())
+    if (!$2.type->get()->isIntegral()) {
+      if (!isa($2.type->get()) ||
+          !cast($2.type->get())->getElementType()->isIntegral())
         GEN_ERROR("Logical operator requires integral operands!");
     }
-    Value* tmpVal1 = getVal(*$2, $3);
+    Value* tmpVal1 = getVal($2.type->get(), $3);
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*$2, $5);
+    Value* tmpVal2 = getVal($2.type->get(), $5);
     CHECK_FOR_ERROR
     $$ = BinaryOperator::create($1.opcode, tmpVal1, tmpVal2);
     if ($$ == 0)
       GEN_ERROR("binary operator returned null!");
-    delete $2;
+    delete $2.type;
   }
   | SetCondOps Types ValueRef ',' ValueRef {
-    if(isa((*$2).get())) {
+    if(isa($2.type->get())) {
       GEN_ERROR(
         "PackedTypes currently not supported in setcc instructions!");
     }
-    Value* tmpVal1 = getVal(*$2, $3);
+    Value* tmpVal1 = getVal($2.type->get(), $3);
     CHECK_FOR_ERROR
-    Value* tmpVal2 = getVal(*$2, $5);
+    Value* tmpVal2 = getVal($2.type->get(), $5);
     CHECK_FOR_ERROR
     $$ = new SetCondInst($1.opcode, tmpVal1, tmpVal2);
     if ($$ == 0)
       GEN_ERROR("binary operator returned null!");
-    delete $2;
+    delete $2.type;
   }
   | NOT ResolvedVal {
     std::cerr << "WARNING: Use of eliminated 'not' instruction:"
@@ -2568,11 +2592,11 @@
     CHECK_FOR_ERROR
   }
   | CAST ResolvedVal TO Types {
-    if (!$4->get()->isFirstClassType())
+    if (!$4.type->get()->isFirstClassType())
       GEN_ERROR("cast instruction to a non-primitive type: '" +
-                     $4->get()->getDescription() + "'!");
-    $$ = new CastInst($2, *$4);
-    delete $4;
+                     $4.type->get()->getDescription() + "'!");
+    $$ = new CastInst($2, $4.type->get());
+    delete $4.type;
     CHECK_FOR_ERROR
   }
   | SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
@@ -2585,8 +2609,8 @@
   }
   | VAARG ResolvedVal ',' Types {
     NewVarArgs = true;
-    $$ = new VAArgInst($2, *$4);
-    delete $4;
+    $$ = new VAArgInst($2, $4.type->get());
+    delete $4.type;
     CHECK_FOR_ERROR
   }
   | VAARG_old ResolvedVal ',' Types {
@@ -2605,8 +2629,8 @@
     CallInst* bar = new CallInst(NF, $2);
     CurBB->getInstList().push_back(bar);
     CurBB->getInstList().push_back(new StoreInst(bar, foo));
-    $$ = new VAArgInst(foo, *$4);
-    delete $4;
+    $$ = new VAArgInst(foo, $4.type->get());
+    delete $4.type;
     CHECK_FOR_ERROR
   }
   | VANEXT_old ResolvedVal ',' Types {
@@ -2626,10 +2650,10 @@
     CallInst* bar = new CallInst(NF, $2);
     CurBB->getInstList().push_back(bar);
     CurBB->getInstList().push_back(new StoreInst(bar, foo));
-    Instruction* tmp = new VAArgInst(foo, *$4);
+    Instruction* tmp = new VAArgInst(foo, $4.type->get());
     CurBB->getInstList().push_back(tmp);
     $$ = new LoadInst(foo);
-    delete $4;
+    delete $4.type;
     CHECK_FOR_ERROR
   }
   | EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
@@ -2669,7 +2693,7 @@
     const PointerType *PFTy = 0;
     const FunctionType *Ty = 0;
 
-    if (!(PFTy = dyn_cast($3->get())) ||
+    if (!(PFTy = dyn_cast($3.type->get())) ||
         !(Ty = dyn_cast(PFTy->getElementType()))) {
       // Pull out the types of all of the arguments...
       std::vector ParamTypes;
@@ -2682,10 +2706,11 @@
       bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
       if (isVarArg) ParamTypes.pop_back();
 
-      if (!(*$3)->isFirstClassType() && *$3 != Type::VoidTy)
+      if (!$3.type->get()->isFirstClassType() && 
+           $3.type->get() != Type::VoidTy)
         GEN_ERROR("LLVM functions cannot return aggregate types!");
 
-      Ty = FunctionType::get($3->get(), ParamTypes, isVarArg);
+      Ty = FunctionType::get($3.type->get(), ParamTypes, isVarArg);
       PFTy = PointerType::get(Ty);
     }
 
@@ -2720,7 +2745,7 @@
     }
     cast($$)->setTailCall($1);
     cast($$)->setCallingConv($2);
-    delete $3;
+    delete $3.type;
     delete $6;
     CHECK_FOR_ERROR
   }
@@ -2751,26 +2776,26 @@
 
 
 MemoryInst : MALLOC Types OptCAlign {
-    $$ = new MallocInst(*$2, 0, $3);
-    delete $2;
+    $$ = new MallocInst($2.type->get(), 0, $3);
+    delete $2.type;
     CHECK_FOR_ERROR
   }
   | MALLOC Types ',' UINT ValueRef OptCAlign {
-    Value* tmpVal = getVal($4, $5);
+    Value* tmpVal = getVal($4.type->get(), $5);
     CHECK_FOR_ERROR
-    $$ = new MallocInst(*$2, tmpVal, $6);
-    delete $2;
+    $$ = new MallocInst($2.type->get(), tmpVal, $6);
+    delete $2.type;
   }
   | ALLOCA Types OptCAlign {
-    $$ = new AllocaInst(*$2, 0, $3);
-    delete $2;
+    $$ = new AllocaInst($2.type->get(), 0, $3);
+    delete $2.type;
     CHECK_FOR_ERROR
   }
   | ALLOCA Types ',' UINT ValueRef OptCAlign {
-    Value* tmpVal = getVal($4, $5);
+    Value* tmpVal = getVal($4.type->get(), $5);
     CHECK_FOR_ERROR
-    $$ = new AllocaInst(*$2, tmpVal, $6);
-    delete $2;
+    $$ = new AllocaInst($2.type->get(), tmpVal, $6);
+    delete $2.type;
   }
   | FREE ResolvedVal {
     if (!isa($2->getType()))
@@ -2781,54 +2806,54 @@
   }
 
   | OptVolatile LOAD Types ValueRef {
-    if (!isa($3->get()))
+    if (!isa($3.type->get()))
       GEN_ERROR("Can't load from nonpointer type: " +
-                     (*$3)->getDescription());
-    if (!cast($3->get())->getElementType()->isFirstClassType())
+                     $3.type->get()->getDescription());
+    if (!cast($3.type->get())->getElementType()->isFirstClassType())
       GEN_ERROR("Can't load from pointer of non-first-class type: " +
-                     (*$3)->getDescription());
-    Value* tmpVal = getVal(*$3, $4);
+                     $3.type->get()->getDescription());
+    Value* tmpVal = getVal($3.type->get(), $4);
     CHECK_FOR_ERROR
     $$ = new LoadInst(tmpVal, "", $1);
-    delete $3;
+    delete $3.type;
   }
   | OptVolatile STORE ResolvedVal ',' Types ValueRef {
-    const PointerType *PT = dyn_cast($5->get());
+    const PointerType *PT = dyn_cast($5.type->get());
     if (!PT)
       GEN_ERROR("Can't store to a nonpointer type: " +
-                     (*$5)->getDescription());
+                     ($5.type->get())->getDescription());
     const Type *ElTy = PT->getElementType();
     if (ElTy != $3->getType())
       GEN_ERROR("Can't store '" + $3->getType()->getDescription() +
                      "' into space of type '" + ElTy->getDescription() + "'!");
 
-    Value* tmpVal = getVal(*$5, $6);
+    Value* tmpVal = getVal($5.type->get(), $6);
     CHECK_FOR_ERROR
     $$ = new StoreInst($3, tmpVal, $1);
-    delete $5;
+    delete $5.type;
   }
   | GETELEMENTPTR Types ValueRef IndexList {
-    if (!isa($2->get()))
+    if (!isa($2.type->get()))
       GEN_ERROR("getelementptr insn requires pointer operand!");
 
     // LLVM 1.2 and earlier used ubyte struct indices.  Convert any ubyte struct
     // indices to uint struct indices for compatibility.
     generic_gep_type_iterator::iterator>
-      GTI = gep_type_begin($2->get(), $4->begin(), $4->end()),
-      GTE = gep_type_end($2->get(), $4->begin(), $4->end());
+      GTI = gep_type_begin($2.type->get(), $4->begin(), $4->end()),
+      GTE = gep_type_end($2.type->get(), $4->begin(), $4->end());
     for (unsigned i = 0, e = $4->size(); i != e && GTI != GTE; ++i, ++GTI)
       if (isa(*GTI))        // Only change struct indices
         if (ConstantInt *CUI = dyn_cast((*$4)[i]))
           if (CUI->getType() == Type::UByteTy)
             (*$4)[i] = ConstantExpr::getCast(CUI, Type::UIntTy);
 
-    if (!GetElementPtrInst::getIndexedType(*$2, *$4, true))
+    if (!GetElementPtrInst::getIndexedType($2.type->get(), *$4, true))
       GEN_ERROR("Invalid getelementptr indices for type '" +
-                     (*$2)->getDescription()+ "'!");
-    Value* tmpVal = getVal(*$2, $3);
+                     $2.type->get()->getDescription()+ "'!");
+    Value* tmpVal = getVal($2.type->get(), $3);
     CHECK_FOR_ERROR
     $$ = new GetElementPtrInst(tmpVal, *$4);
-    delete $2; 
+    delete $2.type; 
     delete $4;
   };
 





From reid at x10sys.com  Sun Nov 19 19:22:53 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Nov 2006 19:22:53 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/Support/InstVisitor.h
Message-ID: <200611200122.kAK1Mr0c012777@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm/Support:

InstVisitor.h updated: 1.41 -> 1.42
---
Log message:

For PR950: http://llvm.org/PR950 :
First in a series of patches to convert SetCondInst into ICmpInst and 
FCmpInst using only two opcodes and having the instructions contain their
predicate value. Nothing uses these classes yet. More patches to follow.


---
Diffs of the changes:  (+3 -0)

 InstVisitor.h |    3 +++
 1 files changed, 3 insertions(+)


Index: llvm/include/llvm/Support/InstVisitor.h
diff -u llvm/include/llvm/Support/InstVisitor.h:1.41 llvm/include/llvm/Support/InstVisitor.h:1.42
--- llvm/include/llvm/Support/InstVisitor.h:1.41	Mon Oct  9 13:33:08 2006
+++ llvm/include/llvm/Support/InstVisitor.h	Sun Nov 19 19:22:35 2006
@@ -169,6 +169,8 @@
   RetTy visitUnwindInst(UnwindInst &I)              { DELEGATE(TerminatorInst);}
   RetTy visitUnreachableInst(UnreachableInst &I)    { DELEGATE(TerminatorInst);}
   RetTy visitSetCondInst(SetCondInst &I)            { DELEGATE(BinaryOperator);}
+  RetTy visitICmpInst(ICmpInst &I)                  { DELEGATE(CmpInst);}
+  RetTy visitFCmpInst(FCmpInst &I)                  { DELEGATE(CmpInst);}
   RetTy visitMallocInst(MallocInst &I)              { DELEGATE(AllocationInst);}
   RetTy visitAllocaInst(AllocaInst &I)              { DELEGATE(AllocationInst);}
   RetTy visitFreeInst(FreeInst     &I)              { DELEGATE(Instruction); }
@@ -192,6 +194,7 @@
   RetTy visitTerminatorInst(TerminatorInst &I) { DELEGATE(Instruction); }
   RetTy visitBinaryOperator(BinaryOperator &I) { DELEGATE(Instruction); }
   RetTy visitAllocationInst(AllocationInst &I) { DELEGATE(Instruction); }
+  RetTy visitCmpInst(CmpInst &I)               { DELEGATE(Instruction); }
 
   // If the user wants a 'default' case, they can choose to override this
   // function.  If this function is not overloaded in the users subclass, then





From reid at x10sys.com  Sun Nov 19 19:22:56 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Nov 2006 19:22:56 -0600
Subject: [llvm-commits] CVS: llvm/lib/VMCore/Instruction.cpp
	Instructions.cpp Verifier.cpp
Message-ID: <200611200122.kAK1MtpG012786@zion.cs.uiuc.edu>



Changes in directory llvm/lib/VMCore:

Instruction.cpp updated: 1.57 -> 1.58
Instructions.cpp updated: 1.46 -> 1.47
Verifier.cpp updated: 1.165 -> 1.166
---
Log message:

For PR950: http://llvm.org/PR950 :
First in a series of patches to convert SetCondInst into ICmpInst and 
FCmpInst using only two opcodes and having the instructions contain their
predicate value. Nothing uses these classes yet. More patches to follow.


---
Diffs of the changes:  (+226 -1)

 Instruction.cpp  |    2 
 Instructions.cpp |  196 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Verifier.cpp     |   29 ++++++++
 3 files changed, 226 insertions(+), 1 deletion(-)


Index: llvm/lib/VMCore/Instruction.cpp
diff -u llvm/lib/VMCore/Instruction.cpp:1.57 llvm/lib/VMCore/Instruction.cpp:1.58
--- llvm/lib/VMCore/Instruction.cpp:1.57	Wed Nov  8 00:47:33 2006
+++ llvm/lib/VMCore/Instruction.cpp	Sun Nov 19 19:22:35 2006
@@ -11,10 +11,10 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Type.h"
 #include "llvm/Instructions.h"
 #include "llvm/Function.h"
 #include "llvm/SymbolTable.h"
-#include "llvm/Type.h"
 #include "llvm/Support/LeakDetector.h"
 using namespace llvm;
 


Index: llvm/lib/VMCore/Instructions.cpp
diff -u llvm/lib/VMCore/Instructions.cpp:1.46 llvm/lib/VMCore/Instructions.cpp:1.47
--- llvm/lib/VMCore/Instructions.cpp:1.46	Wed Nov  8 00:47:33 2006
+++ llvm/lib/VMCore/Instructions.cpp	Sun Nov 19 19:22:35 2006
@@ -1290,6 +1290,197 @@
   }
 }
 
+
+//===----------------------------------------------------------------------===//
+//                               CmpInst Classes
+//===----------------------------------------------------------------------===//
+
+CmpInst::CmpInst(OtherOps op, unsigned short predicate, Value *LHS, Value *RHS,
+                 const std::string &Name, Instruction *InsertBefore)
+  : Instruction(Type::BoolTy, op, Ops, 2, Name, InsertBefore) {
+    Ops[0].init(LHS, this);
+    Ops[1].init(RHS, this);
+  SubclassData = predicate;
+  if (op == Instruction::ICmp) {
+    assert(predicate >= ICmpInst::FIRST_ICMP_PREDICATE &&
+           predicate <= ICmpInst::LAST_ICMP_PREDICATE &&
+           "Invalid ICmp predicate value");
+    const Type* Op0Ty = getOperand(0)->getType();
+    const Type* Op1Ty = getOperand(1)->getType();
+    assert(Op0Ty == Op1Ty &&
+           "Both operands to ICmp instruction are not of the same type!");
+    // Check that the operands are the right type
+    assert(Op0Ty->isIntegral() || Op0Ty->getTypeID() == Type::PointerTyID ||
+           (isa(Op0Ty) && 
+            cast(Op0Ty)->getElementType()->isIntegral()) &&
+           "Invalid operand types for ICmp instruction");
+    return;
+  }
+  assert(op == Instruction::FCmp && "Invalid CmpInst opcode");
+  assert(predicate <= FCmpInst::LAST_FCMP_PREDICATE &&
+         "Invalid FCmp predicate value");
+  const Type* Op0Ty = getOperand(0)->getType();
+  const Type* Op1Ty = getOperand(1)->getType();
+  assert(Op0Ty == Op1Ty &&
+         "Both operands to FCmp instruction are not of the same type!");
+  // Check that the operands are the right type
+  assert(Op0Ty->isFloatingPoint() || (isa(Op0Ty) &&
+         cast(Op0Ty)->getElementType()->isFloatingPoint()) &&
+         "Invalid operand types for FCmp instruction");
+}
+  
+CmpInst::CmpInst(OtherOps op, unsigned short predicate, Value *LHS, Value *RHS,
+                 const std::string &Name, BasicBlock *InsertAtEnd)
+  : Instruction(Type::BoolTy, op, Ops, 2, Name, InsertAtEnd) {
+  Ops[0].init(LHS, this);
+  Ops[1].init(RHS, this);
+  SubclassData = predicate;
+  if (op == Instruction::ICmp) {
+    assert(predicate >= ICmpInst::FIRST_ICMP_PREDICATE &&
+           predicate <= ICmpInst::LAST_ICMP_PREDICATE &&
+           "Invalid ICmp predicate value");
+
+    const Type* Op0Ty = getOperand(0)->getType();
+    const Type* Op1Ty = getOperand(1)->getType();
+    assert(Op0Ty == Op1Ty &&
+          "Both operands to ICmp instruction are not of the same type!");
+    // Check that the operands are the right type
+    assert(Op0Ty->isIntegral() || Op0Ty->getTypeID() == Type::PointerTyID ||
+           (isa(Op0Ty) && 
+            cast(Op0Ty)->getElementType()->isIntegral()) &&
+           "Invalid operand types for ICmp instruction");
+    return;
+  }
+  assert(op == Instruction::FCmp && "Invalid CmpInst opcode");
+  assert(predicate <= FCmpInst::LAST_FCMP_PREDICATE &&
+         "Invalid FCmp predicate value");
+  const Type* Op0Ty = getOperand(0)->getType();
+  const Type* Op1Ty = getOperand(1)->getType();
+  assert(Op0Ty == Op1Ty &&
+          "Both operands to FCmp instruction are not of the same type!");
+  // Check that the operands are the right type
+  assert(Op0Ty->isFloatingPoint() || (isa(Op0Ty) &&
+         cast(Op0Ty)->getElementType()->isFloatingPoint()) &&
+        "Invalid operand types for FCmp instruction");
+}
+
+CmpInst *
+CmpInst::create(OtherOps Op, unsigned short predicate, Value *S1, Value *S2, 
+                const std::string &Name, Instruction *InsertBefore) {
+  if (Op == Instruction::ICmp) {
+    return new ICmpInst(ICmpInst::Predicate(predicate), S1, S2, Name, 
+                        InsertBefore);
+  }
+  return new FCmpInst(FCmpInst::Predicate(predicate), S1, S2, Name, 
+                      InsertBefore);
+}
+
+CmpInst *
+CmpInst::create(OtherOps Op, unsigned short predicate, Value *S1, Value *S2, 
+                const std::string &Name, BasicBlock *InsertAtEnd) {
+  if (Op == Instruction::ICmp) {
+    return new ICmpInst(ICmpInst::Predicate(predicate), S1, S2, Name, 
+                        InsertAtEnd);
+  }
+  return new FCmpInst(FCmpInst::Predicate(predicate), S1, S2, Name, 
+                      InsertAtEnd);
+}
+
+void CmpInst::swapOperands() {
+  if (ICmpInst *IC = dyn_cast(this))
+    IC->swapOperands();
+  else
+    cast(this)->swapOperands();
+}
+
+bool CmpInst::isCommutative() {
+  if (ICmpInst *IC = dyn_cast(this))
+    return IC->isCommutative();
+  return cast(this)->isCommutative();
+}
+
+bool CmpInst::isEquality() {
+  if (ICmpInst *IC = dyn_cast(this))
+    return IC->isEquality();
+  return cast(this)->isEquality();
+}
+
+
+ICmpInst::Predicate ICmpInst::getInversePredicate(Predicate pred) {
+  switch (pred) {
+    default:
+      assert(!"Unknown icmp predicate!");
+    case ICMP_EQ: return ICMP_NE;
+    case ICMP_NE: return ICMP_EQ;
+    case ICMP_UGT: return ICMP_ULE;
+    case ICMP_ULT: return ICMP_UGE;
+    case ICMP_UGE: return ICMP_ULT;
+    case ICMP_ULE: return ICMP_UGT;
+    case ICMP_SGT: return ICMP_SLE;
+    case ICMP_SLT: return ICMP_SGE;
+    case ICMP_SGE: return ICMP_SLT;
+    case ICMP_SLE: return ICMP_SGT;
+  }
+}
+
+ICmpInst::Predicate ICmpInst::getSwappedPredicate(Predicate pred) {
+  switch (pred) {
+    default: assert(! "Unknown setcc instruction!");
+    case ICMP_EQ: case ICMP_NE:
+      return pred;
+    case ICMP_SGT: return ICMP_SLT;
+    case ICMP_SLT: return ICMP_SGT;
+    case ICMP_SGE: return ICMP_SLE;
+    case ICMP_SLE: return ICMP_SGE;
+    case ICMP_UGT: return ICMP_ULT;
+    case ICMP_ULT: return ICMP_UGT;
+    case ICMP_UGE: return ICMP_ULE;
+    case ICMP_ULE: return ICMP_UGE;
+  }
+}
+
+FCmpInst::Predicate FCmpInst::getInversePredicate(Predicate pred) {
+  switch (pred) {
+    default:
+      assert(!"Unknown icmp predicate!");
+    case FCMP_OEQ: return FCMP_UNE;
+    case FCMP_ONE: return FCMP_UEQ;
+    case FCMP_OGT: return FCMP_ULE;
+    case FCMP_OLT: return FCMP_UGE;
+    case FCMP_OGE: return FCMP_ULT;
+    case FCMP_OLE: return FCMP_UGT;
+    case FCMP_UEQ: return FCMP_ONE;
+    case FCMP_UNE: return FCMP_OEQ;
+    case FCMP_UGT: return FCMP_OLE;
+    case FCMP_ULT: return FCMP_OGE;
+    case FCMP_UGE: return FCMP_OLT;
+    case FCMP_ULE: return FCMP_OGT;
+    case FCMP_ORD: return FCMP_UNO;
+    case FCMP_UNO: return FCMP_ORD;
+    case FCMP_TRUE: return FCMP_FALSE;
+    case FCMP_FALSE: return FCMP_TRUE;
+  }
+}
+
+FCmpInst::Predicate FCmpInst::getSwappedPredicate(Predicate pred) {
+  switch (pred) {
+    default: assert(!"Unknown setcc instruction!");
+    case FCMP_FALSE: case FCMP_TRUE:
+    case FCMP_OEQ: case FCMP_ONE:
+    case FCMP_UEQ: case FCMP_UNE:
+    case FCMP_ORD: case FCMP_UNO:
+      return pred;
+    case FCMP_OGT: return FCMP_OLT;
+    case FCMP_OLT: return FCMP_OGT;
+    case FCMP_OGE: return FCMP_OLE;
+    case FCMP_OLE: return FCMP_OGE;
+    case FCMP_UGT: return FCMP_ULT;
+    case FCMP_ULT: return FCMP_UGT;
+    case FCMP_UGE: return FCMP_ULE;
+    case FCMP_ULE: return FCMP_UGE;
+  }
+}
+
 //===----------------------------------------------------------------------===//
 //                        SwitchInst Implementation
 //===----------------------------------------------------------------------===//
@@ -1412,6 +1603,11 @@
   return create(getOpcode(), Ops[0], Ops[1]);
 }
 
+CmpInst* CmpInst::clone() const {
+  return create(Instruction::OtherOps(getOpcode()), getPredicate(), 
+                Ops[0], Ops[1]);
+}
+
 MallocInst *MallocInst::clone() const { return new MallocInst(*this); }
 AllocaInst *AllocaInst::clone() const { return new AllocaInst(*this); }
 FreeInst   *FreeInst::clone()   const { return new FreeInst(getOperand(0)); }


Index: llvm/lib/VMCore/Verifier.cpp
diff -u llvm/lib/VMCore/Verifier.cpp:1.165 llvm/lib/VMCore/Verifier.cpp:1.166
--- llvm/lib/VMCore/Verifier.cpp:1.165	Fri Oct 20 02:07:24 2006
+++ llvm/lib/VMCore/Verifier.cpp	Sun Nov 19 19:22:35 2006
@@ -179,6 +179,8 @@
     void visitBasicBlock(BasicBlock &BB);
     void visitPHINode(PHINode &PN);
     void visitBinaryOperator(BinaryOperator &B);
+    void visitICmpInst(ICmpInst &IC);
+    void visitFCmpInst(FCmpInst &FC);
     void visitShiftInst(ShiftInst &SI);
     void visitExtractElementInst(ExtractElementInst &EI);
     void visitInsertElementInst(InsertElementInst &EI);
@@ -551,6 +553,33 @@
   visitInstruction(B);
 }
 
+void Verifier::visitICmpInst(ICmpInst& IC) {
+  // Check that the operands are the same type
+  const Type* Op0Ty = IC.getOperand(0)->getType();
+  const Type* Op1Ty = IC.getOperand(1)->getType();
+  Assert1(Op0Ty == Op1Ty,
+          "Both operands to ICmp instruction are not of the same type!", &IC);
+  // Check that the operands are the right type
+  Assert1(Op0Ty->isIntegral() || Op0Ty->getTypeID() == Type::PointerTyID ||
+          (isa(Op0Ty) && 
+           cast(Op0Ty)->getElementType()->isIntegral()),
+          "Invalid operand types for ICmp instruction", &IC);
+  visitInstruction(IC);
+}
+
+void Verifier::visitFCmpInst(FCmpInst& FC) {
+  // Check that the operands are the same type
+  const Type* Op0Ty = FC.getOperand(0)->getType();
+  const Type* Op1Ty = FC.getOperand(1)->getType();
+  Assert1(Op0Ty == Op1Ty,
+          "Both operands to FCmp instruction are not of the same type!", &FC);
+  // Check that the operands are the right type
+  Assert1(Op0Ty->isFloatingPoint() || (isa(Op0Ty) &&
+           cast(Op0Ty)->getElementType()->isFloatingPoint()),
+          "Invalid operand types for FCmp instruction", &FC);
+  visitInstruction(FC);
+}
+
 void Verifier::visitShiftInst(ShiftInst &SI) {
   Assert1(SI.getType()->isInteger(),
           "Shift must return an integer result!", &SI);





From reid at x10sys.com  Sun Nov 19 19:22:56 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Nov 2006 19:22:56 -0600
Subject: [llvm-commits] CVS: llvm/include/llvm/InstrTypes.h Instruction.def
	Instructions.h
Message-ID: <200611200122.kAK1Mu9l012795@zion.cs.uiuc.edu>



Changes in directory llvm/include/llvm:

InstrTypes.h updated: 1.47 -> 1.48
Instruction.def updated: 1.24 -> 1.25
Instructions.h updated: 1.45 -> 1.46
---
Log message:

For PR950: http://llvm.org/PR950 :
First in a series of patches to convert SetCondInst into ICmpInst and 
FCmpInst using only two opcodes and having the instructions contain their
predicate value. Nothing uses these classes yet. More patches to follow.


---
Diffs of the changes:  (+334 -14)

 InstrTypes.h    |   85 ++++++++++++++++++++
 Instruction.def |   30 +++----
 Instructions.h  |  233 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 334 insertions(+), 14 deletions(-)


Index: llvm/include/llvm/InstrTypes.h
diff -u llvm/include/llvm/InstrTypes.h:1.47 llvm/include/llvm/InstrTypes.h:1.48
--- llvm/include/llvm/InstrTypes.h:1.47	Sun Sep 17 14:29:56 2006
+++ llvm/include/llvm/InstrTypes.h	Sun Nov 19 19:22:35 2006
@@ -243,6 +243,91 @@
   }
 };
 
+//===----------------------------------------------------------------------===//
+//                               CmpInst Class
+//===----------------------------------------------------------------------===//
+
+/// This class is the base class for the comparison instructions. 
+/// @brief Abstract base class of comparison instructions.
+class CmpInst: public Instruction {
+  CmpInst(); // do not implement
+protected:
+  CmpInst(Instruction::OtherOps op, unsigned short pred, Value *LHS, Value *RHS,
+          const std::string &Name = "", Instruction *InsertBefore = 0);
+  
+  CmpInst(Instruction::OtherOps op, unsigned short pred, Value *LHS, Value *RHS,
+          const std::string &Name, BasicBlock *InsertAtEnd);
+
+  Use Ops[2]; // CmpInst instructions always have 2 operands, optimize
+
+public:
+  /// Construct a compare instruction, given the opcode, the predicate and 
+  /// the two operands.  Optionally (if InstBefore is specified) insert the 
+  /// instruction into a BasicBlock right before the specified instruction.  
+  /// The specified Instruction is allowed to be a dereferenced end iterator.
+  /// @brief Create a CmpInst
+  static CmpInst *create(OtherOps Op, unsigned short predicate, Value *S1, 
+                         Value *S2, const std::string &Name = "",
+                         Instruction *InsertBefore = 0);
+
+  /// Construct a compare instruction, given the opcode, the predicate and the 
+  /// two operands.  Also automatically insert this instruction to the end of 
+  /// the BasicBlock specified.
+  /// @brief Create a CmpInst
+  static CmpInst *create(OtherOps Op, unsigned short predicate, Value *S1, 
+                         Value *S2, const std::string &Name, 
+                         BasicBlock *InsertAtEnd);
+
+  /// @brief Implement superclass method.
+  virtual CmpInst *clone() const;
+
+  /// The predicate for CmpInst is defined by the subclasses but stored in 
+  /// the SubclassData field (see Value.h).  We allow it to be fetched here
+  /// as the predicate but there is no enum type for it, just the raw unsigned 
+  /// short. This facilitates comparison of CmpInst instances without delving
+  /// into the subclasses since predicate values are distinct between the
+  /// CmpInst subclasses.
+  /// @brief Return the predicate for this instruction.
+  unsigned short getPredicate() const {
+    return SubclassData;
+  }
+
+  /// @brief Provide more efficient getOperand methods.
+  Value *getOperand(unsigned i) const {
+    assert(i < 2 && "getOperand() out of range!");
+    return Ops[i];
+  }
+  void setOperand(unsigned i, Value *Val) {
+    assert(i < 2 && "setOperand() out of range!");
+    Ops[i] = Val;
+  }
+
+  /// @brief CmpInst instructions always have 2 operands.
+  unsigned getNumOperands() const { return 2; }
+
+  /// This is just a convenience that dispatches to the subclasses.
+  /// @brief Swap the operands.
+  void swapOperands();
+
+  /// This is just a convenience that dispatches to the subclasses.
+  /// @brief Determine if this CmpInst is commutative.
+  bool isCommutative();
+
+  /// This is just a convenience that dispatches to the subclasses.
+  /// @brief Determine if this is an equals/not equals predicate.
+  bool isEquality();
+
+  /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const CmpInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::ICmp || 
+           I->getOpcode() == Instruction::FCmp;
+  }
+  static inline bool classof(const Value *V) {
+    return isa(V) && classof(cast(V));
+  }
+};
+
 } // End llvm namespace
 
 #endif


Index: llvm/include/llvm/Instruction.def
diff -u llvm/include/llvm/Instruction.def:1.24 llvm/include/llvm/Instruction.def:1.25
--- llvm/include/llvm/Instruction.def:1.24	Sat Nov 11 17:06:47 2006
+++ llvm/include/llvm/Instruction.def	Sun Nov 19 19:22:35 2006
@@ -126,20 +126,22 @@
 
 // Other operators...
  FIRST_OTHER_INST(31)
-HANDLE_OTHER_INST(31, PHI    , PHINode    )  // PHI node instruction
-HANDLE_OTHER_INST(32, Cast   , CastInst   )  // Type cast
-HANDLE_OTHER_INST(33, Call   , CallInst   )  // Call a function
-HANDLE_OTHER_INST(34, Shl    , ShiftInst  )  // Shift Left operations (logical)
-HANDLE_OTHER_INST(35, LShr   , ShiftInst  )  // Logical Shift right (unsigned) 
-HANDLE_OTHER_INST(36, AShr   , ShiftInst  )  // Arithmetic shift right (signed)
-HANDLE_OTHER_INST(37, Select , SelectInst )  // select instruction
-HANDLE_OTHER_INST(38, UserOp1, Instruction)  // May be used internally in a pass
-HANDLE_OTHER_INST(39, UserOp2, Instruction)  // Internal to passes only
-HANDLE_OTHER_INST(40, VAArg  , VAArgInst  )  // vaarg instruction
-HANDLE_OTHER_INST(41, ExtractElement, ExtractElementInst)// extract from vector.
-HANDLE_OTHER_INST(42, InsertElement, InsertElementInst)  // insert into vector
-HANDLE_OTHER_INST(43, ShuffleVector, ShuffleVectorInst)  // shuffle two vectors.
-  LAST_OTHER_INST(43)
+HANDLE_OTHER_INST(31, ICmp   , ICmpInst   )  // Integer comparison instruction
+HANDLE_OTHER_INST(32, FCmp   , FCmpInst   )  // Floating point comparison instr.
+HANDLE_OTHER_INST(33, PHI    , PHINode    )  // PHI node instruction
+HANDLE_OTHER_INST(34, Cast   , CastInst   )  // Type cast
+HANDLE_OTHER_INST(35, Call   , CallInst   )  // Call a function
+HANDLE_OTHER_INST(36, Shl    , ShiftInst  )  // Shift Left operations (logical)
+HANDLE_OTHER_INST(37, LShr   , ShiftInst  )  // Logical Shift right (unsigned) 
+HANDLE_OTHER_INST(38, AShr   , ShiftInst  )  // Arithmetic shift right (signed)
+HANDLE_OTHER_INST(39, Select , SelectInst )  // select instruction
+HANDLE_OTHER_INST(40, UserOp1, Instruction)  // May be used internally in a pass
+HANDLE_OTHER_INST(41, UserOp2, Instruction)  // Internal to passes only
+HANDLE_OTHER_INST(42, VAArg  , VAArgInst  )  // vaarg instruction
+HANDLE_OTHER_INST(43, ExtractElement, ExtractElementInst)// extract from vector.
+HANDLE_OTHER_INST(44, InsertElement, InsertElementInst)  // insert into vector
+HANDLE_OTHER_INST(45, ShuffleVector, ShuffleVectorInst)  // shuffle two vectors.
+  LAST_OTHER_INST(45)
 
 #undef  FIRST_TERM_INST
 #undef HANDLE_TERM_INST


Index: llvm/include/llvm/Instructions.h
diff -u llvm/include/llvm/Instructions.h:1.45 llvm/include/llvm/Instructions.h:1.46
--- llvm/include/llvm/Instructions.h:1.45	Wed Nov  8 00:47:32 2006
+++ llvm/include/llvm/Instructions.h	Sun Nov 19 19:22:35 2006
@@ -415,6 +415,239 @@
 };
 
 //===----------------------------------------------------------------------===//
+//                               ICmpInst Class
+//===----------------------------------------------------------------------===//
+
+/// This instruction compares its operands according to the predicate given
+/// to the constructor. It only operates on integers, pointers, or packed 
+/// vectors of integrals. The two operands must be the same type.
+/// @brief Represent an integer comparison operator.
+class ICmpInst: public CmpInst {
+public:
+  /// This enumeration lists the possible predicates for the ICmpInst. The
+  /// values in the range 0-31 are reserved for FCmpInst while values in the
+  /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
+  /// predicate values are not overlapping between the classes.
+  enum Predicate {
+    ICMP_EQ  = 32,    ///< equal
+    ICMP_NE  = 33,    ///< not equal
+    ICMP_UGT = 34,    ///< unsigned greater than
+    ICMP_UGE = 35,    ///< unsigned greater or equal
+    ICMP_ULT = 36,    ///< unsigned less than
+    ICMP_ULE = 37,    ///< unsigned less or equal
+    ICMP_SGT = 38,    ///< signed greater than
+    ICMP_SGE = 39,    ///< signed greater or equal
+    ICMP_SLT = 40,    ///< signed less than
+    ICMP_SLE = 41,    ///< signed less or equal
+    FIRST_ICMP_PREDICATE = ICMP_EQ,
+    LAST_ICMP_PREDICATE = ICMP_SLE
+  };
+
+  /// @brief Constructor with insert-before-instruction semantics.
+  ICmpInst(
+    Predicate pred,  ///< The predicate to use for the comparison
+    Value *LHS,      ///< The left-hand-side of the expression
+    Value *RHS,      ///< The right-hand-side of the expression
+    const std::string &Name = "",  ///< Name of the instruction
+    Instruction *InsertBefore = 0  ///< Where to insert
+  ) : CmpInst(Instruction::ICmp, pred, LHS, RHS, Name, InsertBefore) {
+  }
+
+  /// @brief Constructor with insert-at-block-end semantics.
+  ICmpInst(
+    Predicate pred, ///< The predicate to use for the comparison
+    Value *LHS,     ///< The left-hand-side of the expression
+    Value *RHS,     ///< The right-hand-side of the expression
+    const std::string &Name,  ///< Name of the instruction
+    BasicBlock *InsertAtEnd   ///< Block to insert into.
+  ) : CmpInst(Instruction::ICmp, pred, LHS, RHS, Name, InsertAtEnd) {
+  }
+
+  /// @brief Return the predicate for this instruction.
+  Predicate getPredicate() const { return Predicate(SubclassData); }
+
+  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, etc.
+  /// @returns the inverse predicate for the instruction's current predicate. 
+  /// @brief Return the inverse of the instruction's predicate.
+  Predicate getInversePredicate() const {
+    return getInversePredicate(getPredicate());
+  }
+
+  /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE, etc.
+  /// @returns the inverse predicate for predicate provided in \p pred. 
+  /// @brief Return the inverse of a given predicate
+  static Predicate getInversePredicate(Predicate pred);
+
+  /// For example, EQ->EQ, SLE->SGE, ULT->UGT, etc.
+  /// @returns the predicate that would be the result of exchanging the two 
+  /// operands of the ICmpInst instruction without changing the result 
+  /// produced.  
+  /// @brief Return the predicate as if the operands were swapped
+  Predicate getSwappedPredicate() const {
+    return getSwappedPredicate(getPredicate());
+  }
+
+  /// This is a static version that you can use without an instruction 
+  /// available.
+  /// @brief Return the predicate as if the operands were swapped.
+  static Predicate getSwappedPredicate(Predicate Opcode);
+
+  /// This also tests for commutativity. If isEquality() returns true then
+  /// the predicate is also commutative. Only the equality predicates are
+  /// commutative.
+  /// @returns true if the predicate of this instruction is EQ or NE.
+  /// @brief Determine if this is an equality predicate.
+  bool isEquality() const {
+    return SubclassData == ICMP_EQ || SubclassData == ICMP_NE;
+  }
+  bool isCommutative() const { return isEquality(); }
+
+  /// @returns true if the predicate is relational (not EQ or NE). 
+  /// @brief Determine if this a relational predicate.
+  bool isRelational() const {
+    return !isEquality();
+  }
+
+  /// Exchange the two operands to this instruction in such a way that it does
+  /// not modify the semantics of the instruction. The predicate value may be
+  /// changed to retain the same result if the predicate is order dependent
+  /// (e.g. ult). 
+  /// @brief Swap operands and adjust predicate.
+  void swapOperands() {
+    SubclassData = getSwappedPredicate();
+    std::swap(Ops[0], Ops[1]);
+  }
+
+  // Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const ICmpInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::ICmp;
+  }
+  static inline bool classof(const Value *V) {
+    return isa(V) && classof(cast(V));
+  }
+};
+
+//===----------------------------------------------------------------------===//
+//                               FCmpInst Class
+//===----------------------------------------------------------------------===//
+
+/// This instruction compares its operands according to the predicate given
+/// to the constructor. It only operates on floating point values or packed     
+/// vectors of floating point values. The operands must be identical types.
+/// @brief Represents a floating point comparison operator.
+class FCmpInst: public CmpInst {
+public:
+  /// This enumeration lists the possible predicates for the FCmpInst. Values
+  /// in the range 0-31 are reserved for FCmpInst.
+  enum Predicate {
+    // Opcode        U L G E    Intuitive operation
+    FCMP_FALSE = 0, ///<  0 0 0 0    Always false (always folded)
+    FCMP_OEQ   = 1, ///<  0 0 0 1    True if ordered and equal
+    FCMP_OGT   = 2, ///<  0 0 1 0    True if ordered and greater than
+    FCMP_OGE   = 3, ///<  0 0 1 1    True if ordered and greater than or equal
+    FCMP_OLT   = 4, ///<  0 1 0 0    True if ordered and less than
+    FCMP_OLE   = 5, ///<  0 1 0 1    True if ordered and less than or equal
+    FCMP_ONE   = 6, ///<  0 1 1 0    True if ordered and operands are unequal
+    FCMP_ORD   = 7, ///<  0 1 1 1    True if ordered (no nans)
+    FCMP_UNO   = 8, ///<  1 0 0 0    True if unordered: isnan(X) | isnan(Y)
+    FCMP_UEQ   = 9, ///<  1 0 0 1    True if unordered or equal
+    FCMP_UGT   =10, ///<  1 0 1 0    True if unordered or greater than
+    FCMP_UGE   =11, ///<  1 0 1 1    True if unordered, greater than, or equal
+    FCMP_ULT   =12, ///<  1 1 0 0    True if unordered or less than
+    FCMP_ULE   =13, ///<  1 1 0 1    True if unordered, less than, or equal
+    FCMP_UNE   =14, ///<  1 1 1 0    True if unordered or not equal
+    FCMP_TRUE  =15, ///<  1 1 1 1    Always true (always folded)
+    FIRST_FCMP_PREDICATE = FCMP_FALSE,
+    LAST_FCMP_PREDICATE = FCMP_TRUE
+  };
+
+  /// @brief Constructor with insert-before-instruction semantics.
+  FCmpInst(
+    Predicate pred,  ///< The predicate to use for the comparison
+    Value *LHS,      ///< The left-hand-side of the expression
+    Value *RHS,      ///< The right-hand-side of the expression
+    const std::string &Name = "",  ///< Name of the instruction
+    Instruction *InsertBefore = 0  ///< Where to insert
+  ) : CmpInst(Instruction::FCmp, pred, LHS, RHS, Name, InsertBefore) {
+  }
+
+  /// @brief Constructor with insert-at-block-end semantics.
+  FCmpInst(
+    Predicate pred, ///< The predicate to use for the comparison
+    Value *LHS,     ///< The left-hand-side of the expression
+    Value *RHS,     ///< The right-hand-side of the expression
+    const std::string &Name,  ///< Name of the instruction
+    BasicBlock *InsertAtEnd   ///< Block to insert into.
+  ) : CmpInst(Instruction::FCmp, pred, LHS, RHS, Name, InsertAtEnd) {
+  }
+
+  /// @brief Return the predicate for this instruction.
+  Predicate getPredicate() const { return Predicate(SubclassData); }
+
+  /// For example, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
+  /// @returns the inverse predicate for the instructions current predicate. 
+  /// @brief Return the inverse of the predicate
+  Predicate getInversePredicate() const {
+    return getInversePredicate(getPredicate());
+  }
+
+  /// For example, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
+  /// @returns the inverse predicate for \p pred.
+  /// @brief Return the inverse of a given predicate
+  static Predicate getInversePredicate(Predicate pred);
+
+  /// For example, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
+  /// @returns the predicate that would be the result of exchanging the two 
+  /// operands of the ICmpInst instruction without changing the result 
+  /// produced.  
+  /// @brief Return the predicate as if the operands were swapped
+  Predicate getSwappedPredicate() const {
+    return getSwappedPredicate(getPredicate());
+  }
+
+  /// This is a static version that you can use without an instruction 
+  /// available.
+  /// @brief Return the predicate as if the operands were swapped.
+  static Predicate getSwappedPredicate(Predicate Opcode);
+
+  /// This also tests for commutativity. If isEquality() returns true then
+  /// the predicate is also commutative. Only the equality predicates are
+  /// commutative.
+  /// @returns true if the predicate of this instruction is EQ or NE.
+  /// @brief Determine if this is an equality predicate.
+  bool isEquality() const {
+    return SubclassData == FCMP_OEQ || SubclassData == FCMP_ONE ||
+           SubclassData == FCMP_UEQ || SubclassData == FCMP_UNE;
+  }
+  bool isCommutative() const { return isEquality(); }
+
+  /// @returns true if the predicate is relational (not EQ or NE). 
+  /// @brief Determine if this a relational predicate.
+  bool isRelational() const { return !isEquality(); }
+
+  /// Exchange the two operands to this instruction in such a way that it does
+  /// not modify the semantics of the instruction. The predicate value may be
+  /// changed to retain the same result if the predicate is order dependent
+  /// (e.g. ult). 
+  /// @brief Swap operands and adjust predicate.
+  void swapOperands() {
+    SubclassData = getSwappedPredicate();
+    std::swap(Ops[0], Ops[1]);
+  }
+
+  /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const FCmpInst *) { return true; }
+  static inline bool classof(const Instruction *I) {
+    return I->getOpcode() == Instruction::FCmp;
+  }
+  static inline bool classof(const Value *V) {
+    return isa(V) && classof(cast(V));
+  }
+};
+
+
+//===----------------------------------------------------------------------===//
 //                            SetCondInst Class
 //===----------------------------------------------------------------------===//
 





From reid at x10sys.com  Sun Nov 19 19:22:56 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Nov 2006 19:22:56 -0600
Subject: [llvm-commits] CVS: llvm/lib/Analysis/ValueNumbering.cpp
Message-ID: <200611200122.kAK1MuQV012800@zion.cs.uiuc.edu>



Changes in directory llvm/lib/Analysis:

ValueNumbering.cpp updated: 1.21 -> 1.22
---
Log message:

For PR950: http://llvm.org/PR950 :
First in a series of patches to convert SetCondInst into ICmpInst and 
FCmpInst using only two opcodes and having the instructions contain their
predicate value. Nothing uses these classes yet. More patches to follow.


---
Diffs of the changes:  (+23 -0)

 ValueNumbering.cpp |   23 +++++++++++++++++++++++
 1 files changed, 23 insertions(+)


Index: llvm/lib/Analysis/ValueNumbering.cpp
diff -u llvm/lib/Analysis/ValueNumbering.cpp:1.21 llvm/lib/Analysis/ValueNumbering.cpp:1.22
--- llvm/lib/Analysis/ValueNumbering.cpp:1.21	Sun Aug 27 19:42:29 2006
+++ llvm/lib/Analysis/ValueNumbering.cpp	Sun Nov 19 19:22:35 2006
@@ -75,6 +75,7 @@
 
     void visitCastInst(CastInst &I);
     void visitGetElementPtrInst(GetElementPtrInst &I);
+    void visitCmpInst(CmpInst &I);
 
     void handleBinaryInst(Instruction &I);
     void visitBinaryOperator(Instruction &I)     { handleBinaryInst(I); }
@@ -124,6 +125,28 @@
       }
 }
 
+void  BVNImpl::visitCmpInst(CmpInst &CI1) {
+  Value *LHS = CI1.getOperand(0);
+  for (Value::use_iterator UI = LHS->use_begin(), UE = LHS->use_end();
+       UI != UE; ++UI)
+    if (CmpInst *CI2 = dyn_cast(*UI))
+      // Check to see if this compare instruction is not CI, but same opcode,
+      // same predicate, and in the same function.
+      if (CI2 != &CI1 && CI2->getOpcode() == CI1.getOpcode() &&
+          CI2->getPredicate() == CI1.getPredicate() &&
+          CI2->getParent()->getParent() == CI1.getParent()->getParent())
+        // If the operands are the same
+        if ((CI2->getOperand(0) == CI1.getOperand(0) &&
+            CI2->getOperand(1) == CI1.getOperand(1)) ||
+            // Or the compare is commutative and the operands are reversed 
+            (CI1.isCommutative() && 
+             CI2->getOperand(0) == CI1.getOperand(1) &&
+             CI2->getOperand(1) == CI1.getOperand(0)))
+          // Then the instructiosn are identical, add to list.
+          RetVals.push_back(CI2);
+}
+
+
 
 // isIdenticalBinaryInst - Return true if the two binary instructions are
 // identical.





From reid at x10sys.com  Sun Nov 19 19:22:52 2006
From: reid at x10sys.com (Reid Spencer)
Date: Sun, 19 Nov 2006 19:22:52 -0600
Subject: [llvm-commits] CVS:
	llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
Message-ID: <200611200122.kAK1MqZX012772@zion.cs.uiuc.edu>



Changes in directory llvm/lib/CodeGen/SelectionDAG:

SelectionDAGISel.cpp updated: 1.318 -> 1.319
---
Log message:

For PR950: http://llvm.org/PR950 :
First in a series of patches to convert SetCondInst into ICmpInst and 
FCmpInst using only two opcodes and having the instructions contain their
predicate value. Nothing uses these classes yet. More patches to follow.


---
Diffs of the changes:  (+56 -0)

 SelectionDAGISel.cpp |   56 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 56 insertions(+)


Index: llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
diff -u llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.318 llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.319
--- llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp:1.318	Wed Nov 15 11:51:15 2006
+++ llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp	Sun Nov 19 19:22:35 2006
@@ -541,6 +541,8 @@
   void visitShl(User &I) { visitShift(I, ISD::SHL); }
   void visitLShr(User &I) { visitShift(I, ISD::SRL); }
   void visitAShr(User &I) { visitShift(I, ISD::SRA); }
+  void visitICmp(User &I);
+  void visitFCmp(User &I);
   void visitSetCC(User &I, ISD::CondCode SignedOpc, ISD::CondCode UnsignedOpc,
                   ISD::CondCode FPOpc);
   void visitSetEQ(User &I) { visitSetCC(I, ISD::SETEQ, ISD::SETEQ, 
@@ -1442,6 +1444,60 @@
   setValue(&I, DAG.getNode(Opcode, Op1.getValueType(), Op1, Op2));
 }
 
+void SelectionDAGLowering::visitICmp(User &I) {
+  ICmpInst *IC = cast(&I);
+  SDOperand Op1 = getValue(IC->getOperand(0));
+  SDOperand Op2 = getValue(IC->getOperand(1));
+  ISD::CondCode Opcode;
+  switch (IC->getPredicate()) {
+    case ICmpInst::ICMP_EQ  : Opcode = ISD::SETEQ; break;
+    case ICmpInst::ICMP_NE  : Opcode = ISD::SETNE; break;
+    case ICmpInst::ICMP_UGT : Opcode = ISD::SETUGT; break;
+    case ICmpInst::ICMP_UGE : Opcode = ISD::SETUGE; break;
+    case ICmpInst::ICMP_ULT : Opcode = ISD::SETULT; break;
+    case ICmpInst::ICMP_ULE : Opcode = ISD::SETULE; break;
+    case ICmpInst::ICMP_SGT : Opcode = ISD::SETGT; break;
+    case ICmpInst::ICMP_SGE : Opcode = ISD::SETGE; break;
+    case ICmpInst::ICMP_SLT : Opcode = ISD::SETLT; break;
+    case ICmpInst::ICMP_SLE : Opcode = ISD::SETLE; break;
+    default:
+      assert(!"Invalid ICmp predicate value");
+      Opcode = ISD::SETEQ;
+      break;
+  }
+  setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode));
+}
+
+void SelectionDAGLowering::visitFCmp(User &I) {
+  FCmpInst *FC = cast(&I);
+  SDOperand Op1 = getValue(FC->getOperand(0));
+  SDOperand Op2 = getValue(FC->getOperand(1));
+  ISD::CondCode Opcode;
+  switch (FC->getPredicate()) {
+    case FCmpInst::FCMP_FALSE : Opcode = ISD::SETFALSE;
+    case FCmpInst::FCMP_OEQ   : Opcode = ISD::SETOEQ;
+    case FCmpInst::FCMP_OGT   : Opcode = ISD::SETOGT;
+    case FCmpInst::FCMP_OGE   : Opcode = ISD::SETOGE;
+    case FCmpInst::FCMP_OLT   : Opcode = ISD::SETOLT;
+    case FCmpInst::FCMP_OLE   : Opcode = ISD::SETOLE;
+    case FCmpInst::FCMP_ONE   : Opcode = ISD::SETONE;
+    case FCmpInst::FCMP_ORD   : Opcode = ISD::SETO;
+    case FCmpInst::FCMP_UNO   : Opcode = ISD::SETUO;
+    case FCmpInst::FCMP_UEQ   : Opcode = ISD::SETUEQ;
+    case FCmpInst::FCMP_UGT   : Opcode = ISD::SETUGT;
+    case FCmpInst::FCMP_UGE   : Opcode = ISD::SETUGE;
+    case FCmpInst::FCMP_ULT   : Opcode = ISD::SETULT;
+    case FCmpInst::FCMP_ULE   : Opcode = ISD::SETULE;
+    case FCmpInst::FCMP_UNE   : Opcode = ISD::SETUNE;
+    case FCmpInst::FCMP_TRUE  : Opcode = ISD::SETTRUE;
+    default:
+      assert(!"Invalid FCmp predicate value");
+      Opcode = ISD::SETFALSE;
+      break;
+  }
+  setValue(&I, DAG.getSetCC(MVT::i1, Op1, Op2, Opcode));
+}
+
 void SelectionDAGLowering::visitSetCC(User &I,ISD::CondCode SignedOpcode,
                                       ISD::CondCode UnsignedOpcode,
                                       ISD::CondCode FPOpcode) {





From tonic at nondot.org  Sun Nov 19 23:20:52 2006
From: tonic at nondot.org (Tanya Lattner)
Date: Sun, 19 Nov 2006 23:20:52 -0600
Subject: [llvm-commits] [release_19] CVS: llvm/docs/ReleaseNotes.html
Message-ID: <200611200520.kAK5KqQM016187@zion.cs.uiuc.edu>



Changes in directory llvm/docs:

ReleaseNotes.html updated: 1.363 -> 1.363.2.1
---
Log message:

Merging from mainline


---
Diffs of the changes:  (+263 -232)

 ReleaseNotes.html |  495 ++++++++++++++++++++++++++++--------------------------
 1 files changed, 263 insertions(+), 232 deletions(-)


Index: llvm/docs/ReleaseNotes.html
diff -u llvm/docs/ReleaseNotes.html:1.363 llvm/docs/ReleaseNotes.html:1.363.2.1
--- llvm/docs/ReleaseNotes.html:1.363	Wed Nov  1 10:15:04 2006
+++ llvm/docs/ReleaseNotes.html	Sun Nov 19 23:20:40 2006
@@ -62,7 +62,8 @@
 
 
 This is the tenth public release of the LLVM Compiler Infrastructure. This
-release incorporates a large number of enhancements and new features.
+release incorporates a large number of enhancements, new features, and bug
+fixes.  We recommend that all users of previous LLVM versions upgrade.
 
 
 
@@ -73,41 +74,106 @@
 
 
 
-DWARF debugging 
-support for X86/ELF
+New X86-64 Backend
 
-The llvm-gcc4 C front-end now generates debugging info for C and C++ for
-X86/ELF platforms (Linux).  This extends the PPC/Darwin and X86/Darwin debugging
-support available in release 18.8 DWARF is a standard debugging format used on 
-many platforms.
+LLVM 1.9 now fully supports the x86-64 instruction set on Mac OS/X, and
+supports it on Linux (and other operating systems) when compiling in -static
+mode. LLVM includes JIT support for X86-64, and supports both Intel EMT-64T
+and AMD-64 architectures.  The X86-64 instruction set permits addressing a
+64-bit addressing space and provides the compiler with twice the
+number of integer registers to use.
 
 
 
-Signed Instructions
+Link-Time Optimization integration
+with native linkers
 
-As a step towards making LLVM's integer types signless, several new
-instructions have been added to LLVM. The DIV instruction has become UDIV, SDIV,
-and FDIV.  The REM instruction has become UREM, SREM and FREM. The SHR
-instruction has become ASHR and LSHR. See the Language
-  Reference for details on these new instructions.
+LLVM now includes liblto which can
+be used to integrate LLVM Link-Time Optimization support into a native linker.
+This allows LLVM .bc to transparently participate with linking an application,
+even when some .o files are in LLVM form and some are not.
 
 
 
-New Feature C
+DWARF debugging 
+support for Linux, Cygwin and MinGW on X86
 
-Describe feature C here.
+llvm-gcc4 now supports generating debugging info for Linux, Cygwin and MinGW.
+This extends the PPC/Darwin and X86/Darwin debugging support available in the
+1.8 release. DWARF is a standard debugging format used on many platforms.
 
 
 
-New Feature D
+Optimizer
+Improvements
 
-Describe feature D here.
+The mid-level optimizer is now faster and produces better code in many cases.
+  Significant changes include:
+
+
+LLVM includes a new 'predicate simplifier' pass, which
+    currently performs dominator tree-based optimizations.
+The complete loop unroll pass now supports unrolling of
+     multiple basic block loops.
+The 'globalopt' pass can now perform the scalar replacement of
+    aggregates transformation on some heap allocations.
+The globalsmodref-aa alias analysis can now track 'indirect pointer
+     globals' more accurately.
+The instruction combiner can now perform element propagation  
+analysis of vector expressions, eliminating computation of vector elements
+that are not used.
+
+  
 
 
 
-New Feature E
+Code
+Generator Enhancements
+
 
-Describe feature E here.
+
+The LLVM Target-Independent code generator now supports more target features and
+optimizes many cases more aggressively.  New features include:
+
+
+
+LLVM now includes a late branch folding pass which optimizes code
+    layout, performs several branch optzns, and deletes unreachable code.
+The code generator now support targets that have pre/post-increment
+    addressing modes.
+LLVM now supports dynamically-loadable register allocators and
+     schedulers.
+LLVM 1.9 includes several improvements to inline asm support,
+    including support for new constraints and modifiers.
+The register coalescer is now more aggressive than before,  
+     allowing it to eliminate more copies.
+
+
+In addition, the LLVM target description format has itself been extended in
+ several ways:
+ 
+
+tblgen now allows definition of 'multiclasses' which can be
+     used to factor instruction patterns more aggressively in .td files.
+LLVM has a new TargetAsmInfo class which captures a variety of
+     information about the target assembly language format.
+.td files now support "${:foo}" syntax for encoding 
+     subtarget-specific assembler syntax into instruction descriptions.
+
+
+Further, several significant target-specific enhancements are included in
+LLVM 1.9:
+
+
+The LLVM ARM backend now supports more instructions
+    and the use of a frame pointer.  It is now possible to build  
+   libgcc and a simple cross compiler, but it is not considered "complete" yet.
+   
+LLVM supports the Win32 dllimport/dllexport linkage and
+     stdcall/fastcall calling conventions.
+
+
 
 
 
@@ -121,38 +187,41 @@
 More specific changes include:
 
 
-LLVM 1.8 includes an initial ARM backend.  This backend is in early 
-    development stages.
-LLVM 1.8 now includes significantly better support for mingw and 
-    cygwin.
-The llvm-config tool is 
-    now built by default and has several new features.
-The X86 and PPC backends now use the correct platform ABI for passing 
-    vectors as arguments to functions.
-The X86 backend now includes support for the Microsoft ML assembler 
-    ("MASM").
-The PowerPC backend now pattern matches the 'rlwimi' instruction more 
-    aggressively.
-Most of LLVM is now built with "-pedantic", ensuring better portability 
-    to more C++ Compilers.
-The PowerPC backend now includes initial 64-bit support.  The JIT is not
-    complete, and the static compiler has a couple of known bugs, but support
-    is mostly in place. LLVM 1.9 will include completed PPC-64 support. 
-
+The llvm-test framework now supports SPEC2006.
+LLVM now includes a FAQ about the
+getelementptr instruction.
+Bugpoint now supports a new "-find-bugs" mode.  This mode makes
+    bugpoint permute pass sequences to try to expose bugs due to pass
+    sequencing.
+The JIT now supports lazily streaming code from multiple modules at a
+     time, implicitly linking the code as it goes.
 
 
 
 
 
-Significant Changes in LLVM 1.8
+Significant API Changes in LLVM 1.9
 
 
 
+
+Several significant API changes have been made.  If you are maintaining
+out-of-tree code, please be aware that:
+
 
-The LLVM "SparcV9" backend (deprecated in LLVM 1.7) has been removed in 
-LLVM 1.8.  The LLVM "Sparc" backend replaces it.
-The --version option now prints more useful information, including the
-    build configuration for the tool.
+The ConstantSInt and ConstantUInt classes have been merged into the
+ ConstantInt class.
+As a step towards making LLVM's integer types signless, several new
+instructions have been added to LLVM. The Div instruction is now 
+UDiv, SDiv, and FDiv.  The Rem instruction
+is now URem, SRem and FRem. See the
+Language Reference for details on these new
+instructions.
+
ConstantBool::True and ConstantBool::False have been
+      renamed to ConstantBool::getTrue() and
+      ConstantBool::getFalse().
+The 'analyze' tool has been merged into the 'opt' tool.
+
 
 
 
@@ -174,7 +243,8 @@
 Sun UltraSPARC workstations running Solaris 8.
 Intel and AMD machines running on Win32 with the Cygwin libraries (limited
     support is available for native builds with Visual C++).
-PowerPC and X86-based Mac OS X systems, running 10.2 and above.
+PowerPC and X86-based Mac OS X systems, running 10.2 and above in 32-bit and
+    64-bit modes.
 Alpha-based machines running Debian GNU/Linux.
 Itanium-based machines running Linux and HP-UX.
 
@@ -220,6 +290,7 @@
 The -cee pass is known to be buggy, and may be removed in in a 
     future release.
 The IA64 code generator is experimental.
+The ARM code generator is experimental.
 The Alpha JIT is experimental.
 "-filetype=asm" (the default) is the only supported value for the 
     -filetype llc option.
@@ -229,16 +300,138 @@
 
 
 
-  Known problems with the Build System
+  Known problems with the X86 back-end
 
 
 
 
 
-none yet
+The X86 backend does not yet support inline
+    assembly that uses the X86 floating point stack.  See the bug for details on workarounds on
+    Linux.
 
+
 
 
+
+
+  Known problems with the PowerPC back-end
+
+
+
+
+
+PowerPC backend does not correctly
+implement ordered FP comparisons.
+The 64-bit PowerPC backend is not fully stable. If you desire PPC64 support,
+    please use mainline CVS LLVM, which has several important bug fixes.
+
+
+
+
+
+
+  Known problems with the SPARC back-end
+
+
+
+
+
+The SPARC backend only supports the 32-bit SPARC ABI (-m32), it does not
+    support the 64-bit SPARC ABI (-m64).
+
+
+
+
+
+
+  Known problems with the C back-end
+
+
+
+
+
+
+The C back-end produces code that violates the ANSI C Type-Based Alias
+Analysis rules.  As such, special options may be necessary to compile the code
+(for example, GCC requires the -fno-strict-aliasing option).  This
+problem probably cannot be fixed.
+
+Zero arg vararg functions are not 
+supported.  This should not affect LLVM produced by the C or C++ 
+frontends.
+
+The C backend does not correctly implement the llvm.stacksave or
+llvm.stackrestore 
+intrinsics.  This means that some code compiled by it can run out of stack
+space if they depend on these (e.g. C99 varargs).
+
+The C backend does not support inline
+    assembly code.
+
+
+
+
+
+
+  Known problems with the Alpha back-end
+
+
+
+
+
+
+On 21164s, some rare FP arithmetic sequences which may trap do not have the
+appropriate nops inserted to ensure restartability.
+
+
+
+
+
+
+  Known problems with the IA64 back-end
+
+
+
+
+
+
+C++ programs are likely to fail on IA64, as calls to setjmp are
+made where the argument is not 16-byte aligned, as required on IA64. (Strictly
+speaking this is not a bug in the IA64 back-end; it will also be encountered
+when building C++ programs using the C back-end.)
+
+The C++ front-end does not use IA64
+ABI compliant layout of v-tables.  In particular, it just stores function
+pointers instead of function descriptors in the vtable.  This bug prevents
+mixing C++ code compiled with LLVM with C++ objects compiled by other C++
+compilers.
+
+There are a few ABI violations which will lead to problems when mixing LLVM
+output with code built with other compilers, particularly for floating-point
+programs.
+
+Defining vararg functions is not supported (but calling them is ok).
+
+
+
+
+
+
+
+  Known problems with the ARM back-end
+
+
+
+
+
+The ARM backend is currently in early development stages, it is not 
+ready for production use.
+
+
+
 
 
 
@@ -264,29 +457,15 @@
 
 
 
-llvm-gcc3 has many significant problems that are fixed by llvm-gcc4.
-Two major ones include:
-
-
-With llvm-gcc3, 
-    C99 variable sized arrays do not release stack memory when they go out of 
-    scope.  Thus, the following program may run out of stack space:
--    for (i = 0; i != 1000000; ++i) {
-      int X[n];
-      foo(X);
-    }
-
-
-With llvm-gcc3, Initialization of global union variables can only be done with the largest union member.
-
-
 
 llvm-gcc4 is far more stable and produces better code than llvm-gcc3, but
-does not currently support Link-Time-Optimization or C++ Exception Handling,
+does not currently support Link-Time 
+Optimization or C++ Exception Handling,
 which llvm-gcc3 does.
 
+llvm-gcc4 does not support the GCC indirect
+goto extension, but llvm-gcc3 does.
+
 
 
 
@@ -302,28 +481,12 @@
 support for floating point data types of any size other than 32 and 64
 bits.
     
-The following Unix system functionality has not been tested and may not
-work:
-  
-  sigsetjmp, siglongjmp - These are not turned into the
-      appropriate invoke/unwind instructions.  Note that
-      setjmp and longjmp are compiled correctly.
-  
getcontext, setcontext, makecontext
-      - These functions have not been tested.
-  
-
 Although many GCC extensions are supported, some are not.  In particular,
     the following extensions are known to not be supported:
   
   Local Labels: Labels local to a block.
   Nested Functions: As in Algol and Pascal, lexical scoping of functions.
   Constructing Calls: Dispatching a call to another function.
-  Extended Asm: Assembler instructions with C expressions as operands.
-  Constraints: Constraints for asm operands.
-  Asm Labels: Specifying the assembler name to use for a C symbol.
-  Explicit Reg Vars: Defining variables residing in specified registers.
-  Vector Extensions: Using vector instructions through built-in functions.
-  Target Builtins:   Built-in functions specific to particular targets.
   Thread-Local: Per-thread variables.
   Pragmas: Pragmas accepted by GCC.
   
@@ -344,29 +507,31 @@
       Declaring that functions have no side effects or that they can never
       return.

 
-      Supported: format, format_arg, non_null,
-      noreturn, constructor, destructor,
-      unused, used,
-      deprecated, warn_unused_result, weak

+      Supported: constructor, destructor,
+      deprecated, fastcall, format, 
+      format_arg, non_null, noreturn, 
+      stdcall, unused, used, 
+      warn_unused_result, weak

 
       Ignored: noinline,
       always_inline, pure, const, nothrow,
       malloc, no_instrument_function, cdecl

 
       Unsupported: section, alias,
-      visibility, regparm, stdcall,
-      fastcall, all other target specific attributes
+      visibility, regparm, all other target specific 
+      attributes
    
   Variable Attributes:
       Specifying attributes of variables.

       Supported: cleanup, common, nocommon,
-                        deprecated, transparent_union,
+                        deprecated, dllimport, 
+                        dllexport,  transparent_union,
                         unused, used, weak

 
       Unsupported: aligned, mode, packed,
                         section, shared, tls_model,
-                        vector_size, dllimport, 
-                        dllexport, all target specific attributes.
+                        vector_size, all target specific attributes.
+  
 
   Type Attributes:	Specifying attributes of types.

       Supported: transparent_union, unused,
@@ -402,6 +567,12 @@
   
Empty Structures: Structures with no members.
   Variadic Macros: Macros with a variable number of arguments.
   Escaped Newlines:  Slightly looser rules for escaped newlines.
+  Extended Asm: Assembler instructions with C expressions as operands.
+  Constraints: Constraints for asm operands.
+  Asm Labels: Specifying the assembler name to use for a C symbol.
+  Explicit Reg Vars: Defining variables residing in specified registers.
+  Vector Extensions: Using vector instructions through built-in functions.
+  Target Builtins:   Built-in functions specific to particular targets.
   Subscripting: Any array can be subscripted, even if not an lvalue.
   Pointer Arith: Arithmetic on void-pointers and function pointers.
   Initializers: Non-constant initializers.
@@ -446,26 +617,13 @@
 
 
 
-Bugs
-
-
-
-
-The C++ front-end inherits all problems afflicting the C
-    front-end.
-
-
-
-
-
-
 
   Notes
 
 
 
-
 
+llvm-gcc4 does not support C++ exception handling at all yet.
 
 Destructors for local objects are not always run when a longjmp is
     performed. In particular, destructors for objects in the longjmping
@@ -480,7 +638,7 @@
     representation issues.  Because we use this API, code generated by the LLVM
     compilers should be binary compatible with machine code generated by other
     Itanium ABI C++ compilers (such as G++, the Intel and HP compilers, etc).
-    However, the exception handling mechanism used by LLVM is very
+    However, the exception handling mechanism used by llvm-gcc3 is very
     different from the model used in the Itanium ABI, so exceptions will not
     interact correctly. 
 
@@ -488,134 +646,7 @@
 
 
 
-
-
-  Known problems with the C back-end
-
-
-
-
-
-
-The C back-end produces code that violates the ANSI C Type-Based Alias
-Analysis rules.  As such, special options may be necessary to compile the code
-(for example, GCC requires the -fno-strict-aliasing option).  This
-problem probably cannot be fixed.
-
-Zero arg vararg functions are not 
-supported.  This should not affect LLVM produced by the C or C++ 
-frontends.
-
-The C backend does not correctly implement the llvm.stacksave or
-llvm.stackrestore 
-intrinsics.  This means that some code compiled by it can run out of stack
-space if they depend on these (e.g. C99 varargs).
-
-
-
-
-
-
-
-  Known problems with the X86 back-end
-
-
-
-
-
-none yet.
-
-
-
-
-
-
-  Known problems with the PowerPC back-end
-
-
-
-
-
-PowerPC backend does not correctly
-implement ordered FP comparisons.
-
-
-
-
-
-
-  Known problems with the Alpha back-end
-
-
-
-
-
-
-On 21164s, some rare FP arithmetic sequences which may trap do not have the
-appropriate nops inserted to ensure restartability.
-
-
-
-
-
-
-
-  Known problems with the IA64 back-end
-
-
-
-
-
-
-C++ programs are likely to fail on IA64, as calls to setjmp are
-made where the argument is not 16-byte aligned, as required on IA64. (Strictly
-speaking this is not a bug in the IA64 back-end; it will also be encountered
-when building C++ programs using the C back-end.)
-
-The C++ front-end does not use IA64
-ABI compliant layout of v-tables.  In particular, it just stores function
-pointers instead of function descriptors in the vtable.  This bug prevents
-mixing C++ code compiled with LLVM with C++ objects compiled by other C++
-compilers.
-
-There are a few ABI violations which will lead to problems when mixing LLVM
-output with code built with other compilers, particularly for floating-point
-programs.
-
-Defining vararg functions is not supported (but calling them is ok).
-
-
-
-
-
-
-
-  Known problems with the SPARC back-end
-
-
-
-
-
-The SPARC backend only supports the 32-bit SPARC ABI (-m32), it does not
-    support the 64-bit SPARC ABI (-m64).
-
-
-
-
-
-
-  Known problems with the ARM back-end
-
-
-
 
-
-The ARM backend is currently in early development stages, it is not 
-ready for production use.
-
-
-
 
 
 
@@ -650,7 +681,7 @@
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" />
 
   The LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/11/01 16:15:04 $
+  Last modified: $Date: 2006/11/20 05:20:40 $
 
 
 





From tonic at nondot.org  Sun Nov 19 23:52:19 2006
From: tonic at nondot.org (Tanya Lattner)
Date: Sun, 19 Nov 2006 23:52:19 -0600
Subject: [llvm-commits] CVS: llvm/docs/CFEBuildInstrs.html
Message-ID: <200611200552.kAK5qJpf016861@zion.cs.uiuc.edu>



Changes in directory llvm/docs:

CFEBuildInstrs.html updated: 1.60 -> 1.61
---
Log message:

Changing cfrontend dir to llvm-gcc3.4 as the example.


---
Diffs of the changes:  (+5 -5)

 CFEBuildInstrs.html |   10 +++++-----
 1 files changed, 5 insertions(+), 5 deletions(-)


Index: llvm/docs/CFEBuildInstrs.html
diff -u llvm/docs/CFEBuildInstrs.html:1.60 llvm/docs/CFEBuildInstrs.html:1.61
--- llvm/docs/CFEBuildInstrs.html:1.60	Thu Nov 16 03:31:19 2006
+++ llvm/docs/CFEBuildInstrs.html	Sun Nov 19 23:52:06 2006
@@ -211,8 +211,8 @@
 
   
 
-  Unpack the C/C++ front-end source into cfrontend/src, either by
-      untar'ing a cfrontend.source.tar.gz file or checking out CVS into this
+  
Unpack the C/C++ front-end source, either by
+      untar'ing/unzipping a tar.gz file or checking out CVS into this
       directory.
   Make "build" and "install" directories as siblings of the "src"
       tree:
@@ -221,7 +221,7 @@
 csh:
    % pwd
-  /usr/local/example/cfrontend/src
+  /usr/local/example/llvm-gcc3.4/src
   % cd ..
   % mkdir build install
   % set CFEINSTALL = `pwd`/install
@@ -229,7 +229,7 @@
 sh:
    % pwd
-  /usr/local/example/cfrontend/src
+  /usr/local/example/llvm-gcc3.4/src
   % cd ..
   % mkdir build install
   % export CFEINSTALL=`pwd`/install
@@ -432,7 +432,7 @@
 
   Brian Gaeke

   LLVM Compiler Infrastructure

-  Last modified: $Date: 2006/11/16 09:31:19 $
+  Last modified: $Date: 2006/11/20 05:52:06 $
 
 
 








Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Syntax:

Overview:

Arguments:

Semantics:

Example:

Example:

Example:

Semantics:

Example: