playground.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "include(\"./Utils.jl\")\n",
    "\n",
    "using MLIR\n",
    "using MLIR: IR, API, API.mlir_c\n",
    "using .Utils\n",
    "\n",
    "import Base.push!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pow (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function pow(x::F, n::Integer) where {F}\n",
    "    p = one(F)\n",
    "    for _ in 1:n\n",
    "        p *= x\n",
    "    end\n",
    "    p\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ir, ret = @code_ircode pow(2, 10);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[90m\u001b[55G│╻╷╷╷╷ Colon\u001b[1G\u001b[39m\u001b[90m3 \u001b[39m\u001b[0m1 ── %1  = Base.sle_int(1, _3)\u001b[36m::Bool\u001b[39m\n",
       "\u001b[90m\u001b[55G││┃│    UnitRange\u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       goto #3 if not %1\n",
       "\u001b[90m\u001b[55G│││┃     unitrange_last\u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m2 ──       goto #4\n",
       "\u001b[90m\u001b[55G││││  \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m3 ──       goto #4\n",
       "\u001b[90m\u001b[55G│││   \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m4 ┄─ %5  = φ (#2 => _3, #3 => 0)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│││   \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       goto #5\n",
       "\u001b[90m\u001b[55G││    \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m5 ──       goto #6\n",
       "\u001b[90m\u001b[55G││╻╷╷   isempty\u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m6 ── %8  = Base.slt_int(%5, 1)\u001b[36m::Bool\u001b[39m\n",
       "\u001b[90m\u001b[55G││    \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       goto #8 if not %8\n",
       "\u001b[90m\u001b[55G││    \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m7 ──       goto #9\n",
       "\u001b[90m\u001b[55G││    \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m8 ──       goto #9\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m9 ┄─ %12 = φ (#7 => true, #8 => false)\u001b[36m::Bool\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m│    %13 = φ (#8 => 1)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m│    %14 = Base.not_int(%12)\u001b[36m::Bool\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       goto #15 if not %14\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m10 ┄ %16 = φ (#9 => %13, #14 => %24)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m│    %17 = φ (#9 => 1, #14 => %18)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│╻     *\u001b[1G\u001b[39m\u001b[90m4 \u001b[39m\u001b[0m│    %18 = Base.mul_int(%17, _2)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│╻╷    iterate\u001b[1G\u001b[39m\u001b[90m5 \u001b[39m\u001b[0m│    %19 = (%16 === %5)\u001b[36m::Bool\u001b[39m\n",
       "\u001b[90m\u001b[55G││    \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       goto #12 if not %19\n",
       "\u001b[90m\u001b[55G││    \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m11 ─       goto #13\n",
       "\u001b[90m\u001b[55G││╻     +\u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m12 ─ %22 = Base.add_int(%16, 1)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│╻     iterate\u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       goto #13\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m13 ┄ %24 = φ (#12 => %22)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m│    %25 = φ (#11 => true, #12 => false)\u001b[36m::Bool\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m│    %26 = Base.not_int(%25)\u001b[36m::Bool\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       goto #15 if not %26\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m14 ─       goto #10\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m6 \u001b[39m\u001b[0m15 ┄ %29 = φ (#13 => %18, #9 => 1)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[55G│     \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└───       return %29\n",
       "\u001b[90m\u001b[55G      \u001b[1G\u001b[39m\u001b[90m  \u001b[39m"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(:inst, :type, :info, :line, :flag)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fieldnames(typeof(ir.stmts[10].data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30-element Vector{Any}:\n",
       " :(Base.sle_int(1, _3))\n",
       " :(goto %3 if not %1)\n",
       " :(goto %4)\n",
       " :(goto %4)\n",
       " :(φ (%2 => _3, %3 => 0))\n",
       " :(goto %5)\n",
       " :(goto %6)\n",
       " :(Base.slt_int(%5, 1))\n",
       " :(goto %8 if not %8)\n",
       " :(goto %9)\n",
       " ⋮\n",
       " :(Base.add_int(%16, 1))\n",
       " :(goto %13)\n",
       " :(φ (%12 => %22))\n",
       " :(φ (%11 => true, %12 => false))\n",
       " :(Base.not_int(%25))\n",
       " :(goto %15 if not %26)\n",
       " :(goto %10)\n",
       " :(φ (%13 => %18, %9 => 1))\n",
       " :(return %29)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ir.stmts.inst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15-element Vector{Core.Compiler.BasicBlock}:\n",
       " Core.Compiler.BasicBlock([1, 2], Int64[], [3, 2])\n",
       " Core.Compiler.BasicBlock([3], [1], [4])\n",
       " Core.Compiler.BasicBlock([4], [1], [4])\n",
       " Core.Compiler.BasicBlock([5, 6], [2, 3], [5])\n",
       " Core.Compiler.BasicBlock([7], [4], [6])\n",
       " Core.Compiler.BasicBlock([8, 9], [5], [8, 7])\n",
       " Core.Compiler.BasicBlock([10], [6], [9])\n",
       " Core.Compiler.BasicBlock([11], [6], [9])\n",
       " Core.Compiler.BasicBlock([12, 13, 14, 15], [7, 8], [15, 10])\n",
       " Core.Compiler.BasicBlock([16, 17, 18, 19, 20], [9, 14], [12, 11])\n",
       " Core.Compiler.BasicBlock([21], [10], [13])\n",
       " Core.Compiler.BasicBlock([22, 23], [10], [13])\n",
       " Core.Compiler.BasicBlock([24, 25, 26, 27], [11, 12], [15, 14])\n",
       " Core.Compiler.BasicBlock([28], [13], [10])\n",
       " Core.Compiler.BasicBlock([29, 30], [9, 13], Int64[])"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ir.cfg.blocks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(:stmts, :preds, :succs)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ir.cfg.blocks[1] |> (fieldnames ∘ typeof)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f(x, y) = 2*(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[90m\u001b[74G│╻ +\u001b[1G\u001b[39m\u001b[90m1 \u001b[39m\u001b[0m1 ─ %1 = Base.add_int(_2, _3)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[74G│╻ *\u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m│   %2 = Base.mul_int(2, %1)\u001b[36m::Int64\u001b[39m\n",
       "\u001b[90m\u001b[74G│ \u001b[1G\u001b[39m\u001b[90m  \u001b[39m\u001b[0m└──      return %2\n",
       "\u001b[90m\u001b[74G  \u001b[1G\u001b[39m\u001b[90m  \u001b[39m => Int64"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ir, ret = @code_ircode f(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "registerAllDialects! (generic function with 1 method)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function registerAllDialects!(ctx)\n",
    "    registry = MLIR.API.mlirDialectRegistryCreate()\n",
    "    MLIR.API.mlirRegisterAllDialects(registry)\n",
    "    handle = MLIR.API.mlirGetDialectHandle__jlir__()\n",
    "    API.mlirDialectHandleInsertDialect(handle, registry)\n",
    "    # MLIR.API.mlirDialectHandleRegisterDialect(handle, ctx)\n",
    "    MLIR.API.mlirContextAppendDialectRegistry(ctx, registry)\n",
    "    # MLIR.API.mlirDialectRegistryDestroy(registry)\n",
    "\n",
    "    MLIR.API.mlirContextLoadAllAvailableDialects(ctx)\n",
    "    return registry\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLIR.API.MlirDialectRegistry(Ptr{Nothing} @0x000055d828120cd0)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: the difference between loaddialect and registerdialect is unclear to me.\n",
    "\n",
    "ctx = IR.Context()\n",
    "registry = registerAllDialects!(ctx)\n",
    "\n",
    "# let \n",
    "#     handle = @ccall mlir_c.mlirGetDialectHandle__jlir__()::IR.MlirDialectHandle\n",
    "#     API.mlirDialectHandleLoadDialect(handle, ctx)\n",
    "\n",
    "#     handle = @ccall mlir_c.mlirGetDialectHandle__func__()::IR.MlirDialectHandle\n",
    "#     API.mlirDialectHandleLoadDialect(handle, ctx)\n",
    "# end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Base.RefValue{MLIR.API.MlirOperationState}(MLIR.API.MlirOperationState(MLIR.API.MlirStringRef(Cstring(0x00007f8edc050360), 0x0000000000000009), MLIR.API.MlirLocation(Ptr{Nothing} @0x000055d827df6890), 0, Ptr{MLIR.API.MlirType} @0x0000000000000000, 0, Ptr{MLIR.API.MlirValue} @0x0000000000000000, 0, Ptr{MLIR.API.MlirRegion} @0x0000000000000000, 0, Ptr{MLIR.API.MlirBlock} @0x0000000000000000, 0, Ptr{MLIR.API.MlirNamedAttribute} @0x0000000000000000, false))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: provide sensible location\n",
    "\n",
    "state = Ref(API.mlirOperationStateGet(\"func.func\", IR.Location(ctx)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "function API.MlirType(ctx::MLIR.IR.Context, t)\n",
    "    return @ccall mlir_c.brutus_get_jlirtype(ctx::MLIR.IR.Context, t::Any)::API.MlirType\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{MLIR.API.MlirType}:\n",
       " MLIR.API.MlirType(Ptr{Nothing} @0x000055d82875abc0)\n",
       " MLIR.API.MlirType(Ptr{Nothing} @0x000055d828101380)\n",
       " MLIR.API.MlirType(Ptr{Nothing} @0x000055d828101380)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "args = let\n",
    "    argtypes = getfield(ir, :argtypes)\n",
    "    API.MlirType.(Ref(ctx), argtypes)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: functions with multiple blocks need more blocks.\n",
    "\n",
    "reg = API.mlirRegionCreate()\n",
    "entry_block = API.mlirBlockCreate(length(args), args, [IR.Location(ctx) for _ in enumerate(args)])\n",
    "\n",
    "API.mlirRegionAppendOwnedBlock(reg, entry_block)\n",
    "API.mlirOperationStateAddOwnedRegions(state, 1, [reg])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "push! (generic function with 39 methods)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "push!(block::API.MlirBlock, type::API.MlirType, loc::API.MlirLocation) =\n",
    "    API.mlirBlockAddArgument(block, type, loc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{MLIR.API.MlirValue}:\n",
       " MLIR.API.MlirValue(Ptr{Nothing} @0x000055d8273cdd40)\n",
       " MLIR.API.MlirValue(Ptr{Nothing} @0x000055d827e8e4e0)\n",
       " MLIR.API.MlirValue(Ptr{Nothing} @0x000055d82862a000)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# args = push!.(Ref(entry_block), API.MlirType.(Ref(ctx), ir.argtypes), Ref(IR.Location(ctx).location))\n",
    "input_types = API.mlirBlockGetArgument.(Ref(entry_block), eachindex(ir.argtypes) .- 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "API.mlirBlockGetNumArguments(entry_block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "push! (generic function with 40 methods)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "push!(block::API.MlirBlock, op::API.MlirOperation) = \n",
    "    API.mlirBlockAppendOwnedOperation(block, op)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "ret_op = IR.create_operation(\"func.return\", IR.Location(ctx); operands=[args[2]], result_inference = false).operation\n",
    "push!(entry_block, ret_op)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLIR.API.MlirNamedAttribute(MLIR.API.MlirIdentifier(Ptr{Nothing} @0x000055d8274e7058), MLIR.API.MlirAttribute(Ptr{Nothing} @0x000055d826b694e0))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: is `ret` always a single value?\n",
    "named_type_attr = let \n",
    "    function_type = API.mlirFunctionTypeGet(\n",
    "        ctx,\n",
    "        length(input_types), API.mlirValueGetType.(input_types),\n",
    "        1, [API.MlirType(ctx, ret)])\n",
    "        \n",
    "    type_attr = API.mlirTypeAttrGet(function_type)\n",
    "    \n",
    "    API.mlirNamedAttributeGet(API.mlirIdentifierGet(ctx, \"function_type\"), type_attr)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLIR.API.MlirNamedAttribute(MLIR.API.MlirIdentifier(Ptr{Nothing} @0x000055d8274e6740), MLIR.API.MlirAttribute(Ptr{Nothing} @0x000055d8289df180))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "named_symbol_name_attr = let \n",
    "    name = \"f\"\n",
    "    \n",
    "    symbol_name_attr = API.mlirStringAttrGet(ctx, name)\n",
    "    \n",
    "    API.mlirNamedAttributeGet(API.mlirIdentifierGet(ctx, \"sym_name\"), symbol_name_attr)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLIR.API.MlirNamedAttribute(MLIR.API.MlirIdentifier(Ptr{Nothing} @0x000055d827117540), MLIR.API.MlirAttribute(Ptr{Nothing} @0x000055d828990c40))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "named_viz_attr = let\n",
    "    viz_attr = API.mlirStringAttrGet(ctx, \"nested\")\n",
    "    \n",
    "    API.mlirNamedAttributeGet(API.mlirIdentifierGet(ctx, \"sym_visibility\"), viz_attr)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLIR.API.MlirNamedAttribute(MLIR.API.MlirIdentifier(Ptr{Nothing} @0x000055d828990c70), MLIR.API.MlirAttribute(Ptr{Nothing} @0x000055d827df6880))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "named_unit_attr = let \n",
    "    unit_attr = API.mlirUnitAttrGet(ctx)\n",
    "\n",
    "    API.mlirNamedAttributeGet(API.mlirIdentifierGet(ctx, \"llvm.emit_c_interface\"), unit_attr)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "push! (generic function with 41 methods)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "function push!(state::Base.RefValue{MLIR.API.MlirOperationState}, attr::IR.MlirNamedAttribute)\n",
    "    API.mlirOperationStateAddAttributes(state, 1, Ref(attr))\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "push!(state, named_type_attr)\n",
    "push!(state, named_symbol_name_attr)\n",
    "push!(state, named_viz_attr)\n",
    "push!(state, named_unit_attr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "op = API.mlirOperationCreate(state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Base.RefValue{MLIR.API.MlirOperationState}\n",
      "  x: MLIR.API.MlirOperationState\n",
      "    name: MLIR.API.MlirStringRef\n",
      "      data: Cstring Cstring(0x00007f224bc52580)\n",
      "      length: UInt64 0x0000000000000009\n",
      "    location: MLIR.API.MlirLocation\n",
      "      ptr: Ptr{Nothing} @0x000055eb4bc57360\n",
      "    nResults: Int64 0\n",
      "    results: Ptr{MLIR.API.MlirType} @0x0000000000000000\n",
      "    nOperands: Int64 0\n",
      "    operands: Ptr{MLIR.API.MlirValue} @0x0000000000000000\n",
      "    nRegions: Int64 1\n",
      "    regions: Ptr"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{MLIR.API.MlirRegion} @0x000055eb4ac0ca50\n",
      "    nSuccessors: Int64 0\n",
      "    successors: Ptr{MLIR.API.MlirBlock} @0x0000000000000000\n",
      "    nAttributes: Int64 4\n",
      "    attributes: Ptr{MLIR.API.MlirNamedAttribute} @0x000055eb4a1be190\n",
      "    enableResultTypeInference: Bool false\n"
     ]
    }
   ],
   "source": [
    "dump(state)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "error: 'func.func' op entry block must have 3 arguments to match function signature\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "API.mlirOperationVerify(op)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLIR.API.MlirModule(Ptr{Nothing} @0x000055d47e975d50)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "IR.create_operation(\"func.return\", IR.Location(ctx); operands, result_inference = false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ctx = IR.Context()\n",
    " \n",
    "handle = @ccall mlir_c.mlirGetDialectHandle__jlir__()::IR.MlirDialectHandle\n",
    "API.mlirDialectHandleLoadDialect(handle, ctx)\n",
    "\n",
    "API.mlirContextGetNumLoadedDialects(ctx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MLIR.API.MlirDialectRegistry(Ptr{Nothing} @0x000055d4829e11f0)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "registry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "API.mlirContextGetNumRegisteredDialects(ctx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching getindex(::Core.Compiler.InstructionStream, ::Core.Compiler.StmtRange)\n\nClosest candidates are:\n  getindex(::Core.Compiler.InstructionStream, !Matched::Int64)\n   @ Base show.jl:2778\n",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching getindex(::Core.Compiler.InstructionStream, ::Core.Compiler.StmtRange)\n",
      "\n",
      "Closest candidates are:\n",
      "  getindex(::Core.Compiler.InstructionStream, !Matched::Int64)\n",
      "   @ Base show.jl:2778\n",
      "\n",
      "\n",
      "Stacktrace:\n",
      " [1] top-level scope\n",
      "   @ ~/julia/build/playground/playground.ipynb:1"
     ]
    }
   ],
   "source": [
    "ir.stmts[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Core.Compiler.Instruction(Core.Compiler.InstructionStream(Any[:(Base.add_int(_2, _3)), :(Base.mul_int(2, %1)), :(return %2)], Any[Int64, Int64, Any], Core.Compiler.CallInfo[Core.Compiler.NoCallInfo(), Core.Compiler.NoCallInfo(), Core.Compiler.NoCallInfo()], Int32[2, 3, 1], UInt8[0x70, 0x70, 0x60]), 1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ir.stmts[first(ir.cfg.blocks).stmts[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.11.0-DEV",
   "language": "julia",
   "name": "julia-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.0-DEV"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}