* Accidental commit.

git-svn-id: trunk@46415 -

compiler/aasmdata.pas

@@ -633,6 +633,7 @@ implementation
          begin
            p.altsymbol:=p.getaltcopy(AsmSymbolDict,FNextAltNr);
            FAltSymbolList.Add(p);
+           inc(FNextAltNr);
          end;
       end;
 

compiler/ncal.pas

@@ -153,6 +153,8 @@ interface
           callinitblock,
           callcleanupblock : tblocknode;
 
+          asminlineblock : tnode;
+
           { function return node for initialized types or supplied return variable.
             When the result is passed in a parameter then it is set to nil }
           funcretnode    : tnode;
@@ -4492,7 +4494,17 @@ implementation
 
            { Continue with checking a normal call or generate the inlined code }
            if cnf_do_inline in callnodeflags then
-             result:=pass1_inline
+             begin
+               if po_assembler in procdefinition.procoptions then
+                 begin
+                   mark_unregable_parameters;
+                   asminlineblock:=tprocdef(procdefinition).inlininginfo^.code.getcopy;
+//                   asminlineblock:=tblocknode(pass1_inline);
+                   result:=pass1_normal;
+                 end
+               else
+                 result:=pass1_inline
+             end
            else
              begin
                if (po_inline in procdefinition.procoptions) and not(po_compilerproc in procdefinition.procoptions) and
@@ -5144,13 +5156,17 @@ implementation
           addstatement(inlineinitstatement,callinitblock.getcopy);
 
         { replace complex parameters with temps }
-        createinlineparas;
+        if not (po_assembler in procdefinition.procoptions) then
+          createinlineparas;
 
         { create a copy of the body and replace parameter loads with the parameter values }
         body:=tprocdef(procdefinition).inlininginfo^.code.getcopy;
-        foreachnodestatic(pm_postprocess,body,@removeusercodeflag,nil);
-        foreachnodestatic(pm_postprocess,body,@importglobalsyms,nil);
-        foreachnode(pm_preprocess,body,@replaceparaload,@fileinfo);
+        if not (po_assembler in procdefinition.procoptions) then
+          begin
+            foreachnodestatic(pm_postprocess,body,@removeusercodeflag,nil);
+            foreachnodestatic(pm_postprocess,body,@importglobalsyms,nil);
+            foreachnode(pm_preprocess,body,@replaceparaload,@fileinfo);
+          end;
 
         { Concat the body and finalization parts }
         addstatement(inlineinitstatement,body);

compiler/ncgcal.pas

@@ -60,6 +60,7 @@ interface
           procedure reorder_parameters;
           procedure freeparas;
           function is_parentfp_pushed:boolean;
+          function generate_asm_inline:boolean;
        protected
           retloc: tcgpara;
           paralocs: array of pcgpara;
@@ -127,6 +128,8 @@ interface
 implementation
 
     uses
+      aasmtai,nbas,
+      cclasses,
       systems,
       verbose,globals,
       symconst,symtable,symtype,symsym,defutil,paramgr,
@@ -134,7 +137,7 @@ implementation
       nld,ncnv,
       ncgutil,blockutl,
       cgobj,tgobj,hlcgobj,
-      procinfo,
+      procinfo,psub,
       wpobase;
 
 
@@ -943,6 +946,75 @@ implementation
           not can_skip_para_push(tparavarsym(tprocdef(procdefinition).parentfpsym));
       end;
 
+    function tcgcallnode.generate_asm_inline: boolean;
+      var
+//        hp : tlinkedlistitem;
+        old_current_procinfo,asm_procinfo : tprocinfo;
+        old_temp_gen: ttgobj;
+        oldasmlist: TAsmList;
+        headertai:tai;
+      begin
+//        result:=(cnf_do_inline in callnodeflags);
+        result:=asminlineblock<>nil;
+        if not result then
+          exit;
+
+//        current_asmdata.CurrAsmList.concatList(tasmnode(asminlineblock).p_asm);
+        include(current_procinfo.procdef.procoptions,po_inline);
+        asminlineblock.pass_generate_code;
+        exclude(current_procinfo.procdef.procoptions,po_inline);
+
+        asminlineblock.free;
+        asminlineblock:=nil;
+
+        exit;
+//        hp:=current_asmdata.CurrAsmList.Last;
+//        asminlineblock.pass_generate_code;
+
+        old_current_procinfo:=current_procinfo;
+        asm_procinfo:=cprocinfo.create(nil);
+        asm_procinfo.procdef:=tprocdef(procdefinition);
+        asm_procinfo.flags:=asm_procinfo.procdef.inlininginfo^.flags;
+        old_temp_gen:=tg;
+        tg:=nil;
+//        oldasmlist:=current_asmdata.CurrAsmList;
+//        current_asmdata.CurrAsmList:=tasmlist.create;
+
+//        tcgprocinfo(current_procinfo).code:=asminlineblock;
+//        tcgprocinfo(current_procinfo).generate_code;
+
+        current_procinfo.generate_parameter_info;
+        hlcg.g_proc_entry(current_asmdata.CurrAsmList,current_procinfo.calc_stackframe_size,po_nostackframe in procdefinition.procoptions);
+        asminlineblock.pass_generate_code;
+        gen_proc_exit_code(current_asmdata.CurrAsmList);
+
+
+//        oldasmlist.concatList(current_asmdata.CurrAsmList);
+//        current_asmdata.CurrAsmList.Free;
+//        current_asmdata.CurrAsmList:=oldasmlist;
+        tg:=old_temp_gen;
+        //current_asmdata:=
+
+{
+//        old_procoptions:=temp_procinfo.procdef.procoptions;
+//                          include(temp_procinfo.procdef.procoptions,po_noreturn);
+
+        current_procinfo:=asm_procinfo;
+        current_procinfo.generate_parameter_info;
+        gen_proc_entry_code(current_asmdata.CurrAsmList);
+//        hlcg.g_proc_entry(current_asmdata.CurrAsmList,0,po_nostackframe in procdefinition.procoptions);
+        asminlineblock.pass_generate_code;
+//        hlcg.g_proc_exit(current_asmdata.CurrAsmList,0,po_nostackframe in procdefinition.procoptions);
+        gen_proc_exit_code(current_asmdata.CurrAsmList);
+
+}
+        current_procinfo:=old_current_procinfo;
+//        temp_procinfo.procdef.procoptions:=old_procoptions;
+
+        asm_procinfo.free;
+
+      end;
+
 
     procedure tcgcallnode.pass_generate_code;
       var
