src/compiler_ffi.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2013 Alexis Laferrière <alexis.laf@xymus.net>
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16
  17 # FFI support for the compilers
  18 module compiler_ffi
  19
  20 intrude import abstract_compiler
  21 intrude import common_ffi
  22 import nitni
  23
  24 redef class MModule
  25         private var foreign_callbacks = new ForeignCallbackSet
  26         var nitni_ccu: nullable CCompilationUnit = null
  27
  28         private fun nmodule(v: AbstractCompilerVisitor): nullable AModule
  29         do
  30                 var m2n = v.compiler.modelbuilder.mmodule2nmodule
  31                 return m2n.get_or_null(self)
  32         end
  33
  34         redef fun finalize_ffi(compiler: AbstractCompiler)
  35         do
  36                 if not uses_ffi then return
  37
  38                 var v = compiler.new_visitor
  39                 var n = nmodule(v)
  40                 if n == null then return
  41                 n.ensure_compile_ffi_wrapper
  42                 finalize_ffi_wrapper(v.compiler.modelbuilder.compile_dir, v.compiler.mainmodule)
  43                 for file in ffi_files do v.compiler.extern_bodies.add(file)
  44
  45                 ensure_compile_nitni_base(v)
  46
  47                 nitni_ccu.header_c_types.add("#include \"{name}._ffi.h\"\n")
  48
  49                 nitni_ccu.write_as_nitni(self, v.compiler.modelbuilder.compile_dir)
  50
  51                 for file in nitni_ccu.files do
  52                         v.compiler.extern_bodies.add(new ExternCFile(file, c_compiler_options))
  53                 end
  54
  55                 # reset FFI things so the next compilation job, if any, starts with a clean context
  56                 # FIXME clean and rationalize this
  57                 nitni_ccu = null
  58                 compiled_ffi_methods.clear
  59                 ffi_ccu = null
  60                 ffi_files.clear
  61                 compiled_callbacks.clear
  62                 #Do not reset `foreign_callbacks` and `ffi_callbacks` because they are computed in previous phases
  63         end
  64
  65         private fun ensure_compile_nitni_base(v: AbstractCompilerVisitor)
  66         do
  67                 if nitni_ccu != null then return
  68
  69                 nitni_ccu = new CCompilationUnit
  70         end
  71
  72         redef fun collect_linker_libs
  73         do
  74                 var s = c_linker_options
  75                 if s.is_empty then return null
  76                 var res = new ArraySet[String]
  77                 res.add s
  78                 return res
  79         end
  80
  81         private var compiled_callbacks: Array[NitniCallback] = new Array[NitniCallback]
  82
  83         # Returns true if callbacks has yet to be generated and register it as being generated
  84         private fun check_callback_compilation(cb: NitniCallback): Bool
  85         do
  86                 var compiled = compiled_callbacks.has(cb)
  87                 if not compiled then compiled_callbacks.add(cb)
  88                 return not compiled
  89         end
  90 end
  91
  92 redef class AMethPropdef
  93         private fun compile_ffi_support_to_c(v: AbstractCompilerVisitor)
  94         do
  95                 var mmodule = mpropdef.mclassdef.mmodule
  96                 var mainmodule = v.compiler.mainmodule
  97                 var amainmodule = v.compiler.modelbuilder.mmodule2nmodule[mainmodule]
  98                 var amodule = v.compiler.modelbuilder.mmodule2nmodule[mmodule]
  99                 var mclass_type = mpropdef.mclassdef.bound_mtype
 100
 101                 # Declare as extern
 102                 var csignature = mpropdef.mproperty.build_csignature(mclass_type, mmodule, "___impl", long_signature, internal_call_context)
 103                 v.declare_once("{csignature};")
 104
 105                 # FFI part
 106                 amodule.ensure_compile_ffi_wrapper
 107                 compile_ffi_method(mmodule)
 108
 109                 assert self isa AExternPropdef
 110
 111                 # nitni - Compile missing callbacks
 112                 mmodule.ensure_compile_nitni_base(v)
 113                 var ccu = mmodule.nitni_ccu.as(not null)
 114
 115                 for mtype in foreign_callbacks.types do
 116                         if not mtype.is_cprimitive then
 117                                 mtype.compile_extern_type(v, ccu)
 118
 119                                 # has callbacks already been compiled? (this may very well happen with global compilation)
 120                                 if mmodule.check_callback_compilation(mtype) then mtype.compile_extern_helper_functions(v, ccu)
 121                         end
 122                 end
 123
 124                 # compile callbacks
 125                 for cb in foreign_callbacks.callbacks do if mainmodule.check_callback_compilation(cb) then
 126                         cb.compile_extern_callback(v, ccu)
 127                 end
 128
 129                 for cb in foreign_callbacks.supers do if mainmodule.check_callback_compilation(cb) then
 130                         cb.compile_extern_callback(v, ccu)
 131                 end
 132
 133                 for cb in foreign_callbacks.casts do if mainmodule.check_callback_compilation(cb) then
 134                         cb.compile_extern_callbacks(v, ccu)
 135                 end
 136
 137                 # manage nitni callback set
 138                 mmodule.foreign_callbacks.join(foreign_callbacks)
 139         end
 140
 141         redef fun compile_externmeth_to_c(v, mpropdef, arguments)
 142         do
 143                 var mmodule = mpropdef.mclassdef.mmodule
 144
 145                 # if using the old native interface fallback on previous implementation
 146                 var nextern = self.n_extern
 147                 if nextern != null then
 148                         super
 149                         return
 150                 end
 151
 152                 mmodule.uses_ffi = true
 153
 154                 var mclass_type = mpropdef.mclassdef.bound_mtype
 155
 156                 # Outgoing code in compiler
 157                 var externname = mpropdef.mproperty.build_cname(mpropdef.mclassdef.bound_mtype, mmodule, "___impl", long_signature)
 158                 var recv_var: nullable RuntimeVariable = null
 159                 var return_mtype = mpropdef.msignature.return_mtype
 160                 if return_mtype != null then
 161                         return_mtype = return_mtype.anchor_to(mmodule, mclass_type)
 162                         recv_var = v.new_var(return_mtype)
 163                 end
 164
 165                 v.adapt_signature(mpropdef, arguments)
 166
 167                 var arguments_for_c = new Array[String]
 168                 for a in [0..arguments.length[ do
 169                         var arg = arguments[a]
 170                         var param_mtype: MType
 171                         if a == 0 then
 172                                 param_mtype = mpropdef.mclassdef.mclass.mclass_type
 173                         else param_mtype = mpropdef.msignature.mparameters[a-1].mtype
 174
 175                         param_mtype = param_mtype.anchor_to(mmodule, mclass_type)
 176
 177                         if param_mtype.is_cprimitive then
 178                                 arguments_for_c.add(arg.name)
 179                         else
 180                                 v.add("struct nitni_instance* var_for_c_{a};")
 181                                 v.add("var_for_c_{a} = malloc(sizeof(struct nitni_instance));")
 182                                 v.add("var_for_c_{a}->value = {arg.name};")
 183                                 arguments_for_c.add("var_for_c_{a}")
 184                         end
 185                 end
 186
 187                 if recv_var == null then
 188                         v.add("{externname}({arguments_for_c.join(", ")});")
 189                 else
 190                         assert return_mtype != null
 191                         if return_mtype.is_cprimitive then
 192                                 v.add("{recv_var} = {externname}({arguments_for_c.join(", ")});")
 193                         else
 194                                 v.add("struct nitni_instance* ret_var;")
 195                                 v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
 196                                 v.add("{recv_var} = ret_var->value;")
 197                         end
 198                         v.ret(recv_var)
 199                 end
 200
 201                 compile_ffi_support_to_c(v)
 202         end
 203
 204         redef fun compile_externinit_to_c(v, mpropdef, arguments)
 205         do
 206                 var mmodule = mpropdef.mclassdef.mmodule
 207
 208                 # if using the old native interface fallback on previous implementation
 209                 var nextern = self.n_extern
 210                 if nextern != null then
 211                         super
 212                         return
 213                 end
 214
 215                 mmodule.uses_ffi = true
 216
 217                 var mclass_type = mpropdef.mclassdef.bound_mtype
 218
 219                 var externname = mpropdef.mproperty.build_cname(mpropdef.mclassdef.bound_mtype, mmodule, "___impl", long_signature)
 220                 var return_mtype = arguments.first.mtype
 221                 var recv_var = v.new_var(return_mtype)
 222
 223                 v.adapt_signature(mpropdef, arguments)
 224
 225                 arguments.shift
 226
 227                 var arguments_for_c = new Array[String]
 228                 for a in [0..arguments.length[ do
 229                         var arg = arguments[a]
 230                         var param_mtype: MType
 231                         param_mtype = mpropdef.msignature.mparameters[a].mtype
 232                         param_mtype = param_mtype.anchor_to(mmodule, mclass_type)
 233
 234                         if param_mtype.is_cprimitive then
 235                                 arguments_for_c.add(arg.name)
 236                         else
 237                                 v.add("struct nitni_instance* var_for_c_{a};")
 238                                 v.add("var_for_c_{a} = malloc(sizeof(struct nitni_instance));")
 239                                 v.add("var_for_c_{a}->value = {arg.name};")
 240                                 arguments_for_c.add("var_for_c_{a}")
 241                         end
 242                 end
 243
 244                 if return_mtype.is_cprimitive then
 245                         v.add("{recv_var} = {externname}({arguments_for_c.join(", ")});")
 246                 else
 247                         v.add("struct nitni_instance* ret_var;")
 248                         v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
 249                         v.add("{recv_var} = ret_var->value;")
 250                 end
 251                 v.ret(recv_var)
 252
 253                 compile_ffi_support_to_c(v)
 254         end
 255 end
 256
 257 redef class CCompilationUnit
 258         fun write_as_nitni(mmodule: MModule, compdir: String)
 259         do
 260                 var base_name = "{mmodule.name}._nitni"
 261
 262                 var h_file = "{base_name}.h"
 263                 write_header_to_file( mmodule, "{compdir}/{h_file}", new Array[String],
 264                         "{mmodule.cname.to_s.to_upper}_NITG_NITNI_H")
 265
 266                 var c_file = "{base_name}.c"
 267                 write_body_to_file( mmodule, "{compdir}/{c_file}", ["\"{h_file}\""] )
 268
 269                 files.add( "{compdir}/{c_file}" )
 270         end
 271 end
 272
 273 redef class AbstractCompiler
 274         # Cache to avoid multiple compilation of NULL values
 275         # see FIXME in `MNullableType#compile_extern_helper_functions`
 276         private var compiled_null_types = new Array[MNullableType]
 277 end
 278
 279 redef class AbstractCompilerVisitor
 280         # Create a `RuntimeVariable` for this C variable originating from C user code
 281         private fun var_from_c(name: String, mtype: MType): RuntimeVariable
 282         do
 283                 if mtype.is_cprimitive then
 284                         return new RuntimeVariable(name, mtype, mtype)
 285                 else
 286                         return new RuntimeVariable("{name}->value", mtype, mtype)
 287                 end
 288         end
 289
 290         # Return a `RuntimeVarible` to C user code
 291         private fun ret_to_c(src: RuntimeVariable, mtype: MType)
 292         do
 293                 if mtype.is_cprimitive then
 294                         add("return {src};")
 295                 else
 296                         add("struct nitni_instance* ret_for_c;")
 297                         add("ret_for_c = malloc(sizeof(struct nitni_instance));")
 298                         add("ret_for_c->value = {src};")
 299                         add("return ret_for_c;")
 300                 end
 301         end
 302 end
 303
 304 redef class MType
 305         private fun compile_extern_type(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 306         do
 307                 assert not is_cprimitive
 308
 309                 # define friendly type
 310                 ccu.header_c_types.add("#ifndef NIT_TYPE_{cname}\n")
 311                 ccu.header_c_types.add("#define NIT_TYPE_{cname} 1\n")
 312                 ccu.header_c_types.add("typedef struct nitni_instance *{cname};\n")
 313                 ccu.header_c_types.add("#endif\n")
 314         end
 315
 316         private fun compile_extern_helper_functions(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 317         do
 318                 # actually, we do not need to do anything when using the bohem garbage collector
 319
 320                 # incr_ref
 321                 var nitni_visitor = v.compiler.new_visitor
 322                 ccu.header_decl.add("#define {mangled_cname}_incr_ref(from) while(0)\{\}\n")
 323
 324                 # incr_ref
 325                 nitni_visitor = v.compiler.new_visitor
 326                 ccu.header_decl.add("#define {mangled_cname}_decr_ref(from) while(0)\{\}\n")
 327         end
 328 end
 329
 330 redef class MNullableType
 331         redef fun compile_extern_helper_functions(v, ccu)
 332         do
 333                 super
 334
 335                 var base_cname = "null_{mtype.mangled_cname}"
 336                 var full_cname = "NIT_NULL___{base_cname}"
 337
 338                 # In nitni files, declare internal function as extern
 339                 var full_friendly_csignature = "{cname_blind} {full_cname}()"
 340                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 341
 342                 # In nitni files, #define friendly as extern
 343                 ccu.header_decl.add("#define {base_cname} {full_cname}\n")
 344
 345                 # FIXME: This is ugly an broke the separate compilation principle
 346                 # The real function MUST be compiled only once, #define pragma only protect the compiler, not the loader
 347                 # However, I am not sure of the right approach here (eg. week refs are ugly)
 348                 if v.compiler.compiled_null_types.has(self) then return
 349                 v.compiler.compiled_null_types.add self
 350
 351                 # Internally, implement internal function
 352                 var nitni_visitor = v.compiler.new_visitor
 353                 nitni_visitor.frame = v.frame
 354                 var full_internal_csignature = "{cname_blind} {full_cname}()"
 355                 nitni_visitor.add("{full_internal_csignature} \{")
 356                 nitni_visitor.add("struct nitni_instance* ret_for_c;")
 357                 nitni_visitor.add("ret_for_c = malloc(sizeof(struct nitni_instance));")
 358                 nitni_visitor.add("ret_for_c->value = NULL;")
 359                 nitni_visitor.add("return ret_for_c;")
 360                 nitni_visitor.add("\}")
 361         end
 362 end
 363
 364 redef class MExplicitCall
 365         private fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 366         do
 367                 var mproperty = mproperty
 368                 assert mproperty isa MMethod
 369
 370                 # In nitni files, declare internal function as extern
 371                 var full_friendly_csignature = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)
 372                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 373
 374                 # Internally, implement internal function
 375                 var nitni_visitor = v.compiler.new_visitor
 376                 nitni_visitor.frame = v.frame
 377                 var msignature = mproperty.lookup_first_definition(v.compiler.mainmodule, recv_mtype).msignature
 378                 var csignature_blind = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)
 379
 380                 nitni_visitor.add_decl("/* nitni callback for {mproperty.full_name} */")
 381                 nitni_visitor.add_decl("{csignature_blind} \{")
 382
 383                 var vars = new Array[RuntimeVariable]
 384                 var mtype: MType = recv_mtype
 385                 var recv_var = null
 386                 if mproperty.is_init then
 387                         if recv_mtype.mclass.kind == extern_kind then
 388                                 recv_var = nitni_visitor.new_var(mtype)
 389                         else
 390                                 var recv_mtype = recv_mtype
 391                                 recv_var = nitni_visitor.init_instance(recv_mtype)
 392                                 nitni_visitor.add("{mtype.ctype} recv /* var self: {mtype} */;")
 393                                 nitni_visitor.add("recv = {recv_var};")
 394                         end
 395                 else
 396                         mtype = mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
 397                         recv_var = nitni_visitor.var_from_c("recv", mtype)
 398                 end
 399
 400                 vars.add(recv_var)
 401
 402                 for p in msignature.mparameters do
 403                         var arg_mtype = p.mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
 404                         var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
 405                         vars.add(arg)
 406                 end
 407
 408                 var ret_var = nitni_visitor.send(mproperty, vars)
 409
 410                 var return_mtype = msignature.return_mtype
 411                 if mproperty.is_init then
 412                         if recv_mtype.mclass.kind != extern_kind then ret_var = recv_var
 413                         return_mtype = recv_mtype
 414                 end
 415                 if return_mtype != null then
 416                         assert ret_var != null
 417                         return_mtype = return_mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
 418                         ret_var = nitni_visitor.autobox(ret_var, return_mtype)
 419                         nitni_visitor.ret_to_c(ret_var, return_mtype)
 420                 end
 421                 nitni_visitor.add("\}")
 422         end
 423 end
 424
 425 redef class MExplicitSuper
 426         private fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 427         do
 428                 var mproperty = from.mproperty
 429                 assert mproperty isa MMethod
 430                 var mclass_type = from.mclassdef.mclass.mclass_type
 431                 var mmodule = from.mclassdef.mmodule
 432
 433                 # In nitni files, declare internal function as extern
 434                 var internal_csignature = mproperty.build_csignature(mclass_type, v.compiler.mainmodule, "___super", long_signature, internal_call_context)
 435                 ccu.header_decl.add("extern {internal_csignature};\n")
 436
 437                 # In nitni files, #define friendly as extern
 438                 var friendly_cname = mproperty.build_cname(mclass_type, v.compiler.mainmodule, "___super", short_signature)
 439                 var internal_cname = mproperty.build_cname(mclass_type, v.compiler.mainmodule, "___super", long_signature)
 440                 ccu.header_decl.add("#define {friendly_cname} {internal_cname}\n")
 441
 442                 # Internally, implement internal function
 443                 var nitni_visitor = v.compiler.new_visitor
 444                 nitni_visitor.frame = v.frame
 445                 var msignature = mproperty.lookup_first_definition(v.compiler.mainmodule, mclass_type).msignature
 446
 447                 var csignature_blind = mproperty.build_csignature(mclass_type, v.compiler.mainmodule, "___super", long_signature, internal_call_context)
 448
 449                 nitni_visitor.add_decl("/* nitni callback to super for {mproperty.full_name} */")
 450                 nitni_visitor.add_decl("{csignature_blind} \{")
 451
 452                 var vars = new Array[RuntimeVariable]
 453
 454                 var recv_var = nitni_visitor.var_from_c("recv", mclass_type)
 455                 vars.add(recv_var)
 456
 457                 for p in msignature.mparameters do
 458                         var arg_mtype = v.anchor(p.mtype)
 459                         var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
 460                         vars.add(arg)
 461                 end
 462
 463                 var ret_var = nitni_visitor.supercall(from.as(MMethodDef), mclass_type, vars)
 464
 465                 var return_mtype = msignature.return_mtype
 466                 if return_mtype != null then
 467                         assert ret_var != null
 468                         return_mtype = v.anchor(return_mtype)
 469                         nitni_visitor.ret_to_c(ret_var, return_mtype)
 470                 end
 471                 nitni_visitor.add("\}")
 472         end
 473 end
 474
 475 redef class MExplicitCast
 476         private fun compile_extern_callbacks(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 477         do
 478                 var from = from
 479                 var to = to
 480
 481                 #
 482                 ## check type
 483                 #
 484
 485                 # In nitni files, declare internal function as extern
 486                 var full_friendly_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({from.cname_blind})"
 487                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 488
 489                 # In nitni files, #define friendly as extern
 490                 ccu.header_decl.add("#define {check_cname} {v.compiler.mainmodule.name}___{check_cname}\n")
 491
 492                 # Internally, implement internal function
 493                 var nitni_visitor = v.compiler.new_visitor
 494                 nitni_visitor.frame = v.frame
 495
 496                 var full_internal_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({from.cname_blind} from)"
 497                 nitni_visitor.add_decl("/* nitni check for {from} to {to} */")
 498                 nitni_visitor.add_decl("{full_internal_csignature} \{")
 499
 500                 var from_var = new RuntimeVariable("from->value", from, from)
 501                 var recv_var = nitni_visitor.type_test(from_var, to, "FFI isa")
 502                 nitni_visitor.add("return {recv_var};")
 503
 504                 nitni_visitor.add("\}")
 505
 506                 # special checks
 507                 if from == to.as_nullable then
 508                         # format A_is_null
 509                         ccu.header_decl.add("#define {from.mangled_cname}_is_null !{from.mangled_cname}_is_a_{to.mangled_cname}\n")
 510                 end
 511
 512                 #
 513                 ## cast
 514                 #
 515
 516                 # In nitni files, declare internal function as extern
 517                 full_friendly_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({from.cname_blind})"
 518                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 519
 520                 # In nitni files, #define friendly as extern
 521                 ccu.header_decl.add("#define {cast_cname} {v.compiler.mainmodule.name}___{cast_cname}\n")
 522
 523                 # Internally, implement internal function
 524                 nitni_visitor = v.compiler.new_visitor
 525                 nitni_visitor.frame = v.frame
 526
 527                 full_internal_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({from.cname_blind} from)"
 528                 nitni_visitor.add_decl("/* nitni cast for {from} to {to} */")
 529                 nitni_visitor.add_decl("{full_internal_csignature} \{")
 530
 531                 from_var = nitni_visitor.var_from_c("from", from)
 532
 533                 ## test type
 534                 var check = nitni_visitor.type_test(from_var, to, "FFI cast")
 535                 nitni_visitor.add("if (!{check}) \{")
 536                 nitni_visitor.add_abort("FFI cast failed")
 537                 nitni_visitor.add("\}")
 538
 539                 ## internal cast
 540                 recv_var = nitni_visitor.autobox(from_var, to)
 541
 542                 nitni_visitor.ret_to_c(recv_var, to)
 543
 544                 nitni_visitor.add("\}")
 545
 546                 # special casts
 547                 if from.as_nullable == to then
 548                         # format A_as_nullable
 549                         ccu.header_decl.add("#define {from.mangled_cname}_as_nullable {from.mangled_cname}_as_{to.mangled_cname}\n")
 550                 end
 551
 552                 if from == to.as_nullable then
 553                         # format A_as_nullable
 554                         ccu.header_decl.add("#define {to.mangled_cname}_as_not_nullable {from.mangled_cname}_as_{to.mangled_cname}\n")
 555                 end
 556         end
 557 end