mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 03:29:40 +00:00
5a70dd1d82
Similar to gep (r230786) and load (r230794) changes.
Similar migration script can be used to update test cases, which
successfully migrated all of LLVM and Polly, but about 4 test cases
needed manually changes in Clang.
(this script will read the contents of stdin and massage it into stdout
- wrap it in the 'apply.sh' script shown in previous commits + xargs to
apply it over a large set of test cases)
import fileinput
import sys
import re
rep = re.compile(r"(getelementptr(?:\s+inbounds)?\s*\()((<\d*\s+x\s+)?([^@]*?)(|\s*addrspace\(\d+\))\s*\*(?(3)>)\s*)(?=$|%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|zeroinitializer|<|\[\[[a-zA-Z]|\{\{)", re.MULTILINE | re.DOTALL)
def conv(match):
line = match.group(1)
line += match.group(4)
line += ", "
line += match.group(2)
return line
line = sys.stdin.read()
off = 0
for match in re.finditer(rep, line):
sys.stdout.write(line[off:match.start()])
sys.stdout.write(conv(match))
off = match.end()
sys.stdout.write(line[off:])
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232184 91177308-0d34-0410-b5e6-96231b3b80d8
214 lines
5.7 KiB
LLVM
214 lines
5.7 KiB
LLVM
|
|
; RUN: not llc < %s -march=xcore -code-model=medium 2>&1 | FileCheck %s -check-prefix=BAD_CM
|
|
; RUN: not llc < %s -march=xcore -code-model=kernel 2>&1 | FileCheck %s -check-prefix=BAD_CM
|
|
; BAD_CM: Target only supports CodeModel Small or Large
|
|
|
|
|
|
; RUN: llc < %s -march=xcore -code-model=default | FileCheck %s
|
|
; RUN: llc < %s -march=xcore -code-model=small | FileCheck %s
|
|
; RUN: llc < %s -march=xcore -code-model=large | FileCheck %s -check-prefix=LARGE
|
|
|
|
|
|
; CHECK-LABEL: test:
|
|
; CHECK: zext r0, 1
|
|
; CHECK: bt r0, [[JUMP:.LBB[0-9_]*]]
|
|
; CHECK: ldaw r0, dp[A2]
|
|
; CHECK: retsp 0
|
|
; CHECK: [[JUMP]]
|
|
; CHECK: ldaw r0, dp[A1]
|
|
; CHECK: retsp 0
|
|
; LARGE-LABEL: test:
|
|
; LARGE: zext r0, 1
|
|
; LARGE: ldaw r11, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE: mov r1, r11
|
|
; LARGE: ldaw r11, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE: bt r0, [[JUMP:.LBB[0-9_]*]]
|
|
; LARGE: mov r11, r1
|
|
; LARGE: [[JUMP]]
|
|
; LARGE: ldw r0, r11[0]
|
|
; LARGE: retsp 0
|
|
@A1 = external global [50000 x i32]
|
|
@A2 = external global [50000 x i32]
|
|
define [50000 x i32]* @test(i1 %bool) nounwind {
|
|
entry:
|
|
%Addr = select i1 %bool, [50000 x i32]* @A1, [50000 x i32]* @A2
|
|
ret [50000 x i32]* %Addr
|
|
}
|
|
|
|
|
|
; CHECK: .section .cp.rodata.cst4,"aMc",@progbits,4
|
|
; CHECK: .long 65536
|
|
; CHECK: .text
|
|
; CHECK-LABEL: f:
|
|
; CHECK: ldc r1, 65532
|
|
; CHECK: add r1, r0, r1
|
|
; CHECK: ldw r1, r1[0]
|
|
; CHECK: ldw r2, cp[.LCPI{{[0-9_]*}}]
|
|
; CHECK: add r0, r0, r2
|
|
; CHECK: ldw r0, r0[0]
|
|
; CHECK: add r0, r1, r0
|
|
; CHECK: ldw r1, dp[l]
|
|
; CHECK: add r0, r0, r1
|
|
; CHECK: ldw r1, dp[l+4]
|
|
; CHECK: add r0, r0, r1
|
|
; CHECK: ldw r1, dp[l+392]
|
|
; CHECK: add r0, r0, r1
|
|
; CHECK: ldw r1, dp[l+396]
|
|
; CHECK: add r0, r0, r1
|
|
; CHECK: ldw r1, dp[s]
|
|
; CHECK: add r0, r0, r1
|
|
; CHECK: ldw r1, dp[s+36]
|
|
; CHECK: add r0, r0, r1
|
|
; CHECK: retsp 0
|
|
;
|
|
; LARGE: .section .cp.rodata.cst4,"aMc",@progbits,4
|
|
; LARGE: .long 65536
|
|
; LARGE: .section .cp.rodata,"ac",@progbits
|
|
; LARGE: .long l
|
|
; LARGE: .long l+4
|
|
; LARGE: .long l+392
|
|
; LARGE: .long l+396
|
|
; LARGE: .text
|
|
; LARGE-LABEL: f:
|
|
; LARGE: ldc r1, 65532
|
|
; LARGE: add r1, r0, r1
|
|
; LARGE: ldw r1, r1[0]
|
|
; LARGE: ldw r2, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE: add r0, r0, r2
|
|
; LARGE: ldw r0, r0[0]
|
|
; LARGE: add r0, r1, r0
|
|
; LARGE: ldw r1, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE: ldw r1, r1[0]
|
|
; LARGE: add r0, r0, r1
|
|
; LARGE: ldw r1, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE: ldw r1, r1[0]
|
|
; LARGE: add r0, r0, r1
|
|
; LARGE: ldw r1, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE: ldw r1, r1[0]
|
|
; LARGE: add r0, r0, r1
|
|
; LARGE: ldw r1, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE: ldw r1, r1[0]
|
|
; LARGE: add r0, r0, r1
|
|
; LARGE: ldw r1, dp[s]
|
|
; LARGE: add r0, r0, r1
|
|
; LARGE: ldw r1, dp[s+36]
|
|
; LARGE: add r0, r0, r1
|
|
; LARGE: retsp 0
|
|
define i32 @f(i32* %i) {
|
|
entry:
|
|
%0 = getelementptr inbounds i32, i32* %i, i32 16383
|
|
%1 = load i32, i32* %0
|
|
%2 = getelementptr inbounds i32, i32* %i, i32 16384
|
|
%3 = load i32, i32* %2
|
|
%4 = add nsw i32 %1, %3
|
|
%5 = load i32, i32* getelementptr inbounds ([100 x i32], [100 x i32]* @l, i32 0, i32 0)
|
|
%6 = add nsw i32 %4, %5
|
|
%7 = load i32, i32* getelementptr inbounds ([100 x i32], [100 x i32]* @l, i32 0, i32 1)
|
|
%8 = add nsw i32 %6, %7
|
|
%9 = load i32, i32* getelementptr inbounds ([100 x i32], [100 x i32]* @l, i32 0, i32 98)
|
|
%10 = add nsw i32 %8, %9
|
|
%11 = load i32, i32* getelementptr inbounds ([100 x i32], [100 x i32]* @l, i32 0, i32 99)
|
|
%12 = add nsw i32 %10, %11
|
|
%13 = load i32, i32* getelementptr inbounds ([10 x i32], [10 x i32]* @s, i32 0, i32 0)
|
|
%14 = add nsw i32 %12, %13
|
|
%15 = load i32, i32* getelementptr inbounds ([10 x i32], [10 x i32]* @s, i32 0, i32 9)
|
|
%16 = add nsw i32 %14, %15
|
|
ret i32 %16
|
|
}
|
|
|
|
|
|
; CHECK-LABEL: UnknownSize:
|
|
; CHECK: ldw r0, dp[NoSize+40]
|
|
; CHECK-NEXT: retsp 0
|
|
;
|
|
; LARGE: .section .cp.rodata,"ac",@progbits
|
|
; LARGE: .LCPI{{[0-9_]*}}
|
|
; LARGE-NEXT: .long NoSize
|
|
; LARGE-NEXT: .text
|
|
; LARGE-LABEL: UnknownSize:
|
|
; LARGE: ldw r0, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE-NEXT: ldw r0, r0[0]
|
|
; LARGE-NEXT: retsp 0
|
|
@NoSize = external global [0 x i32]
|
|
define i32 @UnknownSize() nounwind {
|
|
entry:
|
|
%0 = load i32, i32* getelementptr inbounds ([0 x i32], [0 x i32]* @NoSize, i32 0, i32 10)
|
|
ret i32 %0
|
|
}
|
|
|
|
|
|
; CHECK-LABEL: UnknownStruct:
|
|
; CHECK: ldaw r0, dp[Unknown]
|
|
; CHECK-NEXT: retsp 0
|
|
;
|
|
; LARGE: .section .cp.rodata,"ac",@progbits
|
|
; LARGE: .LCPI{{[0-9_]*}}
|
|
; LARGE-NEXT: .long Unknown
|
|
; LARGE-NEXT: .text
|
|
; LARGE-LABEL: UnknownStruct:
|
|
; LARGE: ldw r0, cp[.LCPI{{[0-9_]*}}]
|
|
; LARGE-NEXT: retsp 0
|
|
%Struct = type opaque
|
|
@Unknown = external global %Struct
|
|
define %Struct* @UnknownStruct() nounwind {
|
|
entry:
|
|
ret %Struct* @Unknown
|
|
}
|
|
|
|
|
|
; CHECK: .section .dp.bss,"awd",@nobits
|
|
; CHECK-LABEL: l:
|
|
; CHECK: .space 400
|
|
; LARGE: .section .dp.bss.large,"awd",@nobits
|
|
; LARGE-LABEL: l:
|
|
; LARGE: .space 400
|
|
@l = global [100 x i32] zeroinitializer
|
|
|
|
; CHECK-LABEL: s:
|
|
; CHECK: .space 40
|
|
; LARGE: .section .dp.bss,"awd",@nobits
|
|
; LARGE-LABEL: s:
|
|
; LARGE: .space 40
|
|
@s = global [10 x i32] zeroinitializer
|
|
|
|
; CHECK: .section .dp.rodata,"awd",@progbits
|
|
; CHECK-LABEL: cl:
|
|
; CHECK: .space 400
|
|
; LARGE: .section .dp.rodata.large,"awd",@progbits
|
|
; LARGE-LABEL: cl:
|
|
; LARGE: .space 400
|
|
@cl = constant [100 x i32] zeroinitializer
|
|
|
|
; CHECK-LABEL: cs:
|
|
; CHECK: .space 40
|
|
; LARGE: .section .dp.rodata,"awd",@progbits
|
|
; LARGE-LABEL: cs:
|
|
; LARGE: .space 40
|
|
@cs = constant [10 x i32] zeroinitializer
|
|
|
|
; CHECK: .section .cp.rodata,"ac",@progbits
|
|
; CHECK-LABEL: icl:
|
|
; CHECK: .space 400
|
|
; LARGE: .section .cp.rodata.large,"ac",@progbits
|
|
; LARGE-LABEL: icl:
|
|
; LARGE: .space 400
|
|
@icl = internal constant [100 x i32] zeroinitializer
|
|
|
|
; CHECK-LABEL: cs:
|
|
; CHECK: .space 40
|
|
; LARGE: .section .cp.rodata,"ac",@progbits
|
|
; LARGE-LABEL: cs:
|
|
; LARGE: .space 40
|
|
@ics = internal constant [10 x i32] zeroinitializer
|
|
|
|
; CHECK: .section .cp.namedsection,"ac",@progbits
|
|
; CHECK-LABEL: cpsec:
|
|
; CHECK: .long 0
|
|
@cpsec = constant i32 0, section ".cp.namedsection"
|
|
|
|
; CHECK: .section .dp.namedsection,"awd",@progbits
|
|
; CHECK-LABEL: dpsec:
|
|
; CHECK: .long 0
|
|
@dpsec = global i32 0, section ".dp.namedsection"
|
|
|