@@ -1142,17 +1214,24 @@ implementation
                         extra_interrupt_code;
                       extra_call_code;
                       retloc.resetiftemp;
-                      if (name_to_call='') then
-                        name_to_call:=tprocdef(procdefinition).mangledname;
-                      if cnf_inherited in callnodeflags then
-                        retloc:=hlcg.a_call_name_inherited(current_asmdata.CurrAsmList,tprocdef(procdefinition),name_to_call,paralocs)
-                      { under certain conditions, a static call (i.e. without PIC) can be generated }
-                      else if ((procdefinition.owner=current_procinfo.procdef.owner) or
-                         (procdefinition.owner.symtabletype in [localsymtable,staticsymtable])
-                        ) and ((procdefinition.procoptions*[po_weakexternal,po_external])=[]) then
-                        retloc:=hlcg.a_call_name_static(current_asmdata.CurrAsmList,tprocdef(procdefinition),name_to_call,paralocs,typedef)
+                      if generate_asm_inline then
+                        begin
+                          retloc:=hlcg.get_call_result_cgpara(tprocdef(procdefinition),typedef);
+                        end
                       else
-                        retloc:=hlcg.a_call_name(current_asmdata.CurrAsmList,tprocdef(procdefinition),name_to_call,paralocs,typedef,po_weakexternal in procdefinition.procoptions);
+                      begin
+                        if (name_to_call='') then
+                          name_to_call:=tprocdef(procdefinition).mangledname;
+                        if cnf_inherited in callnodeflags then
+                          retloc:=hlcg.a_call_name_inherited(current_asmdata.CurrAsmList,tprocdef(procdefinition),name_to_call,paralocs)
+                        { under certain conditions, a static call (i.e. without PIC) can be generated }
+                        else if ((procdefinition.owner=current_procinfo.procdef.owner) or
+                           (procdefinition.owner.symtabletype in [localsymtable,staticsymtable])
+                          ) and ((procdefinition.procoptions*[po_weakexternal,po_external])=[]) then
+                          retloc:=hlcg.a_call_name_static(current_asmdata.CurrAsmList,tprocdef(procdefinition),name_to_call,paralocs,typedef)
+                        else
+                          retloc:=hlcg.a_call_name(current_asmdata.CurrAsmList,tprocdef(procdefinition),name_to_call,paralocs,typedef,po_weakexternal in procdefinition.procoptions);
+                      end;
                       extra_post_call_code;
                     end;
                end;

compiler/psub.pas

@@ -181,11 +181,13 @@ implementation
           ppu file }
         if df_generic in current_procinfo.procdef.defoptions then
           exit;
+{
         if pi_has_assembler_block in current_procinfo.flags then
           begin
             _no_inline('assembler');
             exit;
           end;
+}
         if (pi_has_global_goto in current_procinfo.flags) or
            (pi_has_interproclabel in current_procinfo.flags) then
           begin
@@ -2213,6 +2215,19 @@ implementation
 
             finish_eh;
 
+            if (po_assembler in procdef.procoptions) and (po_inline in procdef.procoptions) then
+              begin
+                if procdef.inlininginfo^.code.nodetype=asmn then
+                  begin
+//                    tasmnode(procdef.inlininginfo^.code).p_asm.Clear;
+//                    tasmnode(procdef.inlininginfo^.code).p_asm.concatListcopy(aktproccode);
+                    gen_proc_entry_code(templist);
+                    tasmnode(procdef.inlininginfo^.code).p_asm.insertList(templist);
+                    gen_proc_exit_code(templist);
+                    tasmnode(procdef.inlininginfo^.code).p_asm.concatList(templist);
+                  end;
+              end;
+
             hlcg.record_generated_code_for_procdef(current_procinfo.procdef,aktproccode,aktlocaldata);
 
             { now generate code for any exception filters (they need the tempgen) }