src/compiler/global_compiler.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Copyright 2012 Jean Privat <jean@pryen.org>
   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 # Global compilation of a Nit program
  18 #
  19 # Techniques used are:
  20 #   * heterogeneous generics
  21 #   * customization
  22 #   * switch dispatch
  23 #   * inlining
  24 module global_compiler
  25
  26 import abstract_compiler
  27 import rapid_type_analysis
  28
  29 redef class ToolContext
  30         # option --global
  31         var opt_global = new OptionBool("Use global compilation", "--global")
  32
  33         var global_compiler_phase = new GlobalCompilerPhase(self, null)
  34
  35         redef init do
  36                 super
  37                 option_context.add_option(opt_global)
  38         end
  39 end
  40
  41 class GlobalCompilerPhase
  42         super Phase
  43         redef fun process_mainmodule(mainmodule, given_mmodules) do
  44                 if not toolcontext.opt_global.value then return
  45
  46                 var modelbuilder = toolcontext.modelbuilder
  47                 var analysis = modelbuilder.do_rapid_type_analysis(mainmodule)
  48                 modelbuilder.run_global_compiler(mainmodule, analysis)
  49         end
  50 end
  51
  52 redef class ModelBuilder
  53         # Entry point to performs a global compilation on the AST of a complete program.
  54         # `mainmodule` is the main module of the program
  55         # `runtime_type_analysis` is a already computer type analysis.
  56         fun run_global_compiler(mainmodule: MModule, runtime_type_analysis: RapidTypeAnalysis)
  57         do
  58                 var time0 = get_time
  59                 self.toolcontext.info("*** GENERATING C ***", 1)
  60
  61                 var compiler = new GlobalCompiler(mainmodule, self, runtime_type_analysis)
  62                 compiler.do_compilation
  63                 compiler.display_stats
  64
  65                 var time1 = get_time
  66                 self.toolcontext.info("*** END GENERATING C: {time1-time0} ***", 2)
  67                 write_and_make(compiler)
  68         end
  69 end
  70
  71 # Compiler that use global compilation and perform hard optimisations like:
  72 #   * customization
  73 #   * switch dispatch
  74 #   * inlining
  75 class GlobalCompiler
  76         super AbstractCompiler
  77
  78         redef type VISITOR: GlobalCompilerVisitor
  79
  80         # The result of the RTA (used to know live types and methods)
  81         var runtime_type_analysis: RapidTypeAnalysis
  82
  83         init
  84         do
  85                 var file = new_file("{mainmodule.c_name}.nitgg")
  86                 self.header = new CodeWriter(file)
  87                 self.live_primitive_types = new Array[MClassType]
  88                 for t in runtime_type_analysis.live_types do
  89                         if t.ctype != "val*" or t.mclass.name == "Pointer" then
  90                                 self.live_primitive_types.add(t)
  91                         end
  92                 end
  93         end
  94
  95         redef fun do_compilation
  96         do
  97                 var compiler = self
  98
  99                 compiler.compile_header
 100
 101                 if mainmodule.model.get_mclasses_by_name("Pointer") != null then
 102                         runtime_type_analysis.live_types.add(mainmodule.pointer_type)
 103                 end
 104                 for t in runtime_type_analysis.live_types do
 105                         compiler.declare_runtimeclass(t)
 106                 end
 107
 108                 compiler.compile_class_names
 109
 110                 # Init instance code (allocate and init-arguments)
 111                 for t in runtime_type_analysis.live_types do
 112                         if t.ctype == "val*" then
 113                                 compiler.generate_init_instance(t)
 114                                 if t.mclass.kind == extern_kind then
 115                                         compiler.generate_box_instance(t)
 116                                 end
 117                         else
 118                                 compiler.generate_box_instance(t)
 119                         end
 120                 end
 121
 122                 # The main function of the C
 123                 compiler.compile_nitni_global_ref_functions
 124                 compiler.compile_main_function
 125
 126                 # Compile until all runtime_functions are visited
 127                 while not compiler.todos.is_empty do
 128                         var m = compiler.todos.shift
 129                         modelbuilder.toolcontext.info("Compile {m} ({compiler.seen.length-compiler.todos.length}/{compiler.seen.length})", 3)
 130                         m.compile_to_c(compiler)
 131                 end
 132                 modelbuilder.toolcontext.info("Total methods to compile to C: {compiler.seen.length}", 2)
 133
 134         end
 135
 136         # Compile class names (for the class_name and output_class_name methods)
 137         protected fun compile_class_names do
 138                 var v = new_visitor
 139                 self.header.add_decl("extern const char *class_names[];")
 140                 v.add("const char *class_names[] = \{")
 141                 for t in self.runtime_type_analysis.live_types do
 142                         v.add("\"{t}\", /* {self.classid(t)} */")
 143                 end
 144                 v.add("\};")
 145         end
 146
 147         # Return the C symbol associated to a live type runtime
 148         # REQUIRE: self.runtime_type_analysis.live_types.has(mtype)
 149         fun classid(mtype: MClassType): String
 150         do
 151                 if self.classids.has_key(mtype) then
 152                         return self.classids[mtype]
 153                 end
 154                 print "No classid for {mtype}"
 155                 abort
 156         end
 157
 158         # Cache for classid
 159         protected var classids: HashMap[MClassType, String] = new HashMap[MClassType, String]
 160
 161         # Declaration of structures the live Nit types
 162         # Each live type is generated as an independent C `struct` type.
 163         # They only share a common first field `classid` used to implement the polymorphism.
 164         # Usualy, all C variables that refers to a Nit object are typed on the abstract struct `val` that contains only the `classid` field.
 165         redef fun compile_header_structs do
 166                 self.header.add_decl("typedef struct \{int classid;\} val; /* general C type representing a Nit instance. */")
 167         end
 168
 169         # Subset of runtime_type_analysis.live_types that contains only primitive types
 170         # Used to implement the equal test
 171         var live_primitive_types: Array[MClassType] is noinit
 172
 173         # Add a new todo task
 174         fun todo(m: AbstractRuntimeFunction)
 175         do
 176                 if seen.has(m) then return
 177                 todos.add(m)
 178                 seen.add(m)
 179         end
 180
 181         # runtime_functions that need to be compiled
 182         private var todos: List[AbstractRuntimeFunction] = new List[AbstractRuntimeFunction]
 183
 184         # runtime_functions already seen (todo or done)
 185         private var seen: HashSet[AbstractRuntimeFunction] = new HashSet[AbstractRuntimeFunction]
 186
 187         # Declare C structures and identifiers for a runtime class
 188         fun declare_runtimeclass(mtype: MClassType)
 189         do
 190                 var v = self.header
 191                 assert self.runtime_type_analysis.live_types.has(mtype)
 192                 v.add_decl("/* runtime class {mtype} */")
 193                 var idnum = classids.length
 194                 var idname = "ID_" + mtype.c_name
 195                 self.classids[mtype] = idname
 196                 v.add_decl("#define {idname} {idnum} /* {mtype} */")
 197
 198                 v.add_decl("struct {mtype.c_name} \{")
 199                 v.add_decl("int classid; /* must be {idname} */")
 200
 201                 if mtype.mclass.name == "NativeArray" then
 202                         # NativeArrays are just a instance header followed by an array of values
 203                         v.add_decl("int length;")
 204                         v.add_decl("{mtype.arguments.first.ctype} values[1];")
 205                 end
 206
 207                 if mtype.ctype_extern != "val*" then
 208                         # Is the Nit type is native then the struct is a box with two fields:
 209                         # * the `classid` to be polymorph
 210                         # * the `value` that contains the native value.
 211                         v.add_decl("{mtype.ctype_extern} value;")
 212                 end
 213
 214                 # Collect all attributes and associate them a field in the structure.
 215                 # Note: we do not try to optimize the order and helps CC to optimize the client code.
 216                 for cd in mtype.collect_mclassdefs(self.mainmodule) do
 217                         for p in cd.intro_mproperties do
 218                                 if not p isa MAttribute then continue
 219                                 var t = p.intro.static_mtype.as(not null)
 220                                 t = t.anchor_to(self.mainmodule, mtype)
 221                                 v.add_decl("{t.ctype} {p.intro.c_name}; /* {p}: {t} */")
 222                         end
 223                 end
 224                 v.add_decl("\};")
 225         end
 226
 227         # Generate the init-instance of a live type (allocate + init-instance)
 228         fun generate_init_instance(mtype: MClassType)
 229         do
 230                 assert self.runtime_type_analysis.live_types.has(mtype)
 231                 assert mtype.ctype == "val*"
 232                 var v = self.new_visitor
 233
 234                 var is_native_array = mtype.mclass.name == "NativeArray"
 235
 236                 var sig
 237                 if is_native_array then
 238                         sig = "int length"
 239                 else
 240                         sig = "void"
 241                 end
 242
 243                 self.header.add_decl("{mtype.ctype} NEW_{mtype.c_name}({sig});")
 244                 v.add_decl("/* allocate {mtype} */")
 245                 v.add_decl("{mtype.ctype} NEW_{mtype.c_name}({sig}) \{")
 246                 var res = v.new_var(mtype)
 247                 res.is_exact = true
 248                 if is_native_array then
 249                         var mtype_elt = mtype.arguments.first
 250                         v.add("{res} = nit_alloc(sizeof(struct {mtype.c_name}) + length*sizeof({mtype_elt.ctype}));")
 251                         v.add("((struct {mtype.c_name}*){res})->length = length;")
 252                 else
 253                         v.add("{res} = nit_alloc(sizeof(struct {mtype.c_name}));")
 254                 end
 255                 v.add("{res}->classid = {self.classid(mtype)};")
 256
 257                 self.generate_init_attr(v, res, mtype)
 258                 v.set_finalizer res
 259                 v.add("return {res};")
 260                 v.add("\}")
 261         end
 262
 263         fun generate_box_instance(mtype: MClassType)
 264         do
 265                 assert self.runtime_type_analysis.live_types.has(mtype)
 266                 var v = self.new_visitor
 267
 268                 self.header.add_decl("val* BOX_{mtype.c_name}({mtype.ctype});")
 269                 v.add_decl("/* allocate {mtype} */")
 270                 v.add_decl("val* BOX_{mtype.c_name}({mtype.ctype} value) \{")
 271                 v.add("struct {mtype.c_name}*res = nit_alloc(sizeof(struct {mtype.c_name}));")
 272                 v.add("res->classid = {self.classid(mtype)};")
 273                 v.add("res->value = value;")
 274                 v.add("return (val*)res;")
 275                 v.add("\}")
 276         end
 277
 278         redef fun new_visitor do return new GlobalCompilerVisitor(self)
 279
 280         private var collect_types_cache: HashMap[MType, Array[MClassType]] = new HashMap[MType, Array[MClassType]]
 281
 282         redef fun compile_nitni_structs
 283         do
 284                 self.header.add_decl """
 285 struct nitni_instance \{
 286         struct nitni_instance *next,
 287                 *prev; /* adjacent global references in global list */
 288         int count; /* number of time this global reference has been marked */
 289         val *value;
 290 \};"""
 291                 super
 292         end
 293 end
 294
 295 # A visitor on the AST of property definition that generate the C code.
 296 # Because of inlining, a visitor can visit more than one property.
 297 class GlobalCompilerVisitor
 298         super AbstractCompilerVisitor
 299
 300         redef type COMPILER: GlobalCompiler
 301
 302         redef fun autobox(value, mtype)
 303         do
 304                 if value.mtype == mtype then
 305                         return value
 306                 else if value.mtype.ctype == "val*" and mtype.ctype == "val*" then
 307                         return value
 308                 else if value.mtype.ctype == "val*" then
 309                         return self.new_expr("((struct {mtype.c_name}*){value})->value; /* autounbox from {value.mtype} to {mtype} */", mtype)
 310                 else if mtype.ctype == "val*" then
 311                         var valtype = value.mtype.as(MClassType)
 312                         var res = self.new_var(mtype)
 313                         if not compiler.runtime_type_analysis.live_types.has(valtype) then
 314                                 self.add("/*no autobox from {value.mtype} to {mtype}: {value.mtype} is not live! */")
 315                                 self.add("PRINT_ERROR(\"Dead code executed!\\n\"); show_backtrace(1);")
 316                                 return res
 317                         end
 318                         self.add("{res} = BOX_{valtype.c_name}({value}); /* autobox from {value.mtype} to {mtype} */")
 319                         return res
 320                 else if value.mtype.ctype == "void*" and mtype.ctype == "void*" then
 321                         return value
 322                 else
 323                         # Bad things will appen!
 324                         var res = self.new_var(mtype)
 325                         self.add("/* {res} left unintialized (cannot convert {value.mtype} to {mtype}) */")
 326                         self.add("PRINT_ERROR(\"Cast error: Cannot cast %s to %s.\\n\", \"{value.mtype}\", \"{mtype}\"); show_backtrace(1);")
 327                         return res
 328                 end
 329         end
 330
 331         redef fun unbox_extern(value, mtype)
 332         do
 333                 if mtype isa MClassType and mtype.mclass.kind == extern_kind and
 334                    mtype.mclass.name != "NativeString" then
 335                         var res = self.new_var_extern(mtype)
 336                         self.add "{res} = ((struct {mtype.c_name}*){value})->value; /* unboxing {value.mtype} */"
 337                         return res
 338                 else
 339                         return value
 340                 end
 341         end
 342
 343         redef fun box_extern(value, mtype)
 344         do
 345                 if not mtype isa MClassType or mtype.mclass.kind != extern_kind or
 346                         mtype.mclass.name == "NativeString" then return value
 347
 348                 var valtype = value.mtype.as(MClassType)
 349                 var res = self.new_var(mtype)
 350                 if not compiler.runtime_type_analysis.live_types.has(value.mtype.as(MClassType)) then
 351                         self.add("/*no boxing of {value.mtype}: {value.mtype} is not live! */")
 352                         self.add("PRINT_ERROR(\"Dead code executed!\\n\"); show_backtrace(1);")
 353                         return res
 354                 end
 355                 self.add("{res} = BOX_{valtype.c_name}({value}); /* boxing {value.mtype} */")
 356                 return res
 357         end
 358
 359         # The runtime types that are acceptable for a given receiver.
 360         fun collect_types(recv: RuntimeVariable): Array[MClassType]
 361         do
 362                 var mtype = recv.mcasttype
 363                 if recv.is_exact then
 364                         assert mtype isa MClassType
 365                         assert self.compiler.runtime_type_analysis.live_types.has(mtype)
 366                         var types = [mtype]
 367                         return types
 368                 end
 369                 var cache = self.compiler.collect_types_cache
 370                 if cache.has_key(mtype) then
 371                         return cache[mtype]
 372                 end
 373                 var types = new Array[MClassType]
 374                 var mainmodule = self.compiler.mainmodule
 375                 for t in self.compiler.runtime_type_analysis.live_types do
 376                         if not t.is_subtype(mainmodule, null, mtype) then continue
 377                         types.add(t)
 378                 end
 379                 cache[mtype] = types
 380                 return types
 381         end
 382
 383         redef fun native_array_def(pname, ret_type, arguments)
 384         do
 385                 var elttype = arguments.first.mtype
 386                 var recv = "((struct {arguments[0].mcasttype.c_name}*){arguments[0]})->values"
 387                 if pname == "[]" then
 388                         self.ret(self.new_expr("{recv}[{arguments[1]}]", ret_type.as(not null)))
 389                         return
 390                 else if pname == "[]=" then
 391                         self.add("{recv}[{arguments[1]}]={arguments[2]};")
 392                         return
 393                 else if pname == "length" then
 394                         self.ret(self.new_expr("((struct {arguments[0].mcasttype.c_name}*){arguments[0]})->length", ret_type.as(not null)))
 395                         return
 396                 else if pname == "copy_to" then
 397                         var recv1 = "((struct {arguments[1].mcasttype.c_name}*){arguments[1]})->values"
 398                         self.add("memmove({recv1},{recv},{arguments[2]}*sizeof({elttype.ctype}));")
 399                         return
 400                 end
 401         end
 402
 403         redef fun native_array_instance(elttype: MType, length: RuntimeVariable): RuntimeVariable
 404         do
 405                 var ret_type = self.get_class("NativeArray").get_mtype([elttype])
 406                 ret_type = anchor(ret_type).as(MClassType)
 407                 return self.new_expr("NEW_{ret_type.c_name}({length})", ret_type)
 408         end
 409
 410         redef fun calloc_array(ret_type, arguments)
 411         do
 412                 self.ret(self.new_expr("NEW_{ret_type.c_name}({arguments[1]})", ret_type))
 413         end
 414
 415         redef fun send(m, args)
 416         do
 417                 var types = self.collect_types(args.first)
 418
 419                 var res: nullable RuntimeVariable
 420                 var ret = m.intro.msignature.return_mtype
 421                 if ret == null then
 422                         res = null
 423                 else
 424                         ret = self.resolve_for(ret, args.first)
 425                         res = self.new_var(ret)
 426                 end
 427
 428                 self.add("/* send {m} on {args.first.inspect} */")
 429                 if args.first.mtype.ctype != "val*" then
 430                         var mclasstype = args.first.mtype.as(MClassType)
 431                         if not self.compiler.runtime_type_analysis.live_types.has(mclasstype) then
 432                                 self.add("/* skip, no method {m} */")
 433                                 return res
 434                         end
 435                         var propdef = m.lookup_first_definition(self.compiler.mainmodule, mclasstype)
 436                         var res2 = self.call(propdef, mclasstype, args)
 437                         if res != null then self.assign(res, res2.as(not null))
 438                         return res
 439                 end
 440                 var consider_null = not self.compiler.modelbuilder.toolcontext.opt_no_check_null.value or m.name == "==" or m.name == "!="
 441                 if args.first.mcasttype isa MNullableType or args.first.mcasttype isa MNullType and consider_null then
 442                         # The reciever is potentially null, so we have to 3 cases: ==, != or NullPointerException
 443                         self.add("if ({args.first} == NULL) \{ /* Special null case */")
 444                         if m.name == "==" or m.name == "is_same_instance" then
 445                                 assert res != null
 446                                 if args[1].mcasttype isa MNullableType then
 447                                         self.add("{res} = ({args[1]} == NULL);")
 448                                 else if args[1].mcasttype isa MNullType then
 449                                         self.add("{res} = 1; /* is null */")
 450                                 else
 451                                         self.add("{res} = 0; /* {args[1].inspect} cannot be null */")
 452                                 end
 453                         else if m.name == "!=" then
 454                                 assert res != null
 455                                 if args[1].mcasttype isa MNullableType then
 456                                         self.add("{res} = ({args[1]} != NULL);")
 457                                 else if args[1].mcasttype isa MNullType then
 458                                         self.add("{res} = 0; /* is null */")
 459                                 else
 460                                         self.add("{res} = 1; /* {args[1].inspect} cannot be null */")
 461                                 end
 462                         else
 463                                 self.add_abort("Receiver is null")
 464                         end
 465                         self.add "\} else"
 466                 end
 467                 if types.is_empty then
 468                         self.add("\{")
 469                         self.add("/*BUG: no live types for {args.first.inspect} . {m}*/")
 470                         self.bugtype(args.first)
 471                         self.add("\}")
 472                         return res
 473                 end
 474
 475                 self.add("switch({args.first}->classid) \{")
 476                 var last = types.last
 477                 var defaultpropdef: nullable MMethodDef = null
 478                 for t in types do
 479                         var propdef = m.lookup_first_definition(self.compiler.mainmodule, t)
 480                         if propdef.mclassdef.mclass.name == "Object" and t.ctype == "val*" then
 481                                 defaultpropdef = propdef
 482                                 continue
 483                         end
 484                         if not self.compiler.hardening and t == last and defaultpropdef == null then
 485                                 self.add("default: /* test {t} */")
 486                         else
 487                                 self.add("case {self.compiler.classid(t)}: /* test {t} */")
 488                         end
 489                         var res2 = self.call(propdef, t, args)
 490                         if res != null then self.assign(res, res2.as(not null))
 491                         self.add "break;"
 492                 end
 493                 if defaultpropdef != null then
 494                         self.add("default: /* default is Object */")
 495                         var res2 = self.call(defaultpropdef, defaultpropdef.mclassdef.bound_mtype, args)
 496                         if res != null then self.assign(res, res2.as(not null))
 497                 else if self.compiler.hardening then
 498                         self.add("default: /* bug */")
 499                         self.bugtype(args.first)
 500                 end
 501                 self.add("\}")
 502                 return res
 503         end
 504
 505         fun check_valid_reciever(recvtype: MClassType)
 506         do
 507                 if self.compiler.runtime_type_analysis.live_types.has(recvtype) or recvtype.mclass.name == "Object" then return
 508                 print "{recvtype} is not a live type"
 509                 abort
 510         end
 511
 512         # Subpart of old call function
 513         #
 514         # Checks if the type of the receiver is valid and corrects it if necessary
 515         private fun get_recvtype(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): MClassType
 516         do
 517                 check_valid_reciever(recvtype)
 518                 #debug("call {m} on {recvtype} on {args.first}:{args.first.mtype}")
 519                 if m.mproperty.is_toplevel then
 520                         # Do not customize top-level methods
 521                         recvtype = m.mclassdef.bound_mtype
 522                 end
 523                 return recvtype
 524         end
 525
 526         redef fun call(m, recvtype, args)
 527         do
 528                 var recv_type = get_recvtype(m, recvtype, args)
 529                 var recv = self.autoadapt(self.autobox(args.first, recvtype), recvtype)
 530                 if m.is_extern then recv = unbox_extern(recv, recv_type)
 531
 532                 args = args.to_a
 533                 args.first = recv
 534
 535                 assert args.length == m.msignature.arity + 1 else debug("Invalid arity for {m}. {args.length} arguments given.")
 536
 537                 var rm = new CustomizedRuntimeFunction(m, recvtype)
 538                 return rm.call(self, args)
 539         end
 540
 541         redef fun supercall(m: MMethodDef, recvtype: MClassType, args: Array[RuntimeVariable]): nullable RuntimeVariable
 542         do
 543                 var types = self.collect_types(args.first)
 544
 545                 var res: nullable RuntimeVariable
 546                 var ret = m.mproperty.intro.msignature.return_mtype
 547                 if ret == null then
 548                         res = null
 549                 else
 550                         ret = self.resolve_for(ret, args.first)
 551                         res = self.new_var(ret)
 552                 end
 553
 554                 self.add("/* super {m} on {args.first.inspect} */")
 555                 if args.first.mtype.ctype != "val*" then
 556                         var mclasstype = args.first.mtype.as(MClassType)
 557                         if not self.compiler.runtime_type_analysis.live_types.has(mclasstype) then
 558                                 self.add("/* skip, no method {m} */")
 559                                 return res
 560                         end
 561                         var propdef = m.lookup_next_definition(self.compiler.mainmodule, mclasstype)
 562                         var res2 = self.call(propdef, mclasstype, args)
 563                         if res != null then self.assign(res, res2.as(not null))
 564                         return res
 565                 end
 566
 567                 if types.is_empty then
 568                         self.add("\{")
 569                         self.add("/*BUG: no live types for {args.first.inspect} . {m}*/")
 570                         self.bugtype(args.first)
 571                         self.add("\}")
 572                         return res
 573                 end
 574
 575                 self.add("switch({args.first}->classid) \{")
 576                 var last = types.last
 577                 for t in types do
 578                         var propdef = m.lookup_next_definition(self.compiler.mainmodule, t)
 579                         if not self.compiler.hardening and t == last then
 580                                 self.add("default: /* test {t} */")
 581                         else
 582                                 self.add("case {self.compiler.classid(t)}: /* test {t} */")
 583                         end
 584                         var res2 = self.call(propdef, t, args)
 585                         if res != null then self.assign(res, res2.as(not null))
 586                         self.add "break;"
 587                 end
 588                 if self.compiler.hardening then
 589                         self.add("default: /* bug */")
 590                         self.bugtype(args.first)
 591                 end
 592                 self.add("\}")
 593                 return res
 594         end
 595
 596         redef fun adapt_signature(m, args)
 597         do
 598                 var recv = args.first
 599                 for i in [0..m.msignature.arity[ do
 600                         var t = m.msignature.mparameters[i].mtype
 601                         if i == m.msignature.vararg_rank then
 602                                 t = args[i+1].mtype
 603                         end
 604                         t = self.resolve_for(t, recv)
 605                         args[i+1] = self.autobox(args[i+1], t)
 606                 end
 607         end
 608
 609         redef fun unbox_signature_extern(m, args)
 610         do
 611                 var recv = args.first
 612                 for i in [0..m.msignature.arity[ do
 613                         var t = m.msignature.mparameters[i].mtype
 614                         if i == m.msignature.vararg_rank then
 615                                 t = args[i+1].mtype
 616                         end
 617                         t = self.resolve_for(t, recv)
 618                         if m.is_extern then args[i+1] = self.unbox_extern(args[i+1], t)
 619                 end
 620         end
 621
 622         # FIXME: this is currently buggy since recv is not exact
 623         redef fun vararg_instance(mpropdef, recv, varargs, elttype)
 624         do
 625                 elttype = self.resolve_for(elttype, recv)
 626                 return self.array_instance(varargs, elttype)
 627         end
 628
 629         fun bugtype(recv: RuntimeVariable)
 630         do
 631                 if recv.mtype.ctype != "val*" then return
 632                 self.add("PRINT_ERROR(\"BTD BUG: Dynamic type is %s, static type is %s\\n\", class_names[{recv}->classid], \"{recv.mcasttype}\");")
 633                 self.add("show_backtrace(1);")
 634         end
 635
 636         redef fun isset_attribute(a, recv)
 637         do
 638                 check_recv_notnull(recv)
 639
 640                 var types = self.collect_types(recv)
 641                 var res = self.new_var(bool_type)
 642
 643                 if types.is_empty then
 644                         self.add("/*BUG: no live types for {recv.inspect} . {a}*/")
 645                         self.bugtype(recv)
 646                         return res
 647                 end
 648                 self.add("/* isset {a} on {recv.inspect} */")
 649                 self.add("switch({recv}->classid) \{")
 650                 var last = types.last
 651                 for t in types do
 652                         if not self.compiler.hardening and t == last then
 653                                 self.add("default: /*{self.compiler.classid(t)}*/")
 654                         else
 655                                 self.add("case {self.compiler.classid(t)}:")
 656                         end
 657                         var recv2 = self.autoadapt(recv, t)
 658                         var ta = a.intro.static_mtype.as(not null)
 659                         ta = self.resolve_for(ta, recv2)
 660                         var attr = self.new_expr("((struct {t.c_name}*){recv})->{a.intro.c_name}", ta)
 661                         if not ta isa MNullableType then
 662                                 if ta.ctype == "val*" then
 663                                         self.add("{res} = ({attr} != NULL);")
 664                                 else
 665                                         self.add("{res} = 1; /*NOTYET isset on primitive attributes*/")
 666                                 end
 667                         end
 668                         self.add("break;")
 669                 end
 670                 if self.compiler.hardening then
 671                         self.add("default: /* Bug */")
 672                         self.bugtype(recv)
 673                 end
 674                 self.add("\}")
 675
 676                 return res
 677         end
 678
 679         redef fun read_attribute(a, recv)
 680         do
 681                 check_recv_notnull(recv)
 682
 683                 var types = self.collect_types(recv)
 684
 685                 var ret = a.intro.static_mtype.as(not null)
 686                 ret = self.resolve_for(ret, recv)
 687                 var res = self.new_var(ret)
 688
 689                 if types.is_empty then
 690                         self.add("/*BUG: no live types for {recv.inspect} . {a}*/")
 691                         self.bugtype(recv)
 692                         return res
 693                 end
 694                 self.add("/* read {a} on {recv.inspect} */")
 695                 self.add("switch({recv}->classid) \{")
 696                 var last = types.last
 697                 for t in types do
 698                         if not self.compiler.hardening and t == last then
 699                                 self.add("default: /*{self.compiler.classid(t)}*/")
 700                         else
 701                                 self.add("case {self.compiler.classid(t)}:")
 702                         end
 703                         var recv2 = self.autoadapt(recv, t)
 704                         var ta = a.intro.static_mtype.as(not null)
 705                         ta = self.resolve_for(ta, recv2)
 706                         var res2 = self.new_expr("((struct {t.c_name}*){recv})->{a.intro.c_name}", ta)
 707                         if not ta isa MNullableType and not self.compiler.modelbuilder.toolcontext.opt_no_check_attr_isset.value then
 708                                 if ta.ctype == "val*" then
 709                                         self.add("if ({res2} == NULL) \{")
 710                                         self.add_abort("Uninitialized attribute {a.name}")
 711                                         self.add("\}")
 712                                 else
 713                                         self.add("/*NOTYET isset on primitive attributes*/")
 714                                 end
 715                         end
 716                         self.assign(res, res2)
 717                         self.add("break;")
 718                 end
 719                 if self.compiler.hardening then
 720                         self.add("default: /* Bug */")
 721                         self.bugtype(recv)
 722                 end
 723                 self.add("\}")
 724
 725                 return res
 726         end
 727
 728         redef fun write_attribute(a, recv, value)
 729         do
 730                 check_recv_notnull(recv)
 731
 732                 var types = self.collect_types(recv)
 733
 734                 if types.is_empty then
 735                         self.add("/*BUG: no live types for {recv.inspect} . {a}*/")
 736                         self.bugtype(recv)
 737                         return
 738                 end
 739                 self.add("/* write {a} on {recv.inspect} */")
 740                 self.add("switch({recv}->classid) \{")
 741                 var last = types.last
 742                 for t in types do
 743                         if not self.compiler.hardening and t == last then
 744                                 self.add("default: /*{self.compiler.classid(t)}*/")
 745                         else
 746                                 self.add("case {self.compiler.classid(t)}:")
 747                         end
 748                         var recv2 = self.autoadapt(recv, t)
 749                         var ta = a.intro.static_mtype.as(not null)
 750                         ta = self.resolve_for(ta, recv2)
 751                         self.add("((struct {t.c_name}*){recv})->{a.intro.c_name} = {self.autobox(value, ta)};")
 752                         self.add("break;")
 753                 end
 754                 if self.compiler.hardening then
 755                         self.add("default: /* Bug*/")
 756                         self.bugtype(recv)
 757                 end
 758                 self.add("\}")
 759         end
 760
 761         redef fun init_instance(mtype)
 762         do
 763                 mtype = self.anchor(mtype).as(MClassType)
 764                 if not self.compiler.runtime_type_analysis.live_types.has(mtype) then
 765                         debug "problem: {mtype} was detected dead"
 766                 end
 767                 var res = self.new_expr("NEW_{mtype.c_name}()", mtype)
 768                 res.is_exact = true
 769                 return res
 770         end
 771
 772         redef fun type_test(value, mtype, tag)
 773         do
 774                 mtype = self.anchor(mtype)
 775                 if not self.compiler.runtime_type_analysis.live_cast_types.has(mtype) then
 776                         debug "problem: {mtype} was detected cast-dead"
 777                         abort
 778                 end
 779
 780                 var types = self.collect_types(value)
 781                 var res = self.new_var(bool_type)
 782
 783                 self.add("/* isa {mtype} on {value.inspect} */")
 784                 if value.mtype.ctype != "val*" then
 785                         if value.mtype.is_subtype(self.compiler.mainmodule, null, mtype) then
 786                                 self.add("{res} = 1;")
 787                         else
 788                                 self.add("{res} = 0;")
 789                         end
 790                         return res
 791                 end
 792                 if value.mcasttype isa MNullableType or value.mcasttype isa MNullType then
 793                         self.add("if ({value} == NULL) \{")
 794                         if mtype isa MNullableType then
 795                                 self.add("{res} = 1; /* isa {mtype} */")
 796                         else
 797                                 self.add("{res} = 0; /* not isa {mtype} */")
 798                         end
 799                         self.add("\} else ")
 800                 end
 801                 self.add("switch({value}->classid) \{")
 802                 for t in types do
 803                         if t.is_subtype(self.compiler.mainmodule, null, mtype) then
 804                                 self.add("case {self.compiler.classid(t)}: /* {t} */")
 805                         end
 806                 end
 807                 self.add("{res} = 1;")
 808                 self.add("break;")
 809                 self.add("default:")
 810                 self.add("{res} = 0;")
 811                 self.add("\}")
 812
 813                 return res
 814         end
 815
 816         redef fun is_same_type_test(value1, value2)
 817         do
 818                 var res = self.new_var(bool_type)
 819                 if value2.mtype.ctype == "val*" then
 820                         if value1.mtype.ctype == "val*" then
 821                                 self.add "{res} = {value1}->classid == {value2}->classid;"
 822                         else
 823                                 self.add "{res} = {self.compiler.classid(value1.mtype.as(MClassType))} == {value2}->classid;"
 824                         end
 825                 else
 826                         if value1.mtype.ctype == "val*" then
 827                                 self.add "{res} = {value1}->classid == {self.compiler.classid(value2.mtype.as(MClassType))};"
 828                         else if value1.mcasttype == value2.mcasttype then
 829                                 self.add "{res} = 1;"
 830                         else
 831                                 self.add "{res} = 0;"
 832                         end
 833                 end
 834                 return res
 835         end
 836
 837         redef fun class_name_string(value)
 838         do
 839                 var res = self.get_name("var_class_name")
 840                 self.add_decl("const char* {res};")
 841                 if value.mtype.ctype == "val*" then
 842                         self.add "{res} = class_names[{value}->classid];"
 843                 else
 844                         self.add "{res} = class_names[{self.compiler.classid(value.mtype.as(MClassType))}];"
 845                 end
 846                 return res
 847         end
 848
 849         redef fun equal_test(value1, value2)
 850         do
 851                 var res = self.new_var(bool_type)
 852                 if value2.mtype.ctype != "val*" and value1.mtype.ctype == "val*" then
 853                         var tmp = value1
 854                         value1 = value2
 855                         value2 = tmp
 856                 end
 857                 if value1.mtype.ctype != "val*" then
 858                         if value2.mtype == value1.mtype then
 859                                 self.add("{res} = {value1} == {value2};")
 860                         else if value2.mtype.ctype != "val*" then
 861                                 self.add("{res} = 0; /* incompatible types {value1.mtype} vs. {value2.mtype}*/")
 862                         else
 863                                 var mtype1 = value1.mtype.as(MClassType)
 864                                 self.add("{res} = ({value2} != NULL) && ({value2}->classid == {self.compiler.classid(mtype1)});")
 865                                 self.add("if ({res}) \{")
 866                                 self.add("{res} = ({self.autobox(value2, value1.mtype)} == {value1});")
 867                                 self.add("\}")
 868                         end
 869                 else
 870                         var s = new Array[String]
 871                         for t in self.compiler.live_primitive_types do
 872                                 if not t.is_subtype(self.compiler.mainmodule, null, value1.mcasttype) then continue
 873                                 if not t.is_subtype(self.compiler.mainmodule, null, value2.mcasttype) then continue
 874                                 s.add "({value1}->classid == {self.compiler.classid(t)} && ((struct {t.c_name}*){value1})->value == ((struct {t.c_name}*){value2})->value)"
 875                         end
 876
 877                         if self.compiler.mainmodule.model.get_mclasses_by_name("Pointer") != null then
 878                                 var pointer_type = self.compiler.mainmodule.pointer_type
 879                                 if value1.mcasttype.is_subtype(self.compiler.mainmodule, null, pointer_type) or
 880                                         value2.mcasttype.is_subtype(self.compiler.mainmodule, null, pointer_type) then
 881                                         s.add "(((struct {pointer_type.c_name}*){value1})->value == ((struct {pointer_type.c_name}*){value2})->value)"
 882                                 end
 883                         end
 884
 885                         if s.is_empty then
 886                                 self.add("{res} = {value1} == {value2};")
 887                         else
 888                                 self.add("{res} = {value1} == {value2} || ({value1} != NULL && {value2} != NULL && {value1}->classid == {value2}->classid && ({s.join(" || ")}));")
 889                         end
 890                 end
 891                 return res
 892         end
 893
 894         redef fun array_instance(array, elttype)
 895         do
 896                 elttype = self.anchor(elttype)
 897                 var arraytype = self.get_class("Array").get_mtype([elttype])
 898                 var res = self.init_instance(arraytype)
 899                 self.add("\{ /* {res} = array_instance Array[{elttype}] */")
 900                 var nat = self.new_var(self.get_class("NativeArray").get_mtype([elttype]))
 901                 nat.is_exact = true
 902                 self.add("{nat} = NEW_{nat.mtype.c_name}({array.length});")
 903                 for i in [0..array.length[ do
 904                         var r = self.autobox(array[i], elttype)
 905                         self.add("((struct {nat.mtype.c_name}*) {nat})->values[{i}] = {r};")
 906                 end
 907                 var length = self.int_instance(array.length)
 908                 self.send(self.get_property("with_native", arraytype), [res, nat, length])
 909                 self.add("\}")
 910                 return res
 911         end
 912 end
 913
 914 # A runtime function customized on a specific monomrph receiver type
 915 private class CustomizedRuntimeFunction
 916         super AbstractRuntimeFunction
 917
 918         redef type COMPILER: GlobalCompiler
 919         redef type VISITOR: GlobalCompilerVisitor
 920
 921         # The considered reciever
 922         # (usually is a live type but no strong guarantee)
 923         var recv: MClassType
 924
 925         redef fun build_c_name
 926         do
 927                 var res = self.c_name_cache
 928                 if res != null then return res
 929                 if self.mmethoddef.mclassdef.bound_mtype == self.recv then
 930                         res = self.mmethoddef.c_name
 931                 else
 932                         res = "{mmethoddef.c_name}__{recv.c_name}"
 933                 end
 934                 self.c_name_cache = res
 935                 return res
 936         end
 937
 938         # used in the compiler worklist
 939         redef fun ==(o)
 940         do
 941                 if not o isa CustomizedRuntimeFunction then return false
 942                 if self.mmethoddef != o.mmethoddef then return false
 943                 if self.recv != o.recv then return false
 944                 return true
 945         end
 946
 947         # used in the compiler work-list
 948         redef fun hash do return self.mmethoddef.hash + self.recv.hash
 949
 950         redef fun to_s
 951         do
 952                 if self.mmethoddef.mclassdef.bound_mtype == self.recv then
 953                         return self.mmethoddef.to_s
 954                 else
 955                         return "{self.mmethoddef}@{self.recv}"
 956                 end
 957         end
 958
 959         # compile the code customized for the reciever
 960         redef fun compile_to_c(compiler)
 961         do
 962                 var recv = self.recv
 963                 var mmethoddef = self.mmethoddef
 964                 if not recv.is_subtype(compiler.mainmodule, null, mmethoddef.mclassdef.bound_mtype) then
 965                         print("problem: why do we compile {self} for {recv}?")
 966                         abort
 967                 end
 968
 969                 var v = compiler.new_visitor
 970                 var selfvar = new RuntimeVariable("self", recv, recv)
 971                 if compiler.runtime_type_analysis.live_types.has(recv) then
 972                         selfvar.is_exact = true
 973                 end
 974                 var arguments = new Array[RuntimeVariable]
 975                 var frame = new StaticFrame(v, mmethoddef, recv, arguments)
 976                 v.frame = frame
 977
 978                 var sig = new FlatBuffer
 979                 var comment = new FlatBuffer
 980                 var ret = mmethoddef.msignature.return_mtype
 981                 if ret != null then
 982                         ret = v.resolve_for(ret, selfvar)
 983                         sig.append("{ret.ctype} ")
 984                 else
 985                         sig.append("void ")
 986                 end
 987                 sig.append(self.c_name)
 988                 sig.append("({recv.ctype} {selfvar}")
 989                 comment.append("(self: {recv}")
 990                 arguments.add(selfvar)
 991                 for i in [0..mmethoddef.msignature.arity[ do
 992                         var mtype = mmethoddef.msignature.mparameters[i].mtype
 993                         if i == mmethoddef.msignature.vararg_rank then
 994                                 mtype = v.get_class("Array").get_mtype([mtype])
 995                         end
 996                         mtype = v.resolve_for(mtype, selfvar)
 997                         comment.append(", {mtype}")
 998                         sig.append(", {mtype.ctype} p{i}")
 999                         var argvar = new RuntimeVariable("p{i}", mtype, mtype)
1000                         arguments.add(argvar)
1001                 end
1002                 sig.append(")")
1003                 comment.append(")")
1004                 if ret != null then
1005                         comment.append(": {ret}")
1006                 end
1007                 compiler.header.add_decl("{sig};")
1008
1009                 v.add_decl("/* method {self} for {comment} */")
1010                 v.add_decl("{sig} \{")
1011                 #v.add("printf(\"method {self} for {comment}\\n\");")
1012                 if ret != null then
1013                         frame.returnvar = v.new_var(ret)
1014                 end
1015                 frame.returnlabel = v.get_name("RET_LABEL")
1016
1017                 mmethoddef.compile_inside_to_c(v, arguments)
1018
1019                 v.add("{frame.returnlabel.as(not null)}:;")
1020                 if ret != null then
1021                         v.add("return {frame.returnvar.as(not null)};")
1022                 end
1023                 v.add("\}")
1024                 if not self.c_name.has_substring("VIRTUAL", 0) then compiler.names[self.c_name] = "{mmethoddef.mclassdef.mmodule.name}::{mmethoddef.mclassdef.mclass.name}::{mmethoddef.mproperty.name} ({mmethoddef.location.file.filename}:{mmethoddef.location.line_start})"
1025         end
1026
1027         redef fun call(v: VISITOR, arguments: Array[RuntimeVariable]): nullable RuntimeVariable
1028         do
1029                 var ret = self.mmethoddef.msignature.return_mtype
1030                 if ret != null then
1031                         ret = v.resolve_for(ret, arguments.first)
1032                 end
1033                 if self.mmethoddef.can_inline(v) then
1034                         var frame = new StaticFrame(v, self.mmethoddef, self.recv, arguments)
1035                         frame.returnlabel = v.get_name("RET_LABEL")
1036                         if ret != null then
1037                                 frame.returnvar = v.new_var(ret)
1038                         end
1039                         var old_frame = v.frame
1040                         v.frame = frame
1041                         v.add("\{ /* Inline {self} ({arguments.join(",")}) */")
1042                         self.mmethoddef.compile_inside_to_c(v, arguments)
1043                         v.add("{frame.returnlabel.as(not null)}:(void)0;")
1044                         v.add("\}")
1045                         v.frame = old_frame
1046                         return frame.returnvar
1047                 end
1048                 v.adapt_signature(self.mmethoddef, arguments)
1049                 v.compiler.todo(self)
1050                 if ret == null then
1051                         v.add("{self.c_name}({arguments.join(",")});")
1052                         return null
1053                 else
1054                         var res = v.new_var(ret)
1055                         v.add("{res} = {self.c_name}({arguments.join(",")});")
1056                         return res
1057                 end
1058         end
1059 end