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