move out c/cpp/py
This commit is contained in:
Li Jie
552
ssa/ssa_test.go
Normal file
552
ssa/ssa_test.go
Normal file
@@ -0,0 +1,552 @@
|
||||
//go:build !llgo
|
||||
// +build !llgo
|
||||
|
||||
/*
|
||||
* Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package ssa
|
||||
|
||||
import (
|
||||
"go/constant"
|
||||
"go/token"
|
||||
"go/types"
|
||||
"testing"
|
||||
"unsafe"
|
||||
|
||||
"github.com/goplus/gogen/packages"
|
||||
"github.com/goplus/llvm"
|
||||
)
|
||||
|
||||
func TestEndDefer(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("foo", "foo")
|
||||
fn := pkg.NewFunc("main", NoArgsNoRet, InC)
|
||||
b := fn.MakeBody(1)
|
||||
fn.defer_ = &aDefer{}
|
||||
fn.endDefer(b)
|
||||
}
|
||||
|
||||
func TestUnsafeString(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
prog.SetRuntime(func() *types.Package {
|
||||
fset := token.NewFileSet()
|
||||
imp := packages.NewImporter(fset)
|
||||
pkg, _ := imp.Import(PkgRuntime)
|
||||
return pkg
|
||||
})
|
||||
pkg := prog.NewPackage("foo", "foo")
|
||||
b := pkg.NewFunc("main", NoArgsNoRet, InC).MakeBody(1)
|
||||
b.Println(b.BuiltinCall("String", b.CStr("hello"), prog.Val(5)))
|
||||
b.Return()
|
||||
}
|
||||
|
||||
func TestPointerSize(t *testing.T) {
|
||||
expected := unsafe.Sizeof(uintptr(0))
|
||||
if size := NewProgram(nil).PointerSize(); size != int(expected) {
|
||||
t.Fatal("bad PointerSize:", size)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSetBlock(t *testing.T) {
|
||||
defer func() {
|
||||
if r := recover(); r == nil {
|
||||
t.Log("SetBlock: no error?")
|
||||
}
|
||||
}()
|
||||
fn := &aFunction{}
|
||||
b := &aBuilder{Func: fn}
|
||||
b.SetBlock(&aBasicBlock{})
|
||||
}
|
||||
|
||||
func TestSetBlockEx(t *testing.T) {
|
||||
defer func() {
|
||||
if r := recover(); r == nil {
|
||||
t.Log("SetBlockEx: no error?")
|
||||
}
|
||||
}()
|
||||
fn := &aFunction{}
|
||||
b := &aBuilder{Func: fn}
|
||||
b.SetBlockEx(&aBasicBlock{fn: fn}, -1, false)
|
||||
}
|
||||
|
||||
func TestSetPython(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
typ := types.NewPackage("foo", "foo")
|
||||
prog.SetPython(typ)
|
||||
}
|
||||
|
||||
func TestClosureCtx(t *testing.T) {
|
||||
defer func() {
|
||||
if r := recover(); r == nil {
|
||||
t.Log("closureCtx: no error?")
|
||||
}
|
||||
}()
|
||||
var f aFunction
|
||||
f.closureCtx(nil)
|
||||
}
|
||||
|
||||
func TestTypes(t *testing.T) {
|
||||
ctx := llvm.NewContext()
|
||||
llvmIntType(ctx, 4)
|
||||
|
||||
intT := types.NewVar(0, nil, "", types.Typ[types.Int])
|
||||
ret := types.NewTuple(intT, intT)
|
||||
sig := types.NewSignatureType(nil, nil, nil, nil, ret, false)
|
||||
prog := NewProgram(nil)
|
||||
prog.retType(sig)
|
||||
}
|
||||
|
||||
func TestIndexType(t *testing.T) {
|
||||
defer func() {
|
||||
if r := recover(); r == nil {
|
||||
t.Log("indexType: no error?")
|
||||
}
|
||||
}()
|
||||
indexType(types.Typ[types.Int])
|
||||
}
|
||||
|
||||
func TestCvtType(t *testing.T) {
|
||||
gt := newGoTypes()
|
||||
params := types.NewTuple(types.NewParam(0, nil, "", NoArgsNoRet))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, nil, false)
|
||||
ret1 := gt.cvtFunc(sig, nil)
|
||||
if ret1 == sig {
|
||||
t.Fatal("cvtFunc failed")
|
||||
}
|
||||
defer func() {
|
||||
if r := recover(); r == nil {
|
||||
t.Log("cvtType: no error?")
|
||||
}
|
||||
}()
|
||||
gt.cvtType(nil)
|
||||
}
|
||||
|
||||
func TestUserdefExpr(t *testing.T) {
|
||||
c := &pyVarTy{}
|
||||
b := &builtinTy{}
|
||||
_ = c.String()
|
||||
_ = b.String()
|
||||
test := func(a types.Type) {
|
||||
defer func() {
|
||||
if r := recover(); r == nil {
|
||||
t.Log("TestUserdefExpr: no error?")
|
||||
}
|
||||
}()
|
||||
a.Underlying()
|
||||
}
|
||||
test(c)
|
||||
test(b)
|
||||
}
|
||||
|
||||
func TestAny(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
prog.SetRuntime(func() *types.Package {
|
||||
ret := types.NewPackage("runtime", "runtime")
|
||||
scope := ret.Scope()
|
||||
name := types.NewTypeName(0, ret, "Eface", nil)
|
||||
types.NewNamed(name, types.NewStruct(nil, nil), nil)
|
||||
scope.Insert(name)
|
||||
return ret
|
||||
})
|
||||
prog.Any()
|
||||
}
|
||||
|
||||
func assertPkg(t *testing.T, p Package, expected string) {
|
||||
t.Helper()
|
||||
if v := p.String(); v != expected {
|
||||
t.Fatalf("\n==> got:\n%s\n==> expected:\n%s\n", v, expected)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPyFunc(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
py := types.NewPackage("foo", "foo")
|
||||
o := types.NewTypeName(0, py, "Object", nil)
|
||||
types.NewNamed(o, types.Typ[types.Int], nil)
|
||||
py.Scope().Insert(o)
|
||||
prog.SetPython(py)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
a := pkg.PyNewFunc("a", NoArgsNoRet, false)
|
||||
if pkg.PyNewFunc("a", NoArgsNoRet, false) != a {
|
||||
t.Fatal("NewPyFunc(a) failed")
|
||||
}
|
||||
foo := pkg.PyNewModVar("foo", false)
|
||||
if pkg.PyNewModVar("foo", false) != foo {
|
||||
t.Fatal("NewPyModVar(foo) failed")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVar(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
typ := types.NewPointer(types.Typ[types.Int])
|
||||
a := pkg.NewVar("a", typ, InGo)
|
||||
if pkg.NewVar("a", typ, InGo) != a {
|
||||
t.Fatal("NewVar(a) failed")
|
||||
}
|
||||
pkg.NewVarEx("a", prog.Type(typ, InGo))
|
||||
a.Init(prog.Val(100))
|
||||
b := pkg.NewVar("b", typ, InGo)
|
||||
b.Init(a.Expr)
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
@a = global i64 100, align 8
|
||||
@b = global i64 @a, align 8
|
||||
`)
|
||||
}
|
||||
|
||||
func TestConst(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Bool]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, nil, rets, false)
|
||||
b := pkg.NewFunc("fn", sig, InGo).MakeBody(1)
|
||||
b.Return(b.Const(constant.MakeBool(true), prog.Bool()))
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i1 @fn() {
|
||||
_llgo_0:
|
||||
ret i1 true
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestStruct(t *testing.T) {
|
||||
empty := types.NewStruct(nil, nil)
|
||||
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
pkg.NewVar("a", types.NewPointer(empty), InGo)
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
@a = external global {}, align 1
|
||||
`)
|
||||
if pkg.NeedRuntime {
|
||||
t.Fatal("NeedRuntime?")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNamedStruct(t *testing.T) {
|
||||
src := types.NewPackage("bar", "foo/bar")
|
||||
empty := types.NewNamed(types.NewTypeName(0, src, "Empty", nil), types.NewStruct(nil, nil), nil)
|
||||
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
pkg.NewVar("a", types.NewPointer(empty), InGo)
|
||||
if pkg.VarOf("a") == nil {
|
||||
t.Fatal("VarOf failed")
|
||||
}
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
%bar.Empty = type {}
|
||||
|
||||
@a = external global %bar.Empty, align 1
|
||||
`)
|
||||
}
|
||||
|
||||
func TestDeclFunc(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
params := types.NewTuple(types.NewVar(0, nil, "a", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, nil, false)
|
||||
pkg.NewFunc("fn", sig, InGo)
|
||||
if pkg.FuncOf("fn") == nil {
|
||||
t.Fatal("FuncOf failed")
|
||||
}
|
||||
if prog.retType(sig) != prog.Void() {
|
||||
t.Fatal("retType failed")
|
||||
}
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
declare void @fn(i64)
|
||||
`)
|
||||
}
|
||||
|
||||
func TestBasicFunc(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
params := types.NewTuple(
|
||||
types.NewVar(0, nil, "a", types.Typ[types.Int]),
|
||||
types.NewVar(0, nil, "b", types.Typ[types.Float64]))
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
pkg.NewFunc("fn", sig, InGo).MakeBody(1).
|
||||
Return(prog.Val(1))
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i64 @fn(i64 %0, double %1) {
|
||||
_llgo_0:
|
||||
ret i64 1
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestFuncParam(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
params := types.NewTuple(
|
||||
types.NewVar(0, nil, "a", types.Typ[types.Int]),
|
||||
types.NewVar(0, nil, "b", types.Typ[types.Float64]))
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
fn := pkg.NewFunc("fn", sig, InGo)
|
||||
fn.MakeBody(1).Return(fn.Param(0))
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i64 @fn(i64 %0, double %1) {
|
||||
_llgo_0:
|
||||
ret i64 %0
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestFuncCall(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
|
||||
params := types.NewTuple(
|
||||
types.NewVar(0, nil, "a", types.Typ[types.Int]),
|
||||
types.NewVar(0, nil, "b", types.Typ[types.Float64]))
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
fn := pkg.NewFunc("fn", sig, InGo)
|
||||
fn.MakeBody(1).
|
||||
Return(prog.Val(1))
|
||||
|
||||
b := pkg.NewFunc("main", NoArgsNoRet, InGo).MakeBody(1)
|
||||
b.Call(fn.Expr, prog.Val(1), prog.Val(1.2))
|
||||
b.Return()
|
||||
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i64 @fn(i64 %0, double %1) {
|
||||
_llgo_0:
|
||||
ret i64 1
|
||||
}
|
||||
|
||||
define void @main() {
|
||||
_llgo_0:
|
||||
%0 = call i64 @fn(i64 1, double 1.200000e+00)
|
||||
ret void
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestFuncMultiRet(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
params := types.NewTuple(
|
||||
types.NewVar(0, nil, "b", types.Typ[types.Float64]))
|
||||
rets := types.NewTuple(
|
||||
types.NewVar(0, nil, "c", types.Typ[types.Int]),
|
||||
types.NewVar(0, nil, "d", types.Typ[types.Float64]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
a := pkg.NewVar("a", types.NewPointer(types.Typ[types.Int]), InGo)
|
||||
fn := pkg.NewFunc("fn", sig, InGo)
|
||||
b := fn.MakeBody(1)
|
||||
b.Return(a.Expr, fn.Param(0))
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
@a = external global i64, align 8
|
||||
|
||||
define { i64, double } @fn(double %0) {
|
||||
_llgo_0:
|
||||
%1 = insertvalue { i64, double } { ptr @a, double undef }, double %0, 1
|
||||
ret { i64, double } %1
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestJump(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
fn := pkg.NewFunc("loop", NoArgsNoRet, InGo)
|
||||
b := fn.MakeBody(1)
|
||||
b.Jump(fn.Block(0))
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define void @loop() {
|
||||
_llgo_0:
|
||||
br label %_llgo_0
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestIf(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
params := types.NewTuple(types.NewVar(0, nil, "a", types.Typ[types.Int]))
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
fn := pkg.NewFunc("fn", sig, InGo)
|
||||
b := fn.MakeBody(3)
|
||||
iftrue := fn.Block(1)
|
||||
iffalse := fn.Block(2)
|
||||
if iftrue.Index() != 1 || iftrue.Parent() != fn {
|
||||
t.Fatal("iftrue")
|
||||
}
|
||||
cond := b.BinOp(token.GTR, fn.Param(0), prog.Val(0))
|
||||
b.If(cond, iftrue, iffalse)
|
||||
b.SetBlock(iftrue).Return(prog.Val(1))
|
||||
b.SetBlock(iffalse).Return(prog.Val(0))
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i64 @fn(i64 %0) {
|
||||
_llgo_0:
|
||||
%1 = icmp sgt i64 %0, 0
|
||||
br i1 %1, label %_llgo_1, label %_llgo_2
|
||||
|
||||
_llgo_1: ; preds = %_llgo_0
|
||||
ret i64 1
|
||||
|
||||
_llgo_2: ; preds = %_llgo_0
|
||||
ret i64 0
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestPrintf(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
pchar := types.NewPointer(types.Typ[types.Int8])
|
||||
params := types.NewTuple(types.NewVar(0, nil, "format", pchar), VArg())
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int32]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, true)
|
||||
pkg.NewFunc("printf", sig, InC)
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
declare i32 @printf(ptr, ...)
|
||||
`)
|
||||
}
|
||||
|
||||
func TestBinOp(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
params := types.NewTuple(
|
||||
types.NewVar(0, nil, "a", types.Typ[types.Int]),
|
||||
types.NewVar(0, nil, "b", types.Typ[types.Float64]))
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
fn := pkg.NewFunc("fn", sig, InGo)
|
||||
b := fn.MakeBody(1)
|
||||
ret := b.BinOp(token.ADD, fn.Param(0), prog.Val(1))
|
||||
b.Return(ret)
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i64 @fn(i64 %0, double %1) {
|
||||
_llgo_0:
|
||||
%2 = add i64 %0, 1
|
||||
ret i64 %2
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestUnOp(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
params := types.NewTuple(
|
||||
types.NewVar(0, nil, "p", types.NewPointer(types.Typ[types.Int])),
|
||||
)
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
fn := pkg.NewFunc("fn", sig, InGo)
|
||||
b := fn.MakeBody(1)
|
||||
ptr := fn.Param(0)
|
||||
val := b.UnOp(token.MUL, ptr)
|
||||
val2 := b.BinOp(token.XOR, val, prog.Val(1))
|
||||
b.Store(ptr, val2)
|
||||
b.Return(val2)
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i64 @fn(ptr %0) {
|
||||
_llgo_0:
|
||||
%1 = load i64, ptr %0, align 4
|
||||
%2 = xor i64 %1, 1
|
||||
store i64 %2, ptr %0, align 4
|
||||
ret i64 %2
|
||||
}
|
||||
`)
|
||||
}
|
||||
|
||||
func TestBasicType(t *testing.T) {
|
||||
type typeInfo struct {
|
||||
typ Type
|
||||
kind types.BasicKind
|
||||
}
|
||||
prog := NewProgram(nil)
|
||||
infos := []*typeInfo{
|
||||
{prog.Bool(), types.Bool},
|
||||
{prog.Byte(), types.Byte},
|
||||
{prog.Int(), types.Int},
|
||||
{prog.Uint(), types.Uint},
|
||||
{prog.Int32(), types.Int32},
|
||||
{prog.Int64(), types.Int64},
|
||||
{prog.Uint32(), types.Uint32},
|
||||
{prog.Uint64(), types.Uint64},
|
||||
{prog.Uintptr(), types.Uintptr},
|
||||
{prog.VoidPtr(), types.UnsafePointer},
|
||||
}
|
||||
for _, info := range infos {
|
||||
if info.typ.RawType() != types.Typ[info.kind] {
|
||||
t.Fatal("bad type", info)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestCompareSelect(t *testing.T) {
|
||||
prog := NewProgram(nil)
|
||||
pkg := prog.NewPackage("bar", "foo/bar")
|
||||
|
||||
params := types.NewTuple(
|
||||
types.NewVar(0, nil, "a", types.Typ[types.Int]),
|
||||
types.NewVar(0, nil, "b", types.Typ[types.Int]),
|
||||
types.NewVar(0, nil, "c", types.Typ[types.Int]),
|
||||
)
|
||||
rets := types.NewTuple(types.NewVar(0, nil, "", types.Typ[types.Int]))
|
||||
sig := types.NewSignatureType(nil, nil, nil, params, rets, false)
|
||||
fn := pkg.NewFunc("fn", sig, InGo)
|
||||
|
||||
b := fn.MakeBody(1)
|
||||
result := b.compareSelect(token.GTR, fn.Param(0), fn.Param(1), fn.Param(2))
|
||||
b.Return(result)
|
||||
|
||||
assertPkg(t, pkg, `; ModuleID = 'foo/bar'
|
||||
source_filename = "foo/bar"
|
||||
|
||||
define i64 @fn(i64 %0, i64 %1, i64 %2) {
|
||||
_llgo_0:
|
||||
%3 = icmp sgt i64 %0, %1
|
||||
%4 = select i1 %3, i64 %0, i64 %1
|
||||
%5 = icmp sgt i64 %4, %2
|
||||
%6 = select i1 %5, i64 %4, i64 %2
|
||||
ret i64 %6
|
||||
}
|
||||
`)
|
||||
}
|
||||
Reference in New Issue
Block a user