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 AModule
  25         private var foreign_callbacks = new ForeignCallbackSet
  26         var nitni_ccu: nullable CCompilationUnit = null
  27
  28         redef var uses_legacy_ni: Bool = false
  29
  30         redef fun finalize_ffi(v: AbstractCompilerVisitor, modelbuilder: ModelBuilder)
  31         do
  32                 finalize_ffi_wrapper(v.compiler.modelbuilder.compile_dir, v.compiler.mainmodule)
  33                 for file in ffi_files do v.compiler.extern_bodies.add(file)
  34         end
  35
  36         fun ensure_compile_nitni_base(v: AbstractCompilerVisitor)
  37         do
  38                 if nitni_ccu != null then return
  39
  40                 nitni_ccu = new CCompilationUnit
  41         end
  42
  43         redef fun finalize_nitni(v: AbstractCompilerVisitor)
  44         do
  45                 ensure_compile_nitni_base(v)
  46
  47                 nitni_ccu.header_c_types.add("#include \"{mmodule.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         end
  55
  56         var compiled_callbacks: Array[NitniCallback] = new Array[NitniCallback]
  57
  58         # Returns true if callbacks has yet to be generated and register it as being generated
  59         fun check_callback_compilation(cb: NitniCallback): Bool
  60         do
  61                 var compiled = compiled_callbacks.has(cb)
  62                 if not compiled then compiled_callbacks.add(cb)
  63                 return not compiled
  64         end
  65 end
  66
  67 redef class AExternPropdef
  68         fun compile_ffi_support_to_c(v: AbstractCompilerVisitor)
  69         do
  70                 var mmodule = mpropdef.mclassdef.mmodule
  71                 var amainmodule = v.compiler.modelbuilder.mmodule2nmodule[v.compiler.mainmodule]
  72                 var amodule = v.compiler.modelbuilder.mmodule2nmodule[mmodule]
  73                 var mclass_type = mpropdef.mclassdef.bound_mtype
  74
  75                 # Declare as extern
  76                 var csignature = mpropdef.mproperty.build_csignature(mclass_type, mmodule, "___impl", long_signature, internal_call_context)
  77                 v.declare_once("{csignature};")
  78
  79                 # FFI part
  80                 compile_ffi_method(amodule)
  81
  82                 # nitni - Compile missing callbacks
  83                 amodule.ensure_compile_nitni_base(v)
  84                 var ccu = amodule.nitni_ccu.as(not null)
  85
  86                 for mtype in foreign_callbacks.types do
  87                         if not mtype.is_cprimitive then
  88                                 mtype.compile_extern_type(v, ccu)
  89
  90                                 # has callbacks already been compiled? (this may very well happen with global compilation)
  91                                 if amodule.check_callback_compilation(mtype) then mtype.compile_extern_helper_functions(v, ccu)
  92                         end
  93                 end
  94
  95                 # compile callbacks
  96                 for cb in foreign_callbacks.callbacks do if amainmodule.check_callback_compilation(cb) then
  97                         cb.compile_extern_callback(v, ccu)
  98                 end
  99
 100                 for cb in foreign_callbacks.supers do if amainmodule.check_callback_compilation(cb) then
 101                         cb.compile_extern_callback(v, ccu)
 102                 end
 103
 104                 for cb in foreign_callbacks.casts do if amainmodule.check_callback_compilation(cb) then
 105                         cb.compile_extern_callbacks(v, ccu)
 106                 end
 107
 108                 # manage nitni callback set
 109                 amodule.foreign_callbacks.join(foreign_callbacks)
 110         end
 111 end
 112
 113 redef class AExternMethPropdef
 114         redef fun compile_to_c(v, mpropdef, arguments)
 115         do
 116                 var mmodule = mpropdef.mclassdef.mmodule
 117                 var amodule = v.compiler.modelbuilder.mmodule2nmodule[mmodule]
 118
 119                 # if using the old native interface fallback on previous implementation
 120                 var nextern = self.n_extern
 121                 if nextern != null then
 122                         amodule.uses_legacy_ni = true
 123                         super
 124                         return
 125                 end
 126
 127                 if not v.compiler.supports_ffi then
 128                         super
 129                         return
 130                 end
 131
 132                 amodule.mmodule.uses_ffi = true
 133
 134                 var mclass_type = mpropdef.mclassdef.bound_mtype
 135
 136                 # Outgoing code in compiler
 137                 var externname = mpropdef.mproperty.build_cname(mpropdef.mclassdef.bound_mtype, mmodule, "___impl", long_signature)
 138                 var recv_var: nullable RuntimeVariable = null
 139                 var return_mtype = mpropdef.msignature.return_mtype
 140                 if return_mtype != null then
 141                         return_mtype = return_mtype.anchor_to(mmodule, mclass_type)
 142                         recv_var = v.new_var(return_mtype)
 143                 end
 144
 145                 v.adapt_signature(mpropdef, arguments)
 146
 147                 var arguments_for_c = new Array[String]
 148                 for a in [0..arguments.length[ do
 149                         var arg = arguments[a]
 150                         var param_mtype: MType
 151                         if a == 0 then
 152                                 param_mtype = mpropdef.mclassdef.mclass.mclass_type
 153                         else param_mtype = mpropdef.msignature.mparameters[a-1].mtype
 154
 155                         param_mtype = param_mtype.anchor_to(mmodule, mclass_type)
 156
 157                         if param_mtype.is_cprimitive then
 158                                 arguments_for_c.add(arg.name)
 159                         else
 160                                 v.add("struct nitni_instance* var_for_c_{a};")
 161                                 v.add("var_for_c_{a} = malloc(sizeof(struct nitni_instance));")
 162                                 v.add("var_for_c_{a}->value = {arg.name};")
 163                                 arguments_for_c.add("var_for_c_{a}")
 164                         end
 165                 end
 166
 167                 if recv_var == null then
 168                         v.add("{externname}({arguments_for_c.join(", ")});")
 169                 else
 170                         assert return_mtype != null
 171                         if return_mtype.is_cprimitive then
 172                                 v.add("{recv_var} = {externname}({arguments_for_c.join(", ")});")
 173                         else
 174                                 v.add("struct nitni_instance* ret_var;")
 175                                 v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
 176                                 v.add("{recv_var} = ret_var->value;")
 177                         end
 178                         v.ret(recv_var)
 179                 end
 180
 181                 compile_ffi_support_to_c(v)
 182         end
 183 end
 184
 185 redef class AExternInitPropdef
 186         redef fun compile_to_c(v, mpropdef, arguments)
 187         do
 188                 var mmodule = mpropdef.mclassdef.mmodule
 189                 var amodule = v.compiler.modelbuilder.mmodule2nmodule[mmodule]
 190
 191                 # if using the old native interface fallback on previous implementation
 192                 var nextern = self.n_extern
 193                 if nextern != null then
 194                         amodule.uses_legacy_ni = true
 195                         super
 196                         return
 197                 end
 198
 199                 if not v.compiler.supports_ffi then
 200                         super
 201                         return
 202                 end
 203
 204                 amodule.mmodule.uses_ffi = true
 205
 206                 var mclass_type = mpropdef.mclassdef.bound_mtype
 207
 208                 var externname = mpropdef.mproperty.build_cname(mpropdef.mclassdef.bound_mtype, mmodule, "___impl", long_signature)
 209                 var return_mtype = arguments.first.mtype
 210                 var recv_var = v.new_var(return_mtype)
 211
 212                 v.adapt_signature(mpropdef, arguments)
 213
 214                 arguments.shift
 215
 216                 var arguments_for_c = new Array[String]
 217                 for a in [0..arguments.length[ do
 218                         var arg = arguments[a]
 219                         var param_mtype: MType
 220                         param_mtype = mpropdef.msignature.mparameters[a].mtype
 221                         param_mtype = param_mtype.anchor_to(mmodule, mclass_type)
 222
 223                         if param_mtype.is_cprimitive then
 224                                 arguments_for_c.add(arg.name)
 225                         else
 226                                 v.add("struct nitni_instance* var_for_c_{a};")
 227                                 v.add("var_for_c_{a} = malloc(sizeof(struct nitni_instance));")
 228                                 v.add("var_for_c_{a}->value = {arg.name};")
 229                                 arguments_for_c.add("var_for_c_{a}")
 230                         end
 231                 end
 232
 233                 if return_mtype.is_cprimitive then
 234                         v.add("{recv_var} = {externname}({arguments_for_c.join(", ")});")
 235                 else
 236                         v.add("struct nitni_instance* ret_var;")
 237                         v.add("ret_var = {externname}({arguments_for_c.join(", ")});")
 238                         v.add("{recv_var} = ret_var->value;")
 239                 end
 240                 v.ret(recv_var)
 241
 242                 compile_ffi_support_to_c(v)
 243         end
 244 end
 245
 246 redef class CCompilationUnit
 247         fun write_as_nitni(amodule: AModule, compdir: String)
 248         do
 249                 var base_name = "{amodule.mmodule.name}._nitni"
 250
 251                 var h_file = "{base_name}.h"
 252                 write_header_to_file( amodule, "{compdir}/{h_file}", new Array[String],
 253                         "{amodule.cname.to_s.to_upper}_NITG_NITNI_H")
 254
 255                 var c_file = "{base_name}.c"
 256                 write_body_to_file( amodule, "{compdir}/{c_file}", ["\"{h_file}\""] )
 257
 258                 files.add( "{compdir}/{c_file}" )
 259         end
 260 end
 261
 262 redef class AbstractCompilerVisitor
 263         # Create a `RuntimeVariable` for this C variable originating from C user code
 264         private fun var_from_c(name: String, mtype: MType): RuntimeVariable
 265         do
 266                 if mtype.is_cprimitive then
 267                         return new RuntimeVariable(name, mtype, mtype)
 268                 else
 269                         return new RuntimeVariable("{name}->value", mtype, mtype)
 270                 end
 271         end
 272
 273         # Return a `RuntimeVarible` to C user code
 274         private fun ret_to_c(src: RuntimeVariable, mtype: MType)
 275         do
 276                 if mtype.is_cprimitive then
 277                         add("return {src};")
 278                 else
 279                         add("struct nitni_instance* ret_for_c;")
 280                         add("ret_for_c = malloc(sizeof(struct nitni_instance));")
 281                         add("ret_for_c->value = {src};")
 282                         add("return ret_for_c;")
 283                 end
 284         end
 285 end
 286
 287 redef class MType
 288         fun compile_extern_type(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 289         do
 290                 assert not is_cprimitive
 291
 292                 # define friendly type
 293                 ccu.header_c_types.add("#ifndef NIT_TYPE_{cname}\n")
 294                 ccu.header_c_types.add("#define NIT_TYPE_{cname} 1\n")
 295                 ccu.header_c_types.add("typedef struct nitni_instance *{cname};\n")
 296                 ccu.header_c_types.add("#endif\n")
 297         end
 298
 299         fun compile_extern_helper_functions(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 300         do
 301                 # actually, we do not need to do anything when using the bohem garbage collector
 302
 303                 # incr_ref
 304                 var nitni_visitor = v.compiler.new_visitor
 305                 ccu.header_decl.add("#define {mangled_cname}_incr_ref(from) while(0)\{\}\n")
 306
 307                 # incr_ref
 308                 nitni_visitor = v.compiler.new_visitor
 309                 ccu.header_decl.add("#define {mangled_cname}_decr_ref(from) while(0)\{\}\n")
 310         end
 311 end
 312
 313 redef class MNullableType
 314         redef fun compile_extern_helper_functions(v, ccu)
 315         do
 316                 super
 317
 318                 # In nitni files, declare internal function as extern
 319                 var full_friendly_csignature = "{cname} {v.compiler.mainmodule.name}___null_{mtype.mangled_cname}()"
 320                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 321
 322                 # In nitni files, #define friendly as extern
 323                 var base_cname = "null_{mtype.mangled_cname}"
 324                 ccu.header_decl.add("#define {base_cname} {v.compiler.mainmodule.name}___{base_cname}\n")
 325
 326                 # Internally, implement internal function
 327                 var nitni_visitor = v.compiler.new_visitor
 328                 nitni_visitor.frame = v.frame
 329                 var full_internal_csignature = "{cname_blind} {v.compiler.mainmodule.name}___null_{mtype.mangled_cname}()"
 330                 nitni_visitor.add("#ifndef NIT_NULL_null_{mtype.mangled_cname}")
 331                 nitni_visitor.add("#define NIT_NULL_null_{mtype.mangled_cname}")
 332                 nitni_visitor.add("{full_internal_csignature} \{")
 333                 nitni_visitor.add("struct nitni_instance* ret_for_c;")
 334                 nitni_visitor.add("ret_for_c = malloc(sizeof(struct nitni_instance));")
 335                 nitni_visitor.add("ret_for_c->value = NULL;")
 336                 nitni_visitor.add("return ret_for_c;")
 337                 nitni_visitor.add("\}")
 338                 nitni_visitor.add("#endif")
 339         end
 340 end
 341
 342 redef class MExplicitCall
 343         fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 344         do
 345                 var mproperty = mproperty
 346                 assert mproperty isa MMethod
 347
 348                 # In nitni files, declare internal function as extern
 349                 var full_friendly_csignature = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)
 350                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 351
 352                 # Internally, implement internal function
 353                 var nitni_visitor = v.compiler.new_visitor
 354                 nitni_visitor.frame = v.frame
 355                 var msignature = mproperty.intro.msignature
 356                 var csignature_blind = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)
 357
 358                 nitni_visitor.add_decl("/* nitni callback for {mproperty.full_name} */")
 359                 nitni_visitor.add_decl("{csignature_blind} \{")
 360
 361                 var vars = new Array[RuntimeVariable]
 362                 var mtype: MType = recv_mtype
 363                 var recv_var = null
 364                 if mproperty.is_init then
 365                         if recv_mtype.mclass.kind == extern_kind then
 366                                 recv_var = nitni_visitor.new_var(mtype)
 367                         else
 368                                 var recv_mtype = recv_mtype
 369                                 recv_var = nitni_visitor.init_instance(recv_mtype)
 370                                 nitni_visitor.add("{mtype.ctype} recv /* var self: {mtype} */;")
 371                                 nitni_visitor.add("recv = {recv_var};")
 372                         end
 373                 else
 374                         mtype = mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
 375                         recv_var = nitni_visitor.var_from_c("recv", mtype)
 376                 end
 377
 378                 vars.add(recv_var)
 379
 380                 for p in msignature.mparameters do
 381                         var arg_mtype = p.mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
 382                         var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
 383                         vars.add(arg)
 384                 end
 385
 386                 var ret_var = nitni_visitor.send(mproperty, vars)
 387
 388                 var return_mtype = msignature.return_mtype
 389                 if mproperty.is_init then
 390                         if recv_mtype.mclass.kind != extern_kind then ret_var = recv_var
 391                         return_mtype = recv_mtype
 392                 end
 393                 if return_mtype != null then
 394                         assert ret_var != null
 395                         return_mtype = return_mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
 396                         nitni_visitor.ret_to_c(ret_var, return_mtype)
 397                 end
 398                 nitni_visitor.add("\}")
 399         end
 400 end
 401
 402 redef class MExplicitSuper
 403         fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 404         do
 405                 var mproperty = from.mproperty
 406                 assert mproperty isa MMethod
 407                 var mclass_type = from.mclassdef.mclass.mclass_type
 408                 var mmodule = from.mclassdef.mmodule
 409
 410                 # In nitni files, declare internal function as extern
 411                 var internal_csignature = mproperty.build_csignature(mclass_type, v.compiler.mainmodule, null, long_signature, from_c_call_context)
 412                 ccu.header_decl.add("extern {internal_csignature};\n")
 413
 414                 # In nitni files, #define friendly as extern
 415                 var friendly_cname = mproperty.build_cname(mclass_type, v.compiler.mainmodule, "___super", short_signature)
 416                 var internal_cname = mproperty.build_cname(mclass_type, v.compiler.mainmodule, "___super", long_signature)
 417                 ccu.header_decl.add("#define {friendly_cname} {internal_cname}\n")
 418
 419                 # Internally, implement internal function
 420                 var nitni_visitor = v.compiler.new_visitor
 421                 nitni_visitor.frame = v.frame
 422                 var msignature = mproperty.intro.msignature
 423
 424                 var csignature_blind = mproperty.build_csignature(mclass_type, v.compiler.mainmodule, "___super", long_signature, internal_call_context)
 425
 426                 nitni_visitor.add_decl("/* nitni callback to super for {mproperty.full_name} */")
 427                 nitni_visitor.add_decl("{csignature_blind} \{")
 428
 429                 var vars = new Array[RuntimeVariable]
 430
 431                 var recv_var = nitni_visitor.var_from_c("recv", mclass_type)
 432                 vars.add(recv_var)
 433
 434                 for p in msignature.mparameters do
 435                         var arg_mtype = v.anchor(p.mtype)
 436                         var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
 437                         vars.add(arg)
 438                 end
 439
 440                 var ret_var = nitni_visitor.supercall(from.as(MMethodDef), mclass_type, vars)
 441
 442                 var return_mtype = msignature.return_mtype
 443                 if return_mtype != null then
 444                         assert ret_var != null
 445                         return_mtype = v.anchor(return_mtype)
 446                         nitni_visitor.ret_to_c(ret_var, return_mtype)
 447                 end
 448                 nitni_visitor.add("\}")
 449         end
 450 end
 451
 452 redef class MExplicitCast
 453         fun compile_extern_callbacks(v: AbstractCompilerVisitor, ccu: CCompilationUnit)
 454         do
 455                 var from = from
 456                 var to = to
 457
 458                 #
 459                 ## check type
 460                 #
 461
 462                 # In nitni files, declare internal function as extern
 463                 var full_friendly_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({from.cname_blind})"
 464                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 465
 466                 # In nitni files, #define friendly as extern
 467                 ccu.header_decl.add("#define {check_cname} {v.compiler.mainmodule.name}___{check_cname}\n")
 468
 469                 # Internally, implement internal function
 470                 var nitni_visitor = v.compiler.new_visitor
 471                 nitni_visitor.frame = v.frame
 472
 473                 var full_internal_csignature = "int {v.compiler.mainmodule.name }___{from.mangled_cname}_is_a_{to.mangled_cname}({from.cname_blind} from)"
 474                 nitni_visitor.add_decl("/* nitni check for {from} to {to} */")
 475                 nitni_visitor.add_decl("{full_internal_csignature} \{")
 476
 477                 var from_var = new RuntimeVariable("from->value", from, from)
 478                 var recv_var = nitni_visitor.type_test(from_var, to, "FFI isa")
 479                 nitni_visitor.add("return {recv_var};")
 480
 481                 nitni_visitor.add("\}")
 482
 483                 # special checks
 484                 if from == to.as_nullable then
 485                         # format A_is_null
 486                         ccu.header_decl.add("#define {from.mangled_cname}_is_null !{from.mangled_cname}_is_a_{to.mangled_cname}\n")
 487                 end
 488
 489                 #
 490                 ## cast
 491                 #
 492
 493                 # In nitni files, declare internal function as extern
 494                 full_friendly_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({from.cname_blind})"
 495                 ccu.header_decl.add("extern {full_friendly_csignature};\n")
 496
 497                 # In nitni files, #define friendly as extern
 498                 ccu.header_decl.add("#define {cast_cname} {v.compiler.mainmodule.name}___{cast_cname}\n")
 499
 500                 # Internally, implement internal function
 501                 nitni_visitor = v.compiler.new_visitor
 502                 nitni_visitor.frame = v.frame
 503
 504                 full_internal_csignature = "{to.cname_blind} {v.compiler.mainmodule.name }___{from.mangled_cname}_as_{to.mangled_cname}({from.cname_blind} from)"
 505                 nitni_visitor.add_decl("/* nitni cast for {from} to {to} */")
 506                 nitni_visitor.add_decl("{full_internal_csignature} \{")
 507
 508                 from_var = nitni_visitor.var_from_c("from", from)
 509
 510                 ## test type
 511                 var check = nitni_visitor.type_test(from_var, to, "FFI cast")
 512                 nitni_visitor.add("if (!{check}) \{")
 513                 nitni_visitor.add_abort("FFI cast failed")
 514                 nitni_visitor.add("\}")
 515
 516                 ## internal cast
 517                 recv_var = nitni_visitor.autobox(from_var, to)
 518
 519                 nitni_visitor.ret_to_c(recv_var, to)
 520
 521                 nitni_visitor.add("\}")
 522
 523                 # special casts
 524                 if from.as_nullable == to then
 525                         # format A_as_nullable
 526                         ccu.header_decl.add("#define {from.mangled_cname}_as_nullable {from.mangled_cname}_as_{to.mangled_cname}\n")
 527                 end
 528
 529                 if from == to.as_nullable then
 530                         # format A_as_nullable
 531                         ccu.header_decl.add("#define {to.mangled_cname}_as_not_nullable {from.mangled_cname}_as_{to.mangled_cname}\n")
 532                 end
 533         end
 534 end