Skip to content

llvm15: update llir/llvm to support LLVM 15.0 (rc1) #223

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 9 commits into from
Aug 3, 2022
Merged

llvm15: update llir/llvm to support LLVM 15.0 (rc1) #223

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
51f8abf
ir/metadata: add DISubprogram.TargetFuncName field (for LLVM 15.0)
mewmew Aug 2, 2022
1bb4d59
ir/enum: add fmin and fmax to AtomicOp for atomicrmw instruction (for…
mewmew Aug 2, 2022
f4d5dbd
ir: add UnwindTable function attribute
mewmew Aug 2, 2022
24038ca
ir: add AllocKind function attribute
mewmew Aug 2, 2022
75a0aa8
ir: add optional sanitizer for global variables (for LLVM 15.0)
mewmew Aug 2, 2022
414ffb3
asm: disable test cases which require opaque pointer type (to be impl…
mewmew Aug 2, 2022
f17ff63
ir/constant: remove deprecated constant expressions (for LLVM 15.0)
mewmew Aug 2, 2022
f219f70
ll: update llir/ll dependency to latest commit (for LLVM 15.0)
mewmew Aug 2, 2022
c2363c5
readme: add mapping between llir/llvm v0.3.7 and LLVM 15.0
mewmew Aug 2, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions .gitignore
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1 +1,2 @@
tools
go.work
1 change: 1 addition & 0 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,6 +22,7 @@ go get -u github.com/llir/llvm/...

Map between `llir/llvm` tagged releases and LLVM release versions.

* [llir/llvm v0.3.7](https://github.com/llir/llvm/tree/v0.3.7): LLVM 15.0
* [llir/llvm v0.3.6](https://github.com/llir/llvm/tree/v0.3.6): LLVM 14.0
* [llir/llvm v0.3.5](https://github.com/llir/llvm/tree/v0.3.5): LLVM 13.0
* [llir/llvm v0.3.4](https://github.com/llir/llvm/tree/v0.3.4): LLVM 12.0
Expand Down
21 changes: 12 additions & 9 deletions asm/asm_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,9 +32,6 @@ func TestParseFile(t *testing.T) {
// be merged into one.
{path: "testdata/multiple_named_metadata_defs.ll"},

// frem constant expression.
{path: "testdata/expr_frem.ll"},

// parameter attributes.
{path: "testdata/param_attrs.ll"},

Expand Down Expand Up @@ -82,16 +79,14 @@ func TestParseFile(t *testing.T) {
// fsub constant expressions.
{path: "../testdata/llvm/test/Transforms/InstCombine/fma.ll"},

// Constant expressions.
{path: "../testdata/llvm/test/Transforms/ConstProp/constant-expr.ll"},

// Vector constant expressions.
{path: "../testdata/llvm/test/Transforms/InstCombine/vec_demanded_elts.ll"},
{path: "../testdata/llvm/test/Transforms/InstCombine/vector_insertelt_shuffle.ll"},

// Use of address space in function declaration and dereferenable
// parameter attribute.
{path: "../testdata/llvm/test/Transforms/InstSimplify/compare.ll"},
// TODO: re-enable test case when opaque pointer type has been implemented (in LLVM 16.0).
//{path: "../testdata/llvm/test/Transforms/InstSimplify/compare.ll"},

// Basic block labels.
{path: "../testdata/llvm/test/Assembler/block-labels.ll"},
Expand All @@ -101,7 +96,8 @@ func TestParseFile(t *testing.T) {

// Calling conventions.
{path: "../testdata/llvm/test/Bitcode/calling-conventions.3.2.ll"},
{path: "../testdata/llvm/test/CodeGen/X86/tailccfp.ll"},
// TODO: re-enable test case when opaque pointer type has been implemented (in LLVM 16.0).
//{path: "../testdata/llvm/test/CodeGen/X86/tailccfp.ll"},

// Parameter attributes.
{path: "../testdata/llvm/test/Bitcode/attributes.ll"},
Expand Down Expand Up @@ -354,7 +350,8 @@ func TestParseFile(t *testing.T) {
{path: "../testdata/llvm/test/Bitcode/disubrange.ll"},

// LLVM test/CodeGen.
{path: "../testdata/llvm/test/CodeGen/X86/extractps.ll"},
// TODO: re-enable test case when opaque pointer type has been implemented (in LLVM 16.0).
//{path: "../testdata/llvm/test/CodeGen/X86/extractps.ll"},

// LLVM test/DebugInfo/Generic.
{path: "../testdata/llvm/test/DebugInfo/Generic/constant-pointers.ll"},
Expand Down Expand Up @@ -410,10 +407,16 @@ func TestParseFile(t *testing.T) {
//
// * 'no_cfi' constant.
{path: "../testdata/llvm/test/Bitcode/nocfivalue.ll"},
// LLVM 14.0.
//
// * 'DIImportedEntity.elements' metadata field
{path: "../testdata/llvm/test/Bitcode/DIImportedEntity_elements.ll"},

// LLVM 15.0.
//
// * 'DISubprogram.targetFuncName' metadata field
{path: "../testdata/llvm/test/Assembler/disubprogram-targetfuncname.ll"},

// Coreutils.
{path: "../testdata/coreutils/test/[.ll"},
{path: "../testdata/coreutils/test/b2sum.ll"},
Expand Down
270 changes: 0 additions & 270 deletions asm/const_expr.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,28 +22,10 @@ func (gen *generator) irConstantExpr(t types.Type, old ast.ConstantExpr) (consta
// Binary expressions
case *ast.AddExpr:
return gen.irAddExpr(t, old)
case *ast.FAddExpr:
return gen.irFAddExpr(t, old)
case *ast.SubExpr:
return gen.irSubExpr(t, old)
case *ast.FSubExpr:
return gen.irFSubExpr(t, old)
case *ast.MulExpr:
return gen.irMulExpr(t, old)
case *ast.FMulExpr:
return gen.irFMulExpr(t, old)
case *ast.UDivExpr:
return gen.irUDivExpr(t, old)
case *ast.SDivExpr:
return gen.irSDivExpr(t, old)
case *ast.FDivExpr:
return gen.irFDivExpr(t, old)
case *ast.URemExpr:
return gen.irURemExpr(t, old)
case *ast.SRemExpr:
return gen.irSRemExpr(t, old)
case *ast.FRemExpr:
return gen.irFRemExpr(t, old)
// Bitwise expressions
case *ast.ShlExpr:
return gen.irShlExpr(t, old)
Expand All @@ -64,11 +46,6 @@ func (gen *generator) irConstantExpr(t types.Type, old ast.ConstantExpr) (consta
return gen.irInsertElementExpr(t, old)
case *ast.ShuffleVectorExpr:
return gen.irShuffleVectorExpr(t, old)
// Aggregate expressions
case *ast.ExtractValueExpr:
return gen.irExtractValueExpr(t, old)
case *ast.InsertValueExpr:
return gen.irInsertValueExpr(t, old)
// Memory expressions
case *ast.GetElementPtrExpr:
return gen.irGetElementPtrExpr(t, old)
Expand Down Expand Up @@ -156,28 +133,6 @@ func (gen *generator) irAddExpr(t types.Type, old *ast.AddExpr) (*constant.ExprA
return expr, nil
}

// ~~~ [ fadd ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irFAddExpr translates the AST fadd constant expression into an equivalent IR
// constant expression.
func (gen *generator) irFAddExpr(t types.Type, old *ast.FAddExpr) (*constant.ExprFAdd, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewFAdd(x, y)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ sub ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irSubExpr translates the AST sub constant expression into an equivalent IR
Expand All @@ -202,28 +157,6 @@ func (gen *generator) irSubExpr(t types.Type, old *ast.SubExpr) (*constant.ExprS
return expr, nil
}

// ~~~ [ fsub ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irFSubExpr translates the AST fsub constant expression into an equivalent IR
// constant expression.
func (gen *generator) irFSubExpr(t types.Type, old *ast.FSubExpr) (*constant.ExprFSub, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewFSub(x, y)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ mul ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irMulExpr translates the AST mul constant expression into an equivalent IR
Expand All @@ -248,164 +181,6 @@ func (gen *generator) irMulExpr(t types.Type, old *ast.MulExpr) (*constant.ExprM
return expr, nil
}

// ~~~ [ fmul ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irFMulExpr translates the AST fmul constant expression into an equivalent IR
// constant expression.
func (gen *generator) irFMulExpr(t types.Type, old *ast.FMulExpr) (*constant.ExprFMul, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewFMul(x, y)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ udiv ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irUDivExpr translates the AST udiv constant expression into an equivalent IR
// constant expression.
func (gen *generator) irUDivExpr(t types.Type, old *ast.UDivExpr) (*constant.ExprUDiv, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewUDiv(x, y)
// (optional) Exact.
_, expr.Exact = old.Exact()
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ sdiv ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irSDivExpr translates the AST sdiv constant expression into an equivalent IR
// constant expression.
func (gen *generator) irSDivExpr(t types.Type, old *ast.SDivExpr) (*constant.ExprSDiv, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewSDiv(x, y)
// (optional) Exact.
_, expr.Exact = old.Exact()
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ fdiv ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irFDivExpr translates the AST fdiv constant expression into an equivalent IR
// constant expression.
func (gen *generator) irFDivExpr(t types.Type, old *ast.FDivExpr) (*constant.ExprFDiv, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewFDiv(x, y)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ urem ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irURemExpr translates the AST urem constant expression into an equivalent IR
// constant expression.
func (gen *generator) irURemExpr(t types.Type, old *ast.URemExpr) (*constant.ExprURem, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewURem(x, y)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ srem ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irSRemExpr translates the AST srem constant expression into an equivalent IR
// constant expression.
func (gen *generator) irSRemExpr(t types.Type, old *ast.SRemExpr) (*constant.ExprSRem, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewSRem(x, y)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ frem ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irFRemExpr translates the AST frem constant expression into an equivalent IR
// constant expression.
func (gen *generator) irFRemExpr(t types.Type, old *ast.FRemExpr) (*constant.ExprFRem, error) {
// X operand.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Y operand.
y, err := gen.irTypeConst(old.Y())
if err != nil {
return nil, errors.WithStack(err)
}
expr := constant.NewFRem(x, y)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// --- [ Bitwise expressions ] -------------------------------------------------

// ~~~ [ shl ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Expand Down Expand Up @@ -624,51 +399,6 @@ func (gen *generator) irShuffleVectorExpr(t types.Type, old *ast.ShuffleVectorEx
return expr, nil
}

// --- [ Aggregate expressions ] -----------------------------------------------

// ~~~ [ extractvalue ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irExtractValueExpr translates the AST extractvalue constant expression into
// an equivalent IR constant expression.
func (gen *generator) irExtractValueExpr(t types.Type, old *ast.ExtractValueExpr) (*constant.ExprExtractValue, error) {
// Aggregate value.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Element indices.
indices := uintSlice(old.Indices())
expr := constant.NewExtractValue(x, indices...)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// ~~~ [ insertvalue ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// irInsertValueExpr translates the AST insertvalue constant expression into an
// equivalent IR constant expression.
func (gen *generator) irInsertValueExpr(t types.Type, old *ast.InsertValueExpr) (*constant.ExprInsertValue, error) {
// Aggregate value.
x, err := gen.irTypeConst(old.X())
if err != nil {
return nil, errors.WithStack(err)
}
// Element.
elem, err := gen.irTypeConst(old.Elem())
if err != nil {
return nil, errors.WithStack(err)
}
// Element indices.
indices := uintSlice(old.Indices())
expr := constant.NewInsertValue(x, elem, indices...)
if !t.Equal(expr.Typ) {
return nil, errors.Errorf("constant expression type mismatch in `%v`; expected %q, got %q", expr, expr.Typ, t)
}
return expr, nil
}

// --- [ Memory expressions ] --------------------------------------------------

// ~~~ [ getelementptr ] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Expand Down
Loading