+; RUN: llvm-as < %s -o /dev/null -f
+
; This testcase failed due to a bad assertion in SymbolTable.cpp, removed in the 1.20 revision
; Basically the symbol table assumed that if there was an abstract type in the symbol table,
; [in this case for the entry %foo of type void(opaque)* ], that there should have also been
+; RUN: llvm-as < %s -o /dev/null -f
+
; This testcase used to fail due to a lack of this diff in Value.cpp:
; diff -r1.16 Value.cpp
; 11c11
+; RUN: llvm-as < %s -o /dev/null -f
+
%Hosp = type { int, int, int, { \2 *, { int, int, int, { [4 x \3], \2, \5, \6,
int, int } * } *, \2 * }, { \2 *, { int, int, int, { [4 x \3], \2, \5, \6, int,
int } * } *, \2 * }, { \2 *, { int, int, int, { [4 x \3], \2, \5, \6, int, int
+; RUN: llvm-as < %s -o /dev/null -f
+
; Method arguments were being checked for collisions at the global scope before
; the method object was created by the parser. Because of this, false collisions
; could occur that would cause the following error message to be produced:
+; RUN: llvm-as < %s -o /dev/null -f
+
; Another name collision problem. Here the problem was that if a forward
; declaration for a method was found, that this would cause spurious conflicts
; to be detected between locals and globals.
+; RUN: llvm-as < %s -o /dev/null -f
+
type { { \2 *, \4 ** },
{ \2 *, \4 ** }
}
-implementation
\ No newline at end of file
+implementation
+; RUN: llvm-as < %s -o /dev/null -f
+
%t = type { { \2*, \2 },
{ \2*, \2 }
}
-implementation
\ No newline at end of file
+implementation
+; RUN: llvm-as < %s -o /dev/null -f
+
%Hosp = type {
{ \2 *, { \2, \4 } * },
{ \2 *, { \2, \4 } * }
+; RUN: llvm-as < %s -o /dev/null -f
+
; It looks like the assembler is not forward resolving the function declaraion
; correctly.
+; RUN: llvm-as < %s -o /dev/null -f
+
; This should parse correctly without an 'implementation', but our current YACC
; based parser doesn't have the required 2 token lookahead...
; XFAIL: *
+; RUN: llvm-as < %s -o /dev/null -f
+
+; RUN: llvm-as < %s -o /dev/null -f
+
%.LC0 = internal global [12 x sbyte] c"hello world\00"
implementation ; Functions:
+; RUN: llvm-as < %s -o /dev/null -f
+
%.LC0 = internal global [12 x sbyte] c"hello world\00" ; <[12 x sbyte]*> [#uses=1]
implementation ; Functions:
+; RUN: llvm-as < %s -o /dev/null -f
+
; Dominance relationships is not calculated correctly for unreachable blocks,
; which causes the verifier to barf on this input.
+; RUN: llvm-as < %s -o /dev/null -f
+
; This testcase comes from the following really simple c file:
;
; int foo[30000];
+; RUN: llvm-as < %s -o /dev/null -f
+
declare int "ArrayRef"([100 x int] * %Array)
int "ArrayRef"([100 x int] * %Array) {
+; RUN: llvm-as < %s -o /dev/null -f
+
%X = external global %T*
+; RUN: llvm-as < %s -o /dev/null -f
+
%spell_order = global [4 x ubyte] c"\FF\00\F7\00"
+; RUN: llvm-as < %s -o /dev/null -f
+
%X = external global int
%X = constant int 7
+; RUN: llvm-as < %s -o /dev/null -f
+
; There should be absolutely no problem with this testcase.
implementation
+; RUN: llvm-as < %s -o /dev/null -f
+
void %test(int %X) {
+; RUN: llvm-as < %s -o /dev/null -f
+
; Test that shift instructions can be used in constant expressions.
global int shl (int 7, ubyte 19)
+; RUN: llvm-as < %s -o /dev/null -f
+
; The old C front-end never generated empty structures, now the new one
; can. For some reason we never handled them in the parser. Wierd.
+; RUN: llvm-as < %s -o /dev/null -f
+
%MidFnTy = type void (void (%MidFnTy* )*)
+; RUN: llvm-as < %s -o /dev/null -f
+
%T = type opaque
%X = global %T* null
+; RUN: llvm-as < %s -o /dev/null -f
+
; make sure that 'float' values have their value properly truncated.
global float 0x1
+; RUN: llvm-as < %s -o /dev/null -f
+
; %inc2 uses it's own value, but that's ok, as it's unreachable!
void %test() {
+; RUN: llvm-as < %s -o /dev/null -f
+
+; RUN: llvm-as < %s -o /dev/null -f
+
int %test(bool %C, int %V1, int %V2) {