* emit_??? used

compiler/cg386add.pas

@@ -199,13 +199,13 @@ implementation
                           LOC_REFERENCE,LOC_MEM:
                             emit_push_mem(p^.right^.location.reference);
                           LOC_REGISTER,LOC_CREGISTER:
-                            exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,p^.right^.location.register)));
+                            emit_reg(A_PUSH,S_L,p^.right^.location.register);
                         end;
                         case p^.left^.location.loc of
                           LOC_REFERENCE,LOC_MEM:
                             emit_push_mem(p^.left^.location.reference);
                           LOC_REGISTER,LOC_CREGISTER:
-                            exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,p^.left^.location.register)));
+                            emit_reg(A_PUSH,S_L,p^.left^.location.register);
                         end;
                         emitcall('FPC_ANSISTR_COMPARE');
                         emit_reg_reg(A_OR,S_L,R_EAX,R_EAX);
@@ -288,11 +288,11 @@ implementation
                              { else pass 1 would have evaluted   }
                              { this node                         }
                              if p^.left^.treetype=stringconstn then
-                               exprasmlist^.concat(new(pai386,op_const_ref(
-                                 A_CMP,S_B,0,newreference(p^.right^.location.reference))))
+                               emit_const_ref(
+                                 A_CMP,S_B,0,newreference(p^.right^.location.reference))
                              else
-                               exprasmlist^.concat(new(pai386,op_const_ref(
-                                 A_CMP,S_B,0,newreference(p^.left^.location.reference))));
+                               emit_const_ref(
+                                 A_CMP,S_B,0,newreference(p^.left^.location.reference));
                              del_reference(p^.right^.location.reference);
                              del_reference(p^.left^.location.reference);
                           end
@@ -729,14 +729,13 @@ implementation
                                p^.left^.location.register:=hregister;
                                emitlab(truelabel);
                                truelabel:=otl;
-                               exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,opsize,1,
-                                 hregister)));
+                               emit_const_reg(A_MOV,opsize,1,hregister);
                                getlabel(hl);
                                emitjmp(C_None,hl);
                                emitlab(falselabel);
                                falselabel:=ofl;
-                               exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,makereg32(hregister),
-                                 makereg32(hregister))));
+                               emit_reg_reg(A_XOR,S_L,makereg32(hregister),
+                                 makereg32(hregister));
                                emitlab(hl);
                             end;
                        end;
@@ -765,14 +764,13 @@ implementation
                                p^.right^.location.register:=hregister;
                                emitlab(truelabel);
                                truelabel:=otl;
-                               exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,opsize,1,
-                                 hregister)));
+                               emit_const_reg(A_MOV,opsize,1,hregister);
                                getlabel(hl);
                                emitjmp(C_None,hl);
                                emitlab(falselabel);
                                falselabel:=ofl;
-                               exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,makereg32(hregister),
-                                 makereg32(hregister))));
+                               emit_reg_reg(A_XOR,S_L,makereg32(hregister),
+                                 makereg32(hregister));
                                emitlab(hl);
                             end;
                        end;
@@ -870,8 +868,8 @@ implementation
                                         del_location(p^.left^.location);
 {!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!}
                                         hregister:=getregister32;
-                                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                          newreference(p^.left^.location.reference),hregister)));
+                                        emit_ref_reg(A_MOV,opsize,
+                                          newreference(p^.left^.location.reference),hregister);
                                         clear_location(p^.left^.location);
                                         p^.left^.location.loc:=LOC_REGISTER;
                                         p^.left^.location.register:=hregister;
@@ -882,8 +880,8 @@ implementation
                                         ungetiftemp(p^.right^.location.reference);
                                         del_location(p^.right^.location);
                                         hregister:=getregister32;
-                                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                          newreference(p^.right^.location.reference),hregister)));
+                                        emit_ref_reg(A_MOV,opsize,
+                                          newreference(p^.right^.location.reference),hregister);
                                         clear_location(p^.right^.location);
                                         p^.right^.location.loc:=LOC_REGISTER;
                                         p^.right^.location.register:=hregister;
@@ -963,8 +961,8 @@ implementation
                                          ungetiftemp(p^.left^.location.reference);
                                          del_reference(p^.left^.location.reference);
                                          hregister:=getregister32;
-                                         exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                         newreference(p^.left^.location.reference),hregister)));
+                                         emit_ref_reg(A_MOV,opsize,
+                                           newreference(p^.left^.location.reference),hregister);
                                          clear_location(p^.left^.location);
                                          p^.left^.location.loc:=LOC_REGISTER;
                                          p^.left^.location.register:=hregister;
@@ -976,8 +974,8 @@ implementation
                                           its value is going to be modified}
                                           begin
                                             hregister := getregister32;
-                                            exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,opsize,
-                                              p^.left^.location.register,hregister)));
+                                            emit_reg_reg(A_MOV,opsize,
+                                              p^.left^.location.register,hregister);
                                              clear_location(p^.left^.location);
                                              p^.left^.location.loc:=LOC_REGISTER;
                                              p^.left^.location.register:=hregister;
@@ -985,11 +983,11 @@ implementation
                                            end;
                                      {here, p^.left^.location should be LOC_REGISTER}
                                       If p^.right^.location.loc in [LOC_MEM,LOC_REFERENCE] Then
-                                         exprasmlist^.concat(new(pai386,op_ref_reg(A_AND,opsize,
-                                           newreference(p^.right^.location.reference),p^.left^.location.register)))
+                                         emit_ref_reg(A_AND,opsize,
+                                           newreference(p^.right^.location.reference),p^.left^.location.register)
                                       Else
-                                        exprasmlist^.concat(new(pai386,op_reg_reg(A_AND,opsize,
-                                          p^.right^.location.register,p^.left^.location.register)));
+                                        emit_reg_reg(A_AND,opsize,
+                                          p^.right^.location.register,p^.left^.location.register);
                 {warning: ugly hack ahead: we need a "jne" after the cmp, so
                  change the treetype from lten/gten to equaln}
                                       p^.treetype := equaln
@@ -1027,30 +1025,30 @@ implementation
                           not(cs_check_overflow in aktlocalswitches) then
                          Begin
                            emitloadord2reg(p^.right^.location,u32bitdef,p^.location.register,true);
-                           exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,power,p^.location.register)))
+                           emit_const_reg(A_SHL,S_L,power,p^.location.register)
                          End
                        Else
                         Begin
 {$EndIf NoShlMul}
                          if not(R_EAX in unused) and (p^.location.register<>R_EAX) then
                           begin
-                           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
+                           emit_reg(A_PUSH,S_L,R_EAX);
                            popeax:=true;
                           end;
                          if not(R_EDX in unused) and (p^.location.register<>R_EDX)  then
                           begin
-                           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EDX)));
+                           emit_reg(A_PUSH,S_L,R_EDX);
                            popedx:=true;
                           end;
                          { p^.left^.location can be R_EAX !!! }
                          emitloadord2reg(p^.left^.location,u32bitdef,R_EDI,true);
                          emitloadord2reg(p^.right^.location,u32bitdef,R_EAX,true);
-                         exprasmlist^.concat(new(pai386,op_reg(A_MUL,S_L,R_EDI)));
+                         emit_reg(A_MUL,S_L,R_EDI);
                          emit_reg_reg(A_MOV,S_L,R_EAX,p^.location.register);
                          if popedx then
-                          exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDX)));
+                          emit_reg(A_POP,S_L,R_EDX);
                          if popeax then
-                          exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EAX)));
+                          emit_reg(A_POP,S_L,R_EAX);
 {$IfNDef NoShlMul}
                         End;
 {$endif NoShlMul}
@@ -1102,8 +1100,8 @@ implementation
                              if is_in_dest then
                                begin
                                   hregister:=p^.location.register;
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                  newreference(p^.left^.location.reference),hregister)));
+                                  emit_ref_reg(A_MOV,opsize,
+                                    newreference(p^.left^.location.reference),hregister);
                                end
                              else
                                begin
@@ -1113,8 +1111,8 @@ implementation
                                      S_W : hregister:=reg32toreg16(getregister32);
                                      S_B : hregister:=reg32toreg8(getregister32);
                                   end;
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                    newreference(p^.left^.location.reference),hregister)));
+                                  emit_ref_reg(A_MOV,opsize,
+                                    newreference(p^.left^.location.reference),hregister);
                                end;
                           end;
                         clear_location(p^.location);
@@ -1141,7 +1139,7 @@ implementation
                              if p^.right^.location.loc=LOC_CREGISTER then
                                begin
                                   if extra_not then
-                                    exprasmlist^.concat(new(pai386,op_reg(A_NOT,opsize,p^.location.register)));
+                                    emit_reg(A_NOT,opsize,p^.location.register);
 
                                   emit_reg_reg(A_MOV,opsize,p^.right^.location.register,R_EDI);
                                   emit_reg_reg(op,opsize,p^.location.register,R_EDI);
@@ -1150,12 +1148,12 @@ implementation
                              else
                                begin
                                   if extra_not then
-                                    exprasmlist^.concat(new(pai386,op_reg(A_NOT,opsize,p^.location.register)));
+                                    emit_reg(A_NOT,opsize,p^.location.register);
 
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                    newreference(p^.right^.location.reference),R_EDI)));
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(op,opsize,p^.location.register,R_EDI)));
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,opsize,R_EDI,p^.location.register)));
+                                  emit_ref_reg(A_MOV,opsize,
+                                    newreference(p^.right^.location.reference),R_EDI);
+                                  emit_reg_reg(op,opsize,p^.location.register,R_EDI);
+                                  emit_reg_reg(A_MOV,opsize,R_EDI,p^.location.register);
                                   ungetiftemp(p^.right^.location.reference);
                                   del_reference(p^.right^.location.reference);
                                end;
@@ -1166,32 +1164,32 @@ implementation
                                 (op=A_CMP) and
                                 (p^.right^.value=0) then
                                begin
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,p^.location.register,
-                                    p^.location.register)));
+                                  emit_reg_reg(A_TEST,opsize,p^.location.register,
+                                    p^.location.register);
                                end
                              else if (p^.right^.treetype=ordconstn) and
                                 (op=A_ADD) and
                                 (p^.right^.value=1) and
                                 not(cs_check_overflow in aktlocalswitches) then
                                begin
-                                  exprasmlist^.concat(new(pai386,op_reg(A_INC,opsize,
-                                    p^.location.register)));
+                                  emit_reg(A_INC,opsize,
+                                    p^.location.register);
                                end
                              else if (p^.right^.treetype=ordconstn) and
                                 (op=A_SUB) and
                                 (p^.right^.value=1) and
                                 not(cs_check_overflow in aktlocalswitches) then
                                begin
-                                  exprasmlist^.concat(new(pai386,op_reg(A_DEC,opsize,
-                                    p^.location.register)));
+                                  emit_reg(A_DEC,opsize,
+                                    p^.location.register);
                                end
                              else if (p^.right^.treetype=ordconstn) and
                                 (op=A_IMUL) and
                                 (ispowerof2(p^.right^.value,power)) and
                                 not(cs_check_overflow in aktlocalswitches) then
                                begin
-                                  exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,opsize,power,
-                                    p^.location.register)));
+                                  emit_const_reg(A_SHL,opsize,power,
+                                    p^.location.register);
                                end
                              else
                                begin
@@ -1200,7 +1198,7 @@ implementation
                                        if extra_not then
                                          begin
                                             emit_reg_reg(A_MOV,S_L,p^.right^.location.register,R_EDI);
-                                            exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,R_EDI)));
+                                            emit_reg(A_NOT,S_L,R_EDI);
                                             emit_reg_reg(A_AND,S_L,R_EDI,
                                               p^.location.register);
                                          end
@@ -1214,16 +1212,16 @@ implementation
                                     begin
                                        if extra_not then
                                          begin
-                                            exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(
-                                              p^.right^.location.reference),R_EDI)));
-                                            exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,R_EDI)));
+                                            emit_ref_reg(A_MOV,S_L,newreference(
+                                              p^.right^.location.reference),R_EDI);
+                                            emit_reg(A_NOT,S_L,R_EDI);
                                             emit_reg_reg(A_AND,S_L,R_EDI,
                                               p^.location.register);
                                          end
                                        else
                                          begin
-                                            exprasmlist^.concat(new(pai386,op_ref_reg(op,opsize,newreference(
-                                              p^.right^.location.reference),p^.location.register)));
+                                            emit_ref_reg(op,opsize,newreference(
+                                              p^.right^.location.reference),p^.location.register);
                                          end;
                                        ungetiftemp(p^.right^.location.reference);
                                        del_reference(p^.right^.location.reference);
@@ -1237,10 +1235,10 @@ implementation
                         if (p^.treetype=subn) and p^.swaped then
                           begin
                              if extra_not then
-                               exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.register)));
+                               emit_reg(A_NOT,S_L,p^.location.register);
 
-                             exprasmlist^.concat(new(pai386,op_reg_reg(op,opsize,
-                               p^.location.register,p^.right^.location.register)));
+                             emit_reg_reg(op,opsize,
+                               p^.location.register,p^.right^.location.register);
                                swap_location(p^.location,p^.right^.location);
                                { newly swapped also set swapped flag }
                                { just to maintain ordering         }
@@ -1249,10 +1247,10 @@ implementation
                         else
                           begin
                              if extra_not then
-                               exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.right^.location.register)));
-                             exprasmlist^.concat(new(pai386,op_reg_reg(op,opsize,
+                               emit_reg(A_NOT,S_L,p^.right^.location.register);
+                             emit_reg_reg(op,opsize,
                                p^.right^.location.register,
-                               p^.location.register)));
+                               p^.location.register);
                           end;
                         case opsize of
                            S_L : ungetregister32(p^.right^.location.register);
@@ -1323,8 +1321,8 @@ implementation
 
                              { first give free then demand new register }
                              hregister:=reg32toreg8(getregister32);
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_B,newreference(p^.location.reference),
-                               hregister)));
+                             emit_ref_reg(A_MOV,S_B,newreference(p^.location.reference),
+                               hregister);
                           end;
                         clear_location(p^.location);
                         p^.location.loc:=LOC_REGISTER;
@@ -1350,8 +1348,8 @@ implementation
                           end
                         else
                           begin
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_CMP,S_B,newreference(
-                                p^.right^.location.reference),p^.location.register)));
+                             emit_ref_reg(A_CMP,S_B,newreference(
+                                p^.right^.location.reference),p^.location.register);
                              del_reference(p^.right^.location.reference);
                           end;
                      end
@@ -1398,8 +1396,8 @@ implementation
 
                              { first give free then demand new register }
                              hregister:=reg32toreg16(getregister32);
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_W,newreference(p^.location.reference),
-                               hregister)));
+                             emit_ref_reg(A_MOV,S_W,newreference(p^.location.reference),
+                               hregister);
                           end;
                         clear_location(p^.location);
                         p^.location.loc:=LOC_REGISTER;
@@ -1425,8 +1423,8 @@ implementation
                           end
                         else
                           begin
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_CMP,S_W,newreference(
-                                p^.right^.location.reference),p^.location.register)));
+                             emit_ref_reg(A_CMP,S_W,newreference(
+                                p^.right^.location.reference),p^.location.register);
                              del_reference(p^.right^.location.reference);
                           end;
                      end
@@ -1569,23 +1567,23 @@ implementation
                                     begin
                                        hregister:=p^.location.registerlow;
                                        hregister2:=p^.location.registerhigh;
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                         newreference(p^.left^.location.reference),hregister)));
+                                       emit_ref_reg(A_MOV,S_L,
+                                         newreference(p^.left^.location.reference),hregister);
                                        hr:=newreference(p^.left^.location.reference);
                                        inc(hr^.offset,4);
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                         hr,hregister2)));
+                                       emit_ref_reg(A_MOV,S_L,
+                                         hr,hregister2);
                                     end
                                   else
                                     begin
                                        hregister:=getregister32;
                                        hregister2:=getregister32;
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                         newreference(p^.left^.location.reference),hregister)));
+                                       emit_ref_reg(A_MOV,S_L,
+                                         newreference(p^.left^.location.reference),hregister);
                                        hr:=newreference(p^.left^.location.reference);
                                        inc(hr^.offset,4);
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                         hr,hregister2)));
+                                       emit_ref_reg(A_MOV,S_L,
+                                         hr,hregister2);
                                     end;
                                end;
                              clear_location(p^.location);
@@ -1622,18 +1620,18 @@ implementation
                                     end
                                   else
                                     begin
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                         newreference(p^.right^.location.reference),R_EDI)));
-                                       exprasmlist^.concat(new(pai386,op_reg_reg(op,opsize,p^.location.registerlow,R_EDI)));
-                                       exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,opsize,R_EDI,p^.location.registerlow)));
+                                       emit_ref_reg(A_MOV,opsize,
+                                         newreference(p^.right^.location.reference),R_EDI);
+                                       emit_reg_reg(op,opsize,p^.location.registerlow,R_EDI);
+                                       emit_reg_reg(A_MOV,opsize,R_EDI,p^.location.registerlow);
                                        hr:=newreference(p^.right^.location.reference);
                                        inc(hr^.offset,4);
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                                         hr,R_EDI)));
+                                       emit_ref_reg(A_MOV,opsize,
+                                         hr,R_EDI);
                                        { here the carry flag is still preserved }
-                                       exprasmlist^.concat(new(pai386,op_reg_reg(op2,opsize,p^.location.registerhigh,R_EDI)));
-                                       exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,opsize,R_EDI,
-                                         p^.location.registerhigh)));
+                                       emit_reg_reg(op2,opsize,p^.location.registerhigh,R_EDI);
+                                       emit_reg_reg(A_MOV,opsize,R_EDI,
+                                         p^.location.registerhigh);
                                        ungetiftemp(p^.right^.location.reference);
                                        del_reference(p^.right^.location.reference);
                                     end;
@@ -1654,12 +1652,12 @@ implementation
                                        hr:=newreference(p^.right^.location.reference);
                                        inc(hr^.offset,4);
 
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_CMP,S_L,
-                                         hr,p^.location.registerhigh)));
+                                       emit_ref_reg(A_CMP,S_L,
+                                         hr,p^.location.registerhigh);
                                        firstjmp64bitcmp;
 
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_CMP,S_L,newreference(
-                                         p^.right^.location.reference),p^.location.registerlow)));
+                                       emit_ref_reg(A_CMP,S_L,newreference(
+                                         p^.right^.location.reference),p^.location.registerlow);
                                        secondjmp64bitcmp;
 
                                        emitjmp(C_None,falselabel);
@@ -1675,15 +1673,15 @@ implementation
                                      (op=A_CMP) and
                                      (p^.right^.value=0) then
                                     begin
-                                       exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,p^.location.register,
-                                         p^.location.register)));
+                                       emit_reg_reg(A_TEST,opsize,p^.location.register,
+                                         p^.location.register);
                                     end
                                   else if (p^.right^.treetype=ordconstn) and
                                      (op=A_IMUL) and
                                      (ispowerof2(p^.right^.value,power)) then
                                     begin
-                                       exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,opsize,power,
-                                         p^.location.register)));
+                                       emit_const_reg(A_SHL,opsize,power,
+                                         p^.location.register);
                                     end
                                   else
                                   }
@@ -1697,12 +1695,12 @@ implementation
                                          end
                                        else
                                          begin
-                                            exprasmlist^.concat(new(pai386,op_ref_reg(op,S_L,newreference(
-                                              p^.right^.location.reference),p^.location.registerlow)));
+                                            emit_ref_reg(op,S_L,newreference(
+                                              p^.right^.location.reference),p^.location.registerlow);
                                             hr:=newreference(p^.right^.location.reference);
                                             inc(hr^.offset,4);
-                                            exprasmlist^.concat(new(pai386,op_ref_reg(op2,S_L,
-                                              hr,p^.location.registerhigh)));
+                                            emit_ref_reg(op2,S_L,
+                                              hr,p^.location.registerhigh);
                                             ungetiftemp(p^.right^.location.reference);
                                             del_reference(p^.right^.location.reference);
                                          end;
@@ -1714,12 +1712,12 @@ implementation
                              { when swapped another result register }
                              if (p^.treetype=subn) and p^.swaped then
                                begin
-                                 exprasmlist^.concat(new(pai386,op_reg_reg(op,S_L,
+                                 emit_reg_reg(op,S_L,
                                     p^.location.registerlow,
-                                    p^.right^.location.registerlow)));
-                                 exprasmlist^.concat(new(pai386,op_reg_reg(op2,S_L,
+                                    p^.right^.location.registerlow);
+                                 emit_reg_reg(op2,S_L,
                                     p^.location.registerhigh,
-                                    p^.right^.location.registerhigh)));
+                                    p^.right^.location.registerhigh);
                                   swap_location(p^.location,p^.right^.location);
                                   { newly swapped also set swapped flag }
                                   { just to maintain ordering           }
@@ -1727,23 +1725,23 @@ implementation
                                end
                              else if cmpop then
                                begin
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(A_CMP,S_L,
+                                  emit_reg_reg(A_CMP,S_L,
                                     p^.right^.location.registerhigh,
-                                    p^.location.registerhigh)));
+                                    p^.location.registerhigh);
                                   firstjmp64bitcmp;
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(A_CMP,S_L,
+                                  emit_reg_reg(A_CMP,S_L,
                                     p^.right^.location.registerlow,
-                                    p^.location.registerlow)));
+                                    p^.location.registerlow);
                                   secondjmp64bitcmp;
                                end
                              else
                                begin
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(op,S_L,
+                                  emit_reg_reg(op,S_L,
                                     p^.right^.location.registerlow,
-                                    p^.location.registerlow)));
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(op2,S_L,
+                                    p^.location.registerlow);
+                                  emit_reg_reg(op2,S_L,
                                     p^.right^.location.registerhigh,
-                                    p^.location.registerhigh)));
+                                    p^.location.registerhigh);
                                end;
                              ungetregister32(p^.right^.location.registerlow);
                              ungetregister32(p^.right^.location.registerhigh);
@@ -1807,8 +1805,8 @@ implementation
                       begin
                          if p^.right^.location.loc=LOC_CFPUREGISTER then
                            begin
-                              exprasmlist^.concat(new(pai386,op_reg(A_FLD,S_NO,
-                                correct_fpuregister(p^.right^.location.register,fpuvaroffset))));
+                              emit_reg( A_FLD,S_NO,
+                                correct_fpuregister(p^.right^.location.register,fpuvaroffset));
                               inc(fpuvaroffset);
                             end
                          else
@@ -1817,8 +1815,8 @@ implementation
                            begin
                               if p^.left^.location.loc=LOC_CFPUREGISTER then
                                 begin
-                                   exprasmlist^.concat(new(pai386,op_reg(A_FLD,S_NO,
-                                     correct_fpuregister(p^.left^.location.register,fpuvaroffset))));
+                                   emit_reg( A_FLD,S_NO,
+                                     correct_fpuregister(p^.left^.location.register,fpuvaroffset));
                                    inc(fpuvaroffset);
                                 end
                               else
@@ -1836,8 +1834,8 @@ implementation
                       begin
                          if p^.left^.location.loc=LOC_CFPUREGISTER then
                            begin
-                              exprasmlist^.concat(new(pai386,op_reg(A_FLD,S_NO,
-                                correct_fpuregister(p^.left^.location.register,fpuvaroffset))));
+                              emit_reg( A_FLD,S_NO,
+                                correct_fpuregister(p^.left^.location.register,fpuvaroffset));
                               inc(fpuvaroffset);
                            end
                          else
@@ -1861,18 +1859,18 @@ implementation
                       end;
                     { to avoid the pentium bug
                     if (op=FDIVP) and (opt_processors=pentium) then
-                      exprasmlist^.concat(new(pai386,op_CALL,S_NO,'EMUL_FDIVP')
+                      emitcall('EMUL_FDIVP')
                     else
                     }
                     { the Intel assemblers want operands }
                     if op<>A_FCOMPP then
                       begin
-                         exprasmlist^.concat(new(pai386,op_reg_reg(op,S_NO,R_ST,R_ST1)));
+                         emit_reg_reg(op,S_NO,R_ST,R_ST1);
                          dec(fpuvaroffset);
                       end
                     else
                       begin
-                         exprasmlist^.concat(new(pai386,op_none(op,S_NO)));
+                         emit_none(op,S_NO);
                          dec(fpuvaroffset,2);
                       end;
 
@@ -1881,8 +1879,8 @@ implementation
                      begin
                        if not(R_EAX in unused) then
                          emit_reg_reg(A_MOV,S_L,R_EAX,R_EDI);
-                       exprasmlist^.concat(new(pai386,op_reg(A_FNSTSW,S_NO,R_AX)));
-                       exprasmlist^.concat(new(pai386,op_none(A_SAHF,S_NO)));
+                       emit_reg(A_FNSTSW,S_NO,R_AX);
+                       emit_none(A_SAHF,S_NO);
                        if not(R_EAX in unused) then
                          emit_reg_reg(A_MOV,S_L,R_EDI,R_EAX);
                        if p^.swaped then
@@ -2032,14 +2030,14 @@ implementation
                              if is_in_dest then
                                begin
                                   hregister:=p^.location.register;
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVQ,S_NO,
-                                  newreference(p^.left^.location.reference),hregister)));
+                                  emit_ref_reg(A_MOVQ,S_NO,
+                                    newreference(p^.left^.location.reference),hregister);
                                end
                              else
                                begin
                                   hregister:=getregistermmx;
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVQ,S_NO,
-                                    newreference(p^.left^.location.reference),hregister)));
+                                  emit_ref_reg(A_MOVQ,S_NO,
+                                    newreference(p^.left^.location.reference),hregister);
                                end;
                           end;
                         clear_location(p^.location);
@@ -2069,12 +2067,12 @@ implementation
                                end
                              else
                                begin
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVQ,S_NO,
-                                    newreference(p^.right^.location.reference),R_MM7)));
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(op,S_NO,p^.location.register,
-                                    R_MM7)));
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVQ,S_NO,
-                                    R_MM7,p^.location.register)));
+                                  emit_ref_reg(A_MOVQ,S_NO,
+                                    newreference(p^.right^.location.reference),R_MM7);
+                                  emit_reg_reg(op,S_NO,p^.location.register,
+                                    R_MM7);
+                                  emit_reg_reg(A_MOVQ,S_NO,
+                                    R_MM7,p^.location.register);
                                   del_reference(p^.right^.location.reference);
                                end;
                           end
@@ -2087,8 +2085,8 @@ implementation
                                end
                              else
                                begin
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(op,S_NO,newreference(
-                                    p^.right^.location.reference),p^.location.register)));
+                                  emit_ref_reg(op,S_NO,newreference(
+                                    p^.right^.location.reference),p^.location.register);
                                   del_reference(p^.right^.location.reference);
                                end;
                           end;
@@ -2098,18 +2096,18 @@ implementation
                         { when swapped another result register }
                         if (p^.treetype=subn) and p^.swaped then
                           begin
-                             exprasmlist^.concat(new(pai386,op_reg_reg(op,S_NO,
-                               p^.location.register,p^.right^.location.register)));
-                               swap_location(p^.location,p^.right^.location);
-                               { newly swapped also set swapped flag }
-                               { just to maintain ordering         }
-                               p^.swaped:=not(p^.swaped);
+                             emit_reg_reg(op,S_NO,
+                               p^.location.register,p^.right^.location.register);
+                             swap_location(p^.location,p^.right^.location);
+                             { newly swapped also set swapped flag }
+                             { just to maintain ordering         }
+                             p^.swaped:=not(p^.swaped);
                           end
                         else
                           begin
-                             exprasmlist^.concat(new(pai386,op_reg_reg(op,S_NO,
+                             emit_reg_reg(op,S_NO,
                                p^.right^.location.register,
-                               p^.location.register)));
+                               p^.location.register);
                           end;
                         ungetregistermmx(p^.right^.location.register);
                      end;
@@ -2124,7 +2122,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.73  1999-08-07 11:29:26  peter
+  Revision 1.74  1999-08-19 13:08:43  pierre
+   * emit_??? used
+
+  Revision 1.73  1999/08/07 11:29:26  peter
     * better fix for muln register allocation
 
   Revision 1.72  1999/08/04 13:45:17  florian

compiler/cg386cal.pas

@@ -105,11 +105,11 @@ implementation
                   if inlined then
                     begin
                        r:=new_reference(procinfo.framepointer,para_offset-pushedparasize);
-                       exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,
-                         p^.left^.location.register,r)));
+                       emit_reg_ref(A_MOV,S_L,
+                         p^.left^.location.register,r);
                     end
                   else
-                    exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,p^.left^.location.register)));
+                    emit_reg(A_PUSH,S_L,p^.left^.location.register);
                   ungetregister32(p^.left^.location.register);
                 end
               else
@@ -120,10 +120,10 @@ implementation
                      begin
                        if inlined then
                          begin
-                           exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-                             newreference(p^.left^.location.reference),R_EDI)));
+                           emit_ref_reg(A_LEA,S_L,
+                             newreference(p^.left^.location.reference),R_EDI);
                            r:=new_reference(procinfo.framepointer,para_offset-pushedparasize);
-                           exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,R_EDI,r)));
+                           emit_reg_ref(A_MOV,S_L,R_EDI,r);
                          end
                       else
                         emitpushreferenceaddr(p^.left^.location.reference);
@@ -140,10 +140,10 @@ implementation
               inc(pushedparasize,4);
               if inlined then
                 begin
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-                     newreference(p^.left^.location.reference),R_EDI)));
+                   emit_ref_reg(A_LEA,S_L,
+                     newreference(p^.left^.location.reference),R_EDI);
                    r:=new_reference(procinfo.framepointer,para_offset-pushedparasize);
-                   exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,R_EDI,r)));
+                   emit_reg_ref(A_MOV,S_L,R_EDI,r);
                 end
               else
                 emitpushreferenceaddr(p^.left^.location.reference);
@@ -160,11 +160,11 @@ implementation
                    inc(pushedparasize,4);
                    if inlined then
                      begin
-                        exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-                          newreference(p^.left^.location.reference),R_EDI)));
+                        emit_ref_reg(A_LEA,S_L,
+                          newreference(p^.left^.location.reference),R_EDI);
                         r:=new_reference(procinfo.framepointer,para_offset-pushedparasize);
-                        exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,
-                          R_EDI,r)));
+                        emit_reg_ref(A_MOV,S_L,
+                          R_EDI,r);
                      end
                    else
                      emitpushreferenceaddr(p^.left^.location.reference);
@@ -224,6 +224,7 @@ implementation
          { we must pop this size also after !! }
 {        must_pop : boolean; }
          pop_size : longint;
+         pop_allowed : boolean;
 
       label
          dont_call;
@@ -303,7 +304,17 @@ implementation
          oldpushedparasize:=pushedparasize;
          pushedparasize:=0;
          pop_size:=0;
-         if (not inlined) then
+         { no inc esp for inlined procedure
+           and for objects constructors PM }
+         if inlined or
+            ((p^.right=nil) and
+            (p^.procdefinition^.proctypeoption=potype_constructor) and
+            { quick'n'dirty check if it is a class or an object }
+            (p^.resulttype^.deftype=orddef)) then
+           pop_allowed:=false
+         else
+           pop_allowed:=true;
+         if pop_allowed then
           begin
           { Old pushedsize aligned on 4 ? }
             i:=oldpushedparasize and 3;
@@ -314,10 +325,12 @@ implementation
             if i>0 then
              inc(pop_size,4-i);
           { insert the opcode and update pushedparasize }
+          { never push 4 or more !! }
+            pop_size:=pop_size mod 4;
             if pop_size>0 then
              begin
                inc(pushedparasize,pop_size);
-               exprasmlist^.concat(new(pai386,op_const_reg(A_SUB,S_L,pop_size,R_ESP)));
+               emit_const_reg(A_SUB,S_L,pop_size,R_ESP);
 {$ifdef GDB}
                if (cs_debuginfo in aktmoduleswitches) and
                   (exprasmlist^.first=exprasmlist^.last) then
@@ -382,11 +395,11 @@ implementation
               inc(pushedparasize,4);
               if inlined then
                 begin
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-                     newreference(funcretref),R_EDI)));
+                   emit_ref_reg(A_LEA,S_L,
+                     newreference(funcretref),R_EDI);
                    r:=new_reference(procinfo.framepointer,inlinecode^.retoffset);
-                   exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,
-                     R_EDI,r)));
+                   emit_reg_ref(A_MOV,S_L,
+                     R_EDI,r);
                 end
               else
                 emitpushreferenceaddr(funcretref);
@@ -426,9 +439,9 @@ implementation
                    r^:=ptree(pwithsymtable(p^.symtable)^.withnode)^.withreference^;
                    if (not pwithsymtable(p^.symtable)^.direct_with) or
                       pobjectdef(p^.methodpointer^.resulttype)^.is_class then
-                     exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_ESI)))
+                     emit_ref_reg(A_MOV,S_L,r,R_ESI)
                    else
-                     exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,r,R_ESI)));
+                     emit_ref_reg(A_LEA,S_L,r,R_ESI);
                 end;
 
               { push self }
@@ -468,14 +481,14 @@ implementation
                                          loadesi:=true;
                                          { if no VMT just use $0 bug0214 PM }
                                          if not(oo_has_vmt in pobjectdef(p^.methodpointer^.resulttype)^.objectoptions) then
-                                           exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_L,0,R_ESI)))
+                                           emit_const_reg(A_MOV,S_L,0,R_ESI)
                                          else
                                            begin
-                                             exprasmlist^.concat(new(pai386,op_sym_ofs_reg(A_MOV,S_L,
+                                             emit_sym_ofs_reg(A_MOV,S_L,
                                                newasmsymbol(pobjectdef(p^.methodpointer^.resulttype)^.vmt_mangledname),
-                                               0,R_ESI)));
+                                               0,R_ESI);
                                            end;
-                                         { exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                                         { emit_reg(A_PUSH,S_L,R_ESI);
                                            this is done below !! }
                                       end
                                     else
@@ -488,7 +501,7 @@ implementation
                                        (aktprocsym^.definition^.proctypeoption=potype_destructor) then
                                       begin
                                         push_int(0);
-                                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                                        emit_reg(A_PUSH,S_L,R_ESI);
                                       end;
 
                                     if not(is_con_or_destructor and
@@ -496,7 +509,7 @@ implementation
                                            assigned(aktprocsym) and
                                            (aktprocsym^.definition^.proctypeoption in [potype_constructor,potype_destructor])
                                           ) then
-                                      exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                                      emit_reg(A_PUSH,S_L,R_ESI);
                                     { if an inherited con- or destructor should be  }
                                     { called in a con- or destructor then a warning }
                                     { will be made                                }
@@ -514,17 +527,17 @@ implementation
                                         not(pobjectdef(p^.methodpointer^.resulttype)^.is_class and
                                         assigned(aktprocsym) and
                                         (aktprocsym^.definition^.proctypeoption=potype_destructor)) then
-                                      push_int(0);
+                                       push_int(0);
                                  end;
                                hnewn:
                                  begin
                                     { extended syntax of new }
                                     { ESI must be zero }
-                                    exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,R_ESI,R_ESI)));
-                                    exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                                    emit_reg_reg(A_XOR,S_L,R_ESI,R_ESI);
+                                    emit_reg(A_PUSH,S_L,R_ESI);
                                     { insert the vmt }
-                                    exprasmlist^.concat(new(pai386,op_sym(A_PUSH,S_L,
-                                      newasmsymbol(pobjectdef(p^.methodpointer^.resulttype)^.vmt_mangledname))));
+                                    emit_sym(A_PUSH,S_L,
+                                      newasmsymbol(pobjectdef(p^.methodpointer^.resulttype)^.vmt_mangledname));
                                     extended_new:=true;
                                  end;
                                hdisposen:
@@ -533,12 +546,12 @@ implementation
 
                                     { destructor with extended syntax called from dispose }
                                     { hdisposen always deliver LOC_REFERENCE          }
-                                    exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-                                      newreference(p^.methodpointer^.location.reference),R_ESI)));
+                                    emit_ref_reg(A_LEA,S_L,
+                                      newreference(p^.methodpointer^.location.reference),R_ESI);
                                     del_reference(p^.methodpointer^.location.reference);
-                                    exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
-                                    exprasmlist^.concat(new(pai386,op_sym(A_PUSH,S_L,
-                                      newasmsymbol(pobjectdef(p^.methodpointer^.resulttype)^.vmt_mangledname))));
+                                    emit_reg(A_PUSH,S_L,R_ESI);
+                                    emit_sym(A_PUSH,S_L,
+                                      newasmsymbol(pobjectdef(p^.methodpointer^.resulttype)^.vmt_mangledname));
                                  end;
                                else
                                  begin
@@ -558,11 +571,11 @@ implementation
                                                  if (p^.methodpointer^.resulttype^.deftype=classrefdef) or
                                                     ((p^.methodpointer^.resulttype^.deftype=objectdef) and
                                                    pobjectdef(p^.methodpointer^.resulttype)^.is_class) then
-                                                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                                     newreference(p^.methodpointer^.location.reference),R_ESI)))
+                                                   emit_ref_reg(A_MOV,S_L,
+                                                     newreference(p^.methodpointer^.location.reference),R_ESI)
                                                  else
-                                                   exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-                                                     newreference(p^.methodpointer^.location.reference),R_ESI)));
+                                                   emit_ref_reg(A_LEA,S_L,
+                                                     newreference(p^.methodpointer^.location.reference),R_ESI);
                                                  del_reference(p^.methodpointer^.location.reference);
                                               end;
                                          end;
@@ -579,22 +592,22 @@ implementation
                                              reset_reference(r^);
                                              r^.base:=R_ESI;
                                              r^.offset:= pprocdef(p^.procdefinition)^._class^.vmt_offset;
-                                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_ESI)));
+                                             emit_ref_reg(A_MOV,S_L,r,R_ESI);
                                           end;
 
                                         { direct call to destructor: don't remove data! }
                                         if (p^.procdefinition^.proctypeoption=potype_destructor) and
                                            (p^.methodpointer^.resulttype^.deftype=objectdef) and
                                            (pobjectdef(p^.methodpointer^.resulttype)^.is_class) then
-                                          exprasmlist^.concat(new(pai386,op_const(A_PUSH,S_L,1)));
+                                          emit_const(A_PUSH,S_L,1);
 
                                         { direct call to class constructor, don't allocate memory }
                                         if (p^.procdefinition^.proctypeoption=potype_constructor) and
                                            (p^.methodpointer^.resulttype^.deftype=objectdef) and
                                            (pobjectdef(p^.methodpointer^.resulttype)^.is_class) then
-                                          exprasmlist^.concat(new(pai386,op_const(A_PUSH,S_L,0)))
+                                          emit_const(A_PUSH,S_L,0)
                                         else
-                                          exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                                          emit_reg(A_PUSH,S_L,R_ESI);
                                       end;
 
                                     if is_con_or_destructor then
@@ -606,8 +619,8 @@ implementation
                                               if (p^.procdefinition^.proctypeoption=potype_constructor) then
                                                 begin
                                                    { it's no bad idea, to insert the VMT }
-                                                   exprasmlist^.concat(new(pai386,op_sym(A_PUSH,S_L,newasmsymbol(
-                                                     pobjectdef(p^.methodpointer^.resulttype)^.vmt_mangledname))));
+                                                   emit_sym(A_PUSH,S_L,newasmsymbol(
+                                                     pobjectdef(p^.methodpointer^.resulttype)^.vmt_mangledname));
                                                 end
                                               { destructors haven't to dispose the instance, if this is }
                                               { a direct call                                      }
@@ -632,14 +645,14 @@ implementation
                              reset_reference(r^);
                              r^.base:=R_ESI;
                              r^.offset:= pprocdef(p^.procdefinition)^._class^.vmt_offset;
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_ESI)));
+                             emit_ref_reg(A_MOV,S_L,r,R_ESI);
                           end
                         else
                           begin
                              { member call, ESI isn't modified }
                              loadesi:=false;
                           end;
-                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                        emit_reg(A_PUSH,S_L,R_ESI);
                         { but a con- or destructor here would probably almost }
                         { always be placed wrong }
                         if is_con_or_destructor then
@@ -661,7 +674,7 @@ implementation
                    {
                      begin
                         loadesi:=false;
-                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                        emit_reg(A_PUSH,S_L,R_ESI);
                      end;
                    }
                    if lexlevel=(pprocdef(p^.procdefinition)^.parast^.symtablelevel) then
@@ -670,13 +683,13 @@ implementation
                         reset_reference(r^);
                         r^.offset:=procinfo.framepointer_offset;
                         r^.base:=procinfo.framepointer;
-                        exprasmlist^.concat(new(pai386,op_ref(A_PUSH,S_L,r)))
+                        emit_ref(A_PUSH,S_L,r)
                      end
                      { this is only true if the difference is one !!
                        but it cannot be more !! }
                    else if (lexlevel=pprocdef(p^.procdefinition)^.parast^.symtablelevel-1) then
                      begin
-                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,procinfo.framepointer)))
+                        emit_reg(A_PUSH,S_L,procinfo.framepointer)
                      end
                    else if (lexlevel>pprocdef(p^.procdefinition)^.parast^.symtablelevel) then
                      begin
@@ -685,7 +698,7 @@ implementation
                         reset_reference(r^);
                         r^.offset:=procinfo.framepointer_offset;
                         r^.base:=procinfo.framepointer;
-                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,hregister)));
+                        emit_ref_reg(A_MOV,S_L,r,hregister);
                         for i:=(pprocdef(p^.procdefinition)^.parast^.symtablelevel) to lexlevel-1 do
                           begin
                              new(r);
@@ -694,9 +707,9 @@ implementation
                              how can we do this !!! }
                              r^.offset:=procinfo.framepointer_offset;
                              r^.base:=hregister;
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,hregister)));
+                             emit_ref_reg(A_MOV,S_L,r,hregister);
                           end;
-                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,hregister)));
+                        emit_reg(A_PUSH,S_L,hregister);
                         ungetregister32(hregister);
                      end
                    else
@@ -732,7 +745,7 @@ implementation
                             r^.base:=R_ESI;
                             { this is one point where we need vmt_offset (PM) }
                             r^.offset:= pprocdef(p^.procdefinition)^._class^.vmt_offset;
-                            exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_EDI)));
+                            emit_ref_reg(A_MOV,S_L,r,R_EDI);
                             new(r);
                             reset_reference(r^);
                             r^.base:=R_EDI;
@@ -746,7 +759,7 @@ implementation
                        new(r);
                        reset_reference(r^);
                        r^.base:=R_ESI;
-                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_EDI)));
+                       emit_ref_reg(A_MOV,S_L,r,R_EDI);
                        new(r);
                        reset_reference(r^);
                        r^.base:=R_EDI;
@@ -758,19 +771,19 @@ implementation
 {$ifndef TESTOBJEXT}
                    if (cs_check_range in aktlocalswitches) then
                      begin
-                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,r^.base)));
+                        emit_reg(A_PUSH,S_L,r^.base);
                         emitcall('FPC_CHECK_OBJECT');
                      end;
 {$else TESTOBJEXT}
                    if (cs_check_range in aktlocalswitches) then
                      begin
-                        exprasmlist^.concat(new(pai386,op_sym(A_PUSH,S_L,
-                          newasmsymbol(pprocdef(p^.procdefinition)^._class^.vmt_mangledname))));
-                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,r^.base)));
+                        emit_sym(A_PUSH,S_L,
+                          newasmsymbol(pprocdef(p^.procdefinition)^._class^.vmt_mangledname));
+                        emit_reg(A_PUSH,S_L,r^.base);
                         emitcall('FPC_CHECK_OBJECT_EXT');
                      end;
 {$endif TESTOBJEXT}
-                   exprasmlist^.concat(new(pai386,op_ref(A_CALL,S_NO,r)));
+                   emit_ref(A_CALL,S_NO,r);
                 end
               else if not inlined then
                 emitcall(pprocdef(p^.procdefinition)^.mangledname)
@@ -806,8 +819,8 @@ implementation
                       (p^.right^.location.reference.index=R_ESI) then
                      begin
                         del_reference(p^.right^.location.reference);
-                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                          newreference(p^.right^.location.reference),R_EDI)));
+                        emit_ref_reg(A_MOV,S_L,
+                          newreference(p^.right^.location.reference),R_EDI);
                         hregister:=R_EDI;
                      end;
 
@@ -816,17 +829,17 @@ implementation
                      begin
                        { load ESI }
                        inc(p^.right^.location.reference.offset,4);
-                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                         newreference(p^.right^.location.reference),R_ESI)));
+                       emit_ref_reg(A_MOV,S_L,
+                         newreference(p^.right^.location.reference),R_ESI);
                        dec(p^.right^.location.reference.offset,4);
                        { push self pointer }
-                       exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ESI)));
+                       emit_reg(A_PUSH,S_L,R_ESI);
                      end;
 
                    if hregister=R_NO then
-                     exprasmlist^.concat(new(pai386,op_ref(A_CALL,S_NO,newreference(p^.right^.location.reference))))
+                     emit_ref(A_CALL,S_NO,newreference(p^.right^.location.reference))
                    else
-                     exprasmlist^.concat(new(pai386,op_reg(A_CALL,S_NO,hregister)));
+                     emit_reg(A_CALL,S_NO,hregister);
 
                    del_reference(p^.right^.location.reference);
                 end
@@ -835,11 +848,11 @@ implementation
                    case p^.right^.location.loc of
                       LOC_REGISTER,LOC_CREGISTER:
                          begin
-                             exprasmlist^.concat(new(pai386,op_reg(A_CALL,S_NO,p^.right^.location.register)));
+                             emit_reg(A_CALL,S_NO,p^.right^.location.register);
                              ungetregister32(p^.right^.location.register);
                          end
                       else
-                         exprasmlist^.concat(new(pai386,op_ref(A_CALL,S_NO,newreference(p^.right^.location.reference))));
+                         emit_ref(A_CALL,S_NO,newreference(p^.right^.location.reference));
                          del_reference(p^.right^.location.reference);
                    end;
                 end;
@@ -855,7 +868,7 @@ implementation
                 pop_size:=0;
                 { better than an add on all processors }
                 if pushedparasize=4 then
-                  exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDI)))
+                  emit_reg(A_POP,S_L,R_EDI)
                 { the pentium has two pipes and pop reg is pairable }
                 { but the registers must be different!        }
                 else if (pushedparasize=8) and
@@ -863,16 +876,28 @@ implementation
                   (aktoptprocessor=ClassP5) and
                   (procinfo._class=nil) then
                     begin
-                       exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDI)));
-                       exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_ESI)));
+                       emit_reg(A_POP,S_L,R_EDI);
+                       emit_reg(A_POP,S_L,R_ESI);
                     end
                 else if pushedparasize<>0 then
-                  exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,pushedparasize,R_ESP)));
+                  emit_const_reg(A_ADD,S_L,pushedparasize,R_ESP);
              end;
       dont_call:
          pushedparasize:=oldpushedparasize;
          unused:=unusedregisters;
 
+         { a constructor could be a function with boolean result }
+         { if calling constructor called fail we
+           must jump directly to quickexitlabel  PM
+           but only if it is a call of an inherited constructor }
+         if (p^.right=nil) and
+            (p^.procdefinition^.proctypeoption=potype_constructor) and
+            assigned(p^.methodpointer) and
+            (p^.methodpointer^.treetype=typen) and
+            (aktprocsym^.definition^.proctypeoption=potype_constructor) then
+           begin
+             emitjmp(C_Z,faillabel);
+           end;
          { handle function results }
          { structured results are easy to handle.... }
          { needed also when result_no_used !! }
@@ -893,8 +918,10 @@ implementation
                  { quick'n'dirty check if it is a class or an object }
                  (p^.resulttype^.deftype=orddef) then
                 begin
+                   { this fails if popsize > 0 PM }
                    p^.location.loc:=LOC_FLAGS;
                    p^.location.resflags:=F_NE;
+                   
                    if extended_new then
                      begin
 {$ifdef test_dest_loc}
@@ -1007,8 +1034,8 @@ implementation
                    emit_reg_reg(A_MOV,S_L,R_EAX,hregister);
                    if gettempansistringreference(hr) then
                      decrstringref(p^.resulttype,hr);
-                   exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,hregister,
-                     newreference(hr))));
+                   emit_reg_ref(A_MOV,S_L,hregister,
+                     newreference(hr));
                    ungetregister32(hregister);
                    p^.location.loc:=LOC_MEM;
                    p^.location.reference:=hr;
@@ -1033,11 +1060,11 @@ implementation
          { perhaps i/o check ? }
          if iolabel<>nil then
            begin
-              exprasmlist^.concat(new(pai386,op_sym(A_PUSH,S_L,iolabel)));
+              emit_sym(A_PUSH,S_L,iolabel);
               emitcall('FPC_IOCHECK');
            end;
          if pop_size>0 then
-           exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,pop_size,R_ESP)));
+           emit_const_reg(A_ADD,S_L,pop_size,R_ESP);
 
          { restore registers }
          popusedregisters(pushed);
@@ -1094,7 +1121,7 @@ implementation
               else if p^.location.loc=LOC_FPU then
                 begin
                   { release FPU stack }
-                  exprasmlist^.concat(new(pai386,op_reg(A_FSTP,S_NO,R_ST0)));
+                  emit_reg(A_FSTP,S_NO,R_ST0);
                   dec(fpuvaroffset);
                 end;
            end;
@@ -1178,7 +1205,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.99  1999-08-09 22:19:47  peter
+  Revision 1.100  1999-08-19 13:08:45  pierre
+   * emit_??? used
+
+  Revision 1.99  1999/08/09 22:19:47  peter
     * classes vmt changed to only positive addresses
     * sharedlib creation is working
 

compiler/cg386cnv.pas

@@ -79,8 +79,8 @@ implementation
               begin
                  if (p^.right^.treetype=stringconstn) and
                    (str_length(p^.right)=0) then
-                   exprasmlist^.concat(new(pai386,op_const_ref(
-                      A_MOV,S_B,0,newreference(p^.left^.location.reference))))
+                   emit_const_ref(
+                      A_MOV,S_B,0,newreference(p^.left^.location.reference))
                  else
                    begin
                      emitpushreferenceaddr(p^.left^.location.reference);
@@ -93,27 +93,24 @@ implementation
             orddef:
               begin
                  if p^.right^.treetype=ordconstn then
-                   exprasmlist^.concat(new(pai386,op_const_ref(
-                      A_MOV,S_W,p^.right^.value*256+1,newreference(p^.left^.location.reference))))
+                   emit_const_ref(
+                      A_MOV,S_W,p^.right^.value*256+1,newreference(p^.left^.location.reference))
                  else
                    begin
                       { not so elegant (goes better with extra register }
                       if (p^.right^.location.loc in [LOC_REGISTER,LOC_CREGISTER]) then
                         begin
-                           exprasmlist^.concat(new(pai386,op_reg_reg(
-                              A_MOV,S_L,makereg32(p^.right^.location.register),R_EDI)));
+                           emit_reg_reg(A_MOV,S_L,makereg32(p^.right^.location.register),R_EDI);
                            ungetregister(p^.right^.location.register);
                         end
                       else
                         begin
-                           exprasmlist^.concat(new(pai386,op_ref_reg(
-                              A_MOV,S_L,newreference(p^.right^.location.reference),R_EDI)));
+                           emit_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),R_EDI);
                            del_reference(p^.right^.location.reference);
                         end;
-                      exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,8,R_EDI)));
-                      exprasmlist^.concat(new(pai386,op_const_reg(A_OR,S_L,1,R_EDI)));
-                      exprasmlist^.concat(new(pai386,op_reg_ref(
-                         A_MOV,S_W,R_DI,newreference(p^.left^.location.reference))));
+                      emit_const_reg(A_SHL,S_L,8,R_EDI);
+                      emit_const_reg(A_OR,S_L,1,R_EDI);
+                      emit_reg_ref(A_MOV,S_W,R_DI,newreference(p^.left^.location.reference));
                    end;
               end;
          else
@@ -134,8 +131,7 @@ implementation
               begin
                  if (p^.right^.treetype=stringconstn) and
                    (str_length(p^.right)=0) then
-                   exprasmlist^.concat(new(pai386,op_const_ref(
-                      A_MOV,S_L,0,newreference(p^.left^.location.reference))))
+                   emit_const_ref(A_MOV,S_L,0,newreference(p^.left^.location.reference))
                  else
                    begin
                      emitpushreferenceaddr(p^.left^.location.reference);
@@ -147,37 +143,30 @@ implementation
               end;
             orddef:
               begin
-                 exprasmlist^.concat(new(pai386,op_const_ref(
-                    A_MOV,S_L,1,newreference(p^.left^.location.reference))));
+                 emit_const_ref(A_MOV,S_L,1,newreference(p^.left^.location.reference));
 
                  r:=newreference(p^.left^.location.reference);
                  inc(r^.offset,4);
 
                  if p^.right^.treetype=ordconstn then
-                   exprasmlist^.concat(new(pai386,op_const_ref(
-                      A_MOV,S_B,p^.right^.value,r)))
+                   emit_const_ref(A_MOV,S_B,p^.right^.value,r)
                  else
                    begin
                       case p^.right^.location.loc of
                          LOC_REGISTER,LOC_CREGISTER:
                            begin
-                              exprasmlist^.concat(new(pai386,op_reg_ref(
-                                 A_MOV,S_B,p^.right^.location.register,r)));
+                              emit_reg_ref(A_MOV,S_B,p^.right^.location.register,r);
                               ungetregister(p^.right^.location.register);
                            end;
                          LOC_MEM,LOC_REFERENCE:
                            begin
                               if not(R_EAX in unused) then
-                                exprasmlist^.concat(new(pai386,op_reg(
-                                  A_PUSH,S_L,R_EAX)));
-                              exprasmlist^.concat(new(pai386,op_ref_reg(
-                                A_MOV,S_B,newreference(p^.right^.location.reference),R_AL)));
-                              exprasmlist^.concat(new(pai386,op_reg_ref(
-                                A_MOV,S_B,R_AL,r)));
+                                emit_reg(A_PUSH,S_L,R_EAX);
+                              emit_ref_reg(A_MOV,S_B,newreference(p^.right^.location.reference),R_AL);
+                              emit_reg_ref(A_MOV,S_B,R_AL,r);
 
                               if not(R_EAX in unused) then
-                                exprasmlist^.concat(new(pai386,op_reg(
-                                   A_POP,S_L,R_EAX)));
+                                emit_reg(A_POP,S_L,R_EAX);
                               del_reference(p^.right^.location.reference);
                            end
                          else
@@ -217,10 +206,10 @@ implementation
 {$IfNDef regallocfix}
                 ungetregister32(source^.location.register);
                 pushusedregisters(pushed,$ff);
-                exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,source^.location.register)));
+                emit_reg(A_PUSH,S_L,source^.location.register);
 {$Else regallocfix}
                  pushusedregisters(pushed, $ff xor ($80 shr byte(source^.location.register)));
-                 exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,source^.location.register)));
+                 emit_reg(A_PUSH,S_L,source^.location.register);
                  ungetregister32(source^.location.register);
 {$EndIf regallocfix}
              end;
@@ -331,23 +320,22 @@ implementation
             if pfrom^.location.loc in [LOC_CREGISTER,LOC_REGISTER] then
               emit_reg_reg(op,opsize,pfrom^.location.register,pto^.location.register)
             else
-              exprasmlist^.concat(new(pai386,op_ref_reg(op,opsize,
-                newreference(pfrom^.location.reference),pto^.location.register)));
+              emit_ref_reg(op,opsize,
+                newreference(pfrom^.location.reference),pto^.location.register);
 
             { do we need a sign extension for int64? }
             if is_64bitint(pto^.resulttype) then
               begin
-                 exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,
-                   hregister2,hregister2)));
+                 emit_reg_reg(A_XOR,S_L,
+                   hregister2,hregister2);
                  if (porddef(pto^.resulttype)^.typ=s64bit) and
                    is_signed(pfrom^.resulttype) then
                    begin
                       getlabel(l);
-                      exprasmlist^.concat(new(pai386,op_const_reg(A_TEST,S_L,
-                        $80000000,makereg32(hregister))));
+                      emit_const_reg(A_TEST,S_L,$80000000,makereg32(hregister));
                       emitjmp(C_Z,l);
-                      exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,
-                        hregister2)));
+                      emit_reg(A_NOT,S_L,
+                        hregister2);
                       emitlab(l);
                    end;
               end;
@@ -479,13 +467,13 @@ implementation
            st_shortstring :
              begin
                inc(pfrom^.location.reference.offset);
-               exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,newreference(pfrom^.location.reference),
-                 pto^.location.register)));
+               emit_ref_reg(A_LEA,S_L,newreference(pfrom^.location.reference),
+                 pto^.location.register);
              end;
            st_ansistring :
              begin
-               exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(pfrom^.location.reference),
-                 pto^.location.register)));
+               emit_ref_reg(A_MOV,S_L,newreference(pfrom^.location.reference),
+                 pto^.location.register);
              end;
            st_longstring:
              begin
@@ -533,8 +521,8 @@ implementation
          clear_location(pto^.location);
          pto^.location.loc:=LOC_REGISTER;
          pto^.location.register:=getregister32;
-         exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,newreference(pfrom^.location.reference),
-           pto^.location.register)));
+         emit_ref_reg(A_LEA,S_L,newreference(pfrom^.location.reference),
+           pto^.location.register);
       end;
 
 
@@ -555,8 +543,8 @@ implementation
             begin
               del_reference(pfrom^.location.reference);
               pto^.location.reference.base:=getregister32;
-              exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(pfrom^.location.reference),
-                pto^.location.reference.base)));
+              emit_ref_reg(A_MOV,S_L,newreference(pfrom^.location.reference),
+                pto^.location.reference.base);
             end;
         end;
       end;
@@ -586,8 +574,8 @@ implementation
                { first get the memory for the string }
                gettempofsizereference(256,pto^.location.reference);
                { write the length }
-               exprasmlist^.concat(new(pai386,op_const_ref(A_MOV,S_B,l,
-                 newreference(pto^.location.reference))));
+               emit_const_ref(A_MOV,S_B,l,
+                 newreference(pto^.location.reference));
                { copy to first char of string }
                inc(pto^.location.reference.offset);
                { generates the copy code      }
@@ -677,15 +665,15 @@ implementation
             (pfrom^.location.loc=LOC_CREGISTER) then
            begin
               case porddef(pfrom^.resulttype)^.typ of
-                 s8bit : exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVSX,S_BL,pfrom^.location.register,R_EDI)));
-                 u8bit : exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVZX,S_BL,pfrom^.location.register,R_EDI)));
-                 s16bit : exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVSX,S_WL,pfrom^.location.register,R_EDI)));
-                 u16bit : exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVZX,S_WL,pfrom^.location.register,R_EDI)));
+                 s8bit : emit_reg_reg(A_MOVSX,S_BL,pfrom^.location.register,R_EDI);
+                 u8bit : emit_reg_reg(A_MOVZX,S_BL,pfrom^.location.register,R_EDI);
+                 s16bit : emit_reg_reg(A_MOVSX,S_WL,pfrom^.location.register,R_EDI);
+                 u16bit : emit_reg_reg(A_MOVZX,S_WL,pfrom^.location.register,R_EDI);
                  u32bit,s32bit:
                    hregister:=pfrom^.location.register;
                  u64bit,s64bit:
                    begin
-                      exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,pfrom^.location.registerhigh)));
+                      emit_reg(A_PUSH,S_L,pfrom^.location.registerhigh);
                       hregister:=pfrom^.location.registerlow;
                    end;
               end;
@@ -696,40 +684,40 @@ implementation
               r:=newreference(pfrom^.location.reference);
               case porddef(pfrom^.resulttype)^.typ of
                  s8bit:
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVSX,S_BL,r,R_EDI)));
+                   emit_ref_reg(A_MOVSX,S_BL,r,R_EDI);
                  u8bit:
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVZX,S_BL,r,R_EDI)));
+                   emit_ref_reg(A_MOVZX,S_BL,r,R_EDI);
                  s16bit:
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVSX,S_WL,r,R_EDI)));
+                   emit_ref_reg(A_MOVSX,S_WL,r,R_EDI);
                  u16bit:
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVZX,S_WL,r,R_EDI)));
+                   emit_ref_reg(A_MOVZX,S_WL,r,R_EDI);
                  u32bit,s32bit:
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_EDI)));
+                   emit_ref_reg(A_MOV,S_L,r,R_EDI);
                  u64bit,s64bit:
                    begin
                       inc(r^.offset,4);
-                      exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_EDI)));
-                      exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EDI)));
+                      emit_ref_reg(A_MOV,S_L,r,R_EDI);
+                      emit_reg(A_PUSH,S_L,R_EDI);
                       r:=newreference(pfrom^.location.reference);
-                      exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_EDI)));
+                      emit_ref_reg(A_MOV,S_L,r,R_EDI);
                    end;
               end;
               del_reference(pfrom^.location.reference);
               ungetiftemp(pfrom^.location.reference);
            end;
          { for 64 bit integers, the high dword is already pushed }
-         exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,hregister)));
+         emit_reg(A_PUSH,S_L,hregister);
          r:=new_reference(R_ESP,0);
          case porddef(pfrom^.resulttype)^.typ of
            u32bit:
              begin
-                exprasmlist^.concat(new(pai386,op_ref(A_FILD,S_IQ,r)));
-                exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,8,R_ESP)));
+                emit_ref(A_FILD,S_IQ,r);
+                emit_const_reg(A_ADD,S_L,8,R_ESP);
              end;
            s64bit:
              begin
-                exprasmlist^.concat(new(pai386,op_ref(A_FILD,S_IQ,r)));
-                exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,8,R_ESP)));
+                emit_ref(A_FILD,S_IQ,r);
+                emit_const_reg(A_ADD,S_L,8,R_ESP);
              end;
            u64bit:
              begin
@@ -738,12 +726,12 @@ implementation
                 { if it is 1 then we add $80000000 000000000 }
                 { as double                                  }
                 inc(r^.offset,4);
-                exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_EDI)));
+                emit_ref_reg(A_MOV,S_L,r,R_EDI);
                 r:=new_reference(R_ESP,4);
-                exprasmlist^.concat(new(pai386,op_const_ref(A_AND,S_L,$7fffffff,r)));
-                exprasmlist^.concat(new(pai386,op_const_reg(A_AND,S_L,$80000000,R_EDI)));
+                emit_const_ref(A_AND,S_L,$7fffffff,r);
+                emit_const_reg(A_AND,S_L,$80000000,R_EDI);
                 r:=new_reference(R_ESP,0);
-                exprasmlist^.concat(new(pai386,op_ref(A_FILD,S_IQ,r)));
+                emit_ref(A_FILD,S_IQ,r);
                 getdatalabel(l1);
                 getlabel(l2);
                 emitjmp(C_Z,l2);
@@ -753,14 +741,14 @@ implementation
                 consts^.concat(new(pai_const,init_32bit(1138753536)));
                 r:=new_reference(R_NO,0);
                 r^.symbol:=l1;
-                exprasmlist^.concat(new(pai386,op_ref(A_FADD,S_FL,r)));
+                emit_ref(A_FADD,S_FL,r);
                 emitlab(l2);
-                exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,8,R_ESP)));
+                emit_const_reg(A_ADD,S_L,8,R_ESP);
              end
            else
              begin
-                exprasmlist^.concat(new(pai386,op_ref(A_FILD,S_IL,r)));
-                exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDI)));
+                emit_ref(A_FILD,S_IL,r);
+                emit_reg(A_POP,S_L,R_EDI);
              end;
          end;
          inc(fpuvaroffset);
@@ -776,30 +764,30 @@ implementation
       begin
          { real must be on fpu stack }
          if (pfrom^.location.loc<>LOC_FPU) then
-           exprasmlist^.concat(new(pai386,op_ref(A_FLD,S_FL,newreference(pfrom^.location.reference))));
+           emit_ref(A_FLD,S_FL,newreference(pfrom^.location.reference));
          push_int($1f3f);
          push_int(65536);
          reset_reference(ref);
          ref.base:=R_ESP;
 
-         exprasmlist^.concat(new(pai386,op_ref(A_FIMUL,S_IL,newreference(ref))));
+         emit_ref(A_FIMUL,S_IL,newreference(ref));
 
          ref.offset:=4;
-         exprasmlist^.concat(new(pai386,op_ref(A_FSTCW,S_NO,newreference(ref))));
+         emit_ref(A_FSTCW,S_NO,newreference(ref));
 
          ref.offset:=6;
-         exprasmlist^.concat(new(pai386,op_ref(A_FLDCW,S_NO,newreference(ref))));
+         emit_ref(A_FLDCW,S_NO,newreference(ref));
 
          ref.offset:=0;
-         exprasmlist^.concat(new(pai386,op_ref(A_FISTP,S_IL,newreference(ref))));
+         emit_ref(A_FISTP,S_IL,newreference(ref));
 
          ref.offset:=4;
-         exprasmlist^.concat(new(pai386,op_ref(A_FLDCW,S_NO,newreference(ref))));
+         emit_ref(A_FLDCW,S_NO,newreference(ref));
 
          rreg:=getregister32;
-         exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,rreg)));
+         emit_reg(A_POP,S_L,rreg);
          { better than an add on all processors }
-         exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDI)));
+         emit_reg(A_POP,S_L,R_EDI);
 
          clear_location(pto^.location);
          pto^.location.loc:=LOC_REGISTER;
@@ -845,64 +833,64 @@ implementation
               ungetregister(startreg);
               popeax:=(startreg<>R_EAX) and not (R_EAX in unused);
               if popeax then
-                exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
+                emit_reg(A_PUSH,S_L,R_EAX);
               { mov eax,eax is removed by emit_reg_reg }
               emit_reg_reg(A_MOV,S_L,startreg,R_EAX);
            end
          else
            begin
-              exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(
-                pfrom^.location.reference),R_EAX)));
+              emit_ref_reg(A_MOV,S_L,newreference(
+                pfrom^.location.reference),R_EAX);
               del_reference(pfrom^.location.reference);
               startreg:=R_NO;
            end;
 
          popebx:=(startreg<>R_EBX) and not (R_EBX in unused);
          if popebx then
-           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EBX)));
+           emit_reg(A_PUSH,S_L,R_EBX);
 
          popecx:=(startreg<>R_ECX) and not (R_ECX in unused);
          if popecx then
-           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ECX)));
+           emit_reg(A_PUSH,S_L,R_ECX);
 
          popedx:=(startreg<>R_EDX) and not (R_EDX in unused);
          if popedx then
-           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EDX)));
+           emit_reg(A_PUSH,S_L,R_EDX);
 
-         exprasmlist^.concat(new(pai386,op_none(A_CDQ,S_NO)));
+         emit_none(A_CDQ,S_NO);
          emit_reg_reg(A_XOR,S_L,R_EDX,R_EAX);
          emit_reg_reg(A_MOV,S_L,R_EAX,R_EBX);
          emit_reg_reg(A_SUB,S_L,R_EDX,R_EAX);
          getlabel(hl);
          emitjmp(C_Z,hl);
-         exprasmlist^.concat(new(pai386,op_const_reg(A_RCL,S_L,1,R_EBX)));
+         emit_const_reg(A_RCL,S_L,1,R_EBX);
          emit_reg_reg(A_BSR,S_L,R_EAX,R_EDX);
-         exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_B,32,R_CL)));
+         emit_const_reg(A_MOV,S_B,32,R_CL);
          emit_reg_reg(A_SUB,S_B,R_DL,R_CL);
          emit_reg_reg(A_SHL,S_L,R_CL,R_EAX);
-         exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_W,1007,R_DX)));
-         exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_W,5,R_DX)));
-         exprasmlist^.concat(new(pai386,op_const_reg_reg(A_SHLD,S_W,11,R_DX,R_BX)));
-         exprasmlist^.concat(new(pai386,op_const_reg_reg(A_SHLD,S_L,20,R_EAX,R_EBX)));
+         emit_const_reg(A_ADD,S_W,1007,R_DX);
+         emit_const_reg(A_SHL,S_W,5,R_DX);
+         emit_const_reg_reg(A_SHLD,S_W,11,R_DX,R_BX);
+         emit_const_reg_reg(A_SHLD,S_L,20,R_EAX,R_EBX);
 
-         exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,20,R_EAX)));
+         emit_const_reg(A_SHL,S_L,20,R_EAX);
          emitlab(hl);
          { better than an add on all processors }
-         exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EBX)));
-         exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
+         emit_reg(A_PUSH,S_L,R_EBX);
+         emit_reg(A_PUSH,S_L,R_EAX);
 
          reset_reference(r);
          r.base:=R_ESP;
-         exprasmlist^.concat(new(pai386,op_ref(A_FLD,S_FL,newreference(r))));
-         exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,8,R_ESP)));
+         emit_ref(A_FLD,S_FL,newreference(r));
+         emit_const_reg(A_ADD,S_L,8,R_ESP);
          if popedx then
-           exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDX)));
+           emit_reg(A_POP,S_L,R_EDX);
          if popecx then
-           exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_ECX)));
+           emit_reg(A_POP,S_L,R_ECX);
          if popebx then
-           exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EBX)));
+           emit_reg(A_POP,S_L,R_EBX);
          if popeax then
-           exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EAX)));
+           emit_reg(A_POP,S_L,R_EAX);
 
          clear_location(pto^.location);
          pto^.location.loc:=LOC_FPU;
@@ -922,20 +910,20 @@ implementation
               del_reference(pfrom^.location.reference);
               hregister:=getregister32;
               case porddef(pfrom^.resulttype)^.typ of
-                s8bit : exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVSX,S_BL,newreference(pfrom^.location.reference),
-                  hregister)));
-                u8bit : exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVZX,S_BL,newreference(pfrom^.location.reference),
-                  hregister)));
-                s16bit : exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVSX,S_WL,newreference(pfrom^.location.reference),
-                  hregister)));
-                u16bit : exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVZX,S_WL,newreference(pfrom^.location.reference),
-                  hregister)));
-                u32bit,s32bit : exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(pfrom^.location.reference),
-                  hregister)));
+                s8bit : emit_ref_reg(A_MOVSX,S_BL,newreference(pfrom^.location.reference),
+                  hregister);
+                u8bit : emit_ref_reg(A_MOVZX,S_BL,newreference(pfrom^.location.reference),
+                  hregister);
+                s16bit : emit_ref_reg(A_MOVSX,S_WL,newreference(pfrom^.location.reference),
+                  hregister);
+                u16bit : emit_ref_reg(A_MOVZX,S_WL,newreference(pfrom^.location.reference),
+                  hregister);
+                u32bit,s32bit : emit_ref_reg(A_MOV,S_L,newreference(pfrom^.location.reference),
+                  hregister);
                 {!!!! u32bit }
               end;
            end;
-         exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,16,hregister)));
+         emit_const_reg(A_SHL,S_L,16,hregister);
 
          clear_location(pto^.location);
          pto^.location.loc:=LOC_REGISTER;
@@ -956,8 +944,8 @@ implementation
              pto^.location.loc:=LOC_REGISTER;
              pto^.location.register:=getregister32;
              del_reference(pfrom^.location.reference);
-             exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-               newreference(pfrom^.location.reference),pto^.location.register)));
+             emit_ref_reg(A_LEA,S_L,
+               newreference(pfrom^.location.reference),pto^.location.register);
           end;
       end;
 
@@ -1053,14 +1041,14 @@ implementation
 
          case pfrom^.location.loc of
             LOC_MEM,
-      LOC_REFERENCE : exprasmlist^.concat(new(pai386,op_ref_reg(op,opsize,
-                        newreference(pfrom^.location.reference),pto^.location.register)));
+      LOC_REFERENCE : emit_ref_reg(op,opsize,
+                        newreference(pfrom^.location.reference),pto^.location.register);
        LOC_REGISTER,
       LOC_CREGISTER : begin
                       { remove things like movb %al,%al }
                         if pfrom^.location.register<>pto^.location.register then
-                          exprasmlist^.concat(new(pai386,op_reg_reg(op,opsize,
-                            pfrom^.location.register,pto^.location.register)));
+                          emit_reg_reg(op,opsize,
+                            pfrom^.location.register,pto^.location.register);
                       end;
           LOC_FLAGS : begin
                         emit_flag2reg(pfrom^.location.resflags,pto^.location.register);
@@ -1068,11 +1056,11 @@ implementation
            LOC_JUMP : begin
                         getlabel(hlabel);
                         emitlab(truelabel);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,newsize,1,pto^.location.register)));
+                        emit_const_reg(A_MOV,newsize,1,pto^.location.register);
                         emitjmp(C_None,hlabel);
                         emitlab(falselabel);
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,newsize,pto^.location.register,
-                          pto^.location.register)));
+                        emit_reg_reg(A_XOR,newsize,pto^.location.register,
+                          pto^.location.register);
                         emitlab(hlabel);
                       end;
          else
@@ -1108,9 +1096,9 @@ implementation
             LOC_MEM,LOC_REFERENCE :
               begin
                 hregister:=def_getreg(pfrom^.resulttype);
-                exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                  newreference(pfrom^.location.reference),hregister)));
-                exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,opsize,hregister,hregister)));
+                emit_ref_reg(A_MOV,opsize,
+                  newreference(pfrom^.location.reference),hregister);
+                emit_reg_reg(A_OR,opsize,hregister,hregister);
                 flags:=F_NE;
               end;
             LOC_FLAGS :
@@ -1121,7 +1109,7 @@ implementation
             LOC_REGISTER,LOC_CREGISTER :
               begin
                 hregister:=pfrom^.location.register;
-                exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,opsize,hregister,hregister)));
+                emit_reg_reg(A_OR,opsize,hregister,hregister);
                 flags:=F_NE;
               end;
             else
@@ -1168,28 +1156,28 @@ implementation
          getlabel(l2);
          case pfrom^.location.loc of
             LOC_CREGISTER,LOC_REGISTER:
-              exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,S_L,0,
-                pfrom^.location.register)));
+              emit_const_reg(A_CMP,S_L,0,
+                pfrom^.location.register);
             LOC_MEM,LOC_REFERENCE:
               begin
-                 exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_L,0,
-                   newreference(pfrom^.location.reference))));
+                 emit_const_ref(A_CMP,S_L,0,
+                   newreference(pfrom^.location.reference));
                   del_reference(pfrom^.location.reference);
                   pto^.location.register:=getregister32;
                end;
          end;
          emitjmp(C_Z,l1);
          if pfrom^.location.loc in [LOC_MEM,LOC_REFERENCE] then
-           exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(
+           emit_ref_reg(A_MOV,S_L,newreference(
              pfrom^.location.reference),
-             pto^.location.register)));
+             pto^.location.register);
          emitjmp(C_None,l2);
          emitlab(l1);
          new(hr);
          reset_reference(hr^);
          hr^.symbol:=newasmsymbol('FPC_EMPTYCHAR');
-         exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,hr,
-           pto^.location.register)));
+         emit_ref_reg(A_LEA,S_L,hr,
+           pto^.location.register);
          emitlab(l2);
       end;
 
@@ -1207,7 +1195,7 @@ implementation
                 case pfrom^.location.loc of
                    LOC_REGISTER,LOC_CREGISTER:
                      begin
-                        exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,pfrom^.location.register)));
+                        emit_reg(A_PUSH,S_L,pfrom^.location.register);
                         ungetregister32(pfrom^.location.register);
                      end;
                    LOC_REFERENCE,LOC_MEM:
@@ -1246,10 +1234,10 @@ implementation
 {$IfNDef regallocfix}
                       ungetregister32(pfrom^.location.register);
                       pushusedregisters(pushed,$ff);
-                      exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,pfrom^.location.register)));
+                      emit_reg(A_PUSH,S_L,pfrom^.location.register);
 {$Else regallocfix}
                       pushusedregisters(pushed, $ff xor ($80 shr byte(pfrom^.location.register)));
-                      exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,pfrom^.location.register)));
+                      emit_reg(A_PUSH,S_L,pfrom^.location.register);
                       ungetregister32(pfrom^.location.register);
 {$EndIf regallocfix}
                    end;
@@ -1343,15 +1331,15 @@ implementation
                                r^.base:=R_EDI;
                             end;
                           { NIL must be accepted !! }
-                          exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,S_L,r^.base,r^.base)));
+                          emit_reg_reg(A_OR,S_L,r^.base,r^.base);
                           getlabel(nillabel);
                           emitjmp(C_E,nillabel);
                           { this is one point where we need vmt_offset (PM) }
                           r^.offset:= pobjectdef(ppointerdef(p^.resulttype)^.definition)^.vmt_offset;
-                          exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,R_EDI)));
-                          exprasmlist^.concat(new(pai386,op_sym(A_PUSH,S_L,
-                            newasmsymbol(pobjectdef(ppointerdef(p^.resulttype)^.definition)^.vmt_mangledname))));
-                          exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EDI)));
+                          emit_ref_reg(A_MOV,S_L,r,R_EDI);
+                          emit_sym(A_PUSH,S_L,
+                            newasmsymbol(pobjectdef(ppointerdef(p^.resulttype)^.definition)^.vmt_mangledname));
+                          emit_reg(A_PUSH,S_L,R_EDI);
                           emitcall('FPC_CHECK_OBJECT_EXT');
                           emitlab(nillabel);
                        end;
@@ -1379,14 +1367,14 @@ implementation
          case p^.left^.location.loc of
             LOC_REGISTER,LOC_CREGISTER:
               begin
-                 exprasmlist^.concat(new(pai386,op_reg(A_PUSH,
-                   S_L,p^.left^.location.register)));
+                 emit_reg(A_PUSH,
+                   S_L,p^.left^.location.register);
                  ungetregister32(p^.left^.location.register);
               end;
             LOC_MEM,LOC_REFERENCE:
               begin
-                 exprasmlist^.concat(new(pai386,op_ref(A_PUSH,
-                   S_L,newreference(p^.left^.location.reference))));
+                 emit_ref(A_PUSH,
+                   S_L,newreference(p^.left^.location.reference));
                  del_reference(p^.left^.location.reference);
               end;
             else internalerror(100);
@@ -1397,20 +1385,20 @@ implementation
          case p^.right^.location.loc of
             LOC_REGISTER,LOC_CREGISTER:
               begin
-                 exprasmlist^.concat(new(pai386,op_reg(A_PUSH,
-                   S_L,p^.right^.location.register)));
+                 emit_reg(A_PUSH,
+                   S_L,p^.right^.location.register);
                  ungetregister32(p^.right^.location.register);
               end;
             LOC_MEM,LOC_REFERENCE:
               begin
-                 exprasmlist^.concat(new(pai386,op_ref(A_PUSH,
-                   S_L,newreference(p^.right^.location.reference))));
+                 emit_ref(A_PUSH,
+                   S_L,newreference(p^.right^.location.reference));
                  del_reference(p^.right^.location.reference);
               end;
             else internalerror(100);
          end;
          emitcall('FPC_DO_IS');
-         exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,S_B,R_AL,R_AL)));
+         emit_reg_reg(A_OR,S_B,R_AL,R_AL);
          popusedregisters(pushed);
          maybe_loadesi;
       end;
@@ -1431,11 +1419,11 @@ implementation
          { push instance to check: }
          case p^.left^.location.loc of
             LOC_REGISTER,LOC_CREGISTER:
-              exprasmlist^.concat(new(pai386,op_reg(A_PUSH,
-                S_L,p^.left^.location.register)));
+              emit_reg(A_PUSH,
+                S_L,p^.left^.location.register);
             LOC_MEM,LOC_REFERENCE:
-              exprasmlist^.concat(new(pai386,op_ref(A_PUSH,
-                S_L,newreference(p^.left^.location.reference))));
+              emit_ref(A_PUSH,
+                S_L,newreference(p^.left^.location.reference));
             else internalerror(100);
          end;
 
@@ -1447,14 +1435,14 @@ implementation
          case p^.right^.location.loc of
             LOC_REGISTER,LOC_CREGISTER:
               begin
-                 exprasmlist^.concat(new(pai386,op_reg(A_PUSH,
-                   S_L,p^.right^.location.register)));
+                 emit_reg(A_PUSH,
+                   S_L,p^.right^.location.register);
                  ungetregister32(p^.right^.location.register);
               end;
             LOC_MEM,LOC_REFERENCE:
               begin
-                 exprasmlist^.concat(new(pai386,op_ref(A_PUSH,
-                   S_L,newreference(p^.right^.location.reference))));
+                 emit_ref(A_PUSH,
+                   S_L,newreference(p^.right^.location.reference));
                  del_reference(p^.right^.location.reference);
               end;
             else internalerror(100);
@@ -1469,7 +1457,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.84  1999-08-05 14:58:03  florian
+  Revision 1.85  1999-08-19 13:08:46  pierre
+   * emit_??? used
+
+  Revision 1.84  1999/08/05 14:58:03  florian
     * some fixes for the floating point registers
     * more things for the new code generator
 

compiler/cg386inl.pas

@@ -188,7 +188,7 @@ implementation
             new(r);
             reset_reference(r^);
             r^.symbol:=newasmsymbol('U_'+upper(target_info.system_unit)+io[doread]);
-            exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,r,R_EDI)))
+            emit_ref_reg(A_LEA,S_L,r,R_EDI)
           end;
 
         const
@@ -228,7 +228,7 @@ implementation
                 { the following instructions are for "writeln;" }
                 loadstream;
                 { save @aktfile in temporary variable }
-                exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,R_EDI,newreference(aktfile))));
+                emit_reg_ref(A_MOV,S_L,R_EDI,newreference(aktfile));
              end
            else
              begin
@@ -255,7 +255,7 @@ implementation
                           exit;
                        end;
 
-                     exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,newreference(node^.left^.location.reference),R_EDI)));
+                     emit_ref_reg(A_LEA,S_L,newreference(node^.left^.location.reference),R_EDI);
 
                      { skip to the next parameter }
                      node:=node^.right;
@@ -267,7 +267,7 @@ implementation
                   end;
 
                 { save @aktfile in temporary variable }
-                exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,R_EDI,newreference(aktfile))));
+                emit_reg_ref(A_MOV,S_L,R_EDI,newreference(aktfile));
                 if doread then
                 { parameter by READ gives call by reference }
                   dummycoll.paratyp:=vs_var
@@ -473,7 +473,7 @@ implementation
            if assigned(iolabel) then
              begin
                 { registers are saved in the procedure }
-                exprasmlist^.concat(new(pai386,op_sym(A_PUSH,S_L,iolabel)));
+                emit_sym(A_PUSH,S_L,iolabel);
                 emitcall('FPC_IOCHECK');
              end;
          { Freeup all used temps }
@@ -721,7 +721,7 @@ implementation
                         {if we are converting to a signed number, we have to include the
                          size of the destination, so the Val function can extend the sign
                          of the result to allow proper range checking}
-                        exprasmlist^.concat(new(pai386,op_const(A_PUSH,S_L,dest_para^.resulttype^.size)));
+                        emit_const(A_PUSH,S_L,dest_para^.resulttype^.size);
                         procedureprefix := 'FPC_VAL_SINT_'
                       end
                     else
@@ -763,13 +763,13 @@ implementation
               {load the address of the code parameter}
                secondpass(code_para^.left);
               {move the code to its destination}
-               exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,NewReference(hr),R_EDI)));
+               emit_ref_reg(A_MOV,S_L,NewReference(hr),R_EDI);
                emit_mov_reg_loc(R_DI,code_para^.left^.location);
                Disposetree(code_para);
              End;
 
           {restore the address of the result}
-           exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDI)));
+           emit_reg(A_POP,S_L,R_EDI);
 
           {set up hr2 to a refernce with EDI as base register}
            reset_reference(hr2);
@@ -782,22 +782,22 @@ implementation
              orddef:
                Case PordDef(dest_para^.left^.resulttype)^.typ of
                  u8bit,s8bit:
-                   exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV, S_B,
-                     RegToReg8(hreg),newreference(hr2))));
+                   emit_reg_ref(A_MOV, S_B,
+                     RegToReg8(hreg),newreference(hr2));
                  u16bit,s16bit:
-                   exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV, S_W,
-                     RegToReg16(hreg),newreference(hr2))));
+                   emit_reg_ref(A_MOV, S_W,
+                     RegToReg16(hreg),newreference(hr2));
                  u32bit,s32bit:
-                   exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV, S_L,
-                     hreg,newreference(hr2))));
+                   emit_reg_ref(A_MOV, S_L,
+                     hreg,newreference(hr2));
                  u64bit,s64bit:
                    begin
-                      exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV, S_L,
-                        hreg,newreference(hr2))));
+                      emit_reg_ref(A_MOV, S_L,
+                        hreg,newreference(hr2));
                       r:=newreference(hr2);
                       inc(r^.offset,4);
-                      exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV, S_L,
-                        hreg2,r)));
+                      emit_reg_ref(A_MOV, S_L,
+                        hreg2,r);
                    end;
                End;
            End;
@@ -863,9 +863,9 @@ implementation
                       maketojumpbool(p^.left^.left);
                       emitlab(falselabel);
                       { erroraddr }
-                      exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EBP)));
+                      emit_reg(A_PUSH,S_L,R_EBP);
                       { lineno }
-                      exprasmlist^.concat(new(pai386,op_const(A_PUSH,S_L,aktfilepos.line)));
+                      emit_const(A_PUSH,S_L,aktfilepos.line);
                       { filename string }
                       hp:=genstringconstnode(current_module^.sourcefiles^.get_file_name(aktfilepos.fileindex));
                       secondpass(hp);
@@ -902,13 +902,13 @@ implementation
                        begin
                           del_reference(p^.left^.location.reference);
                           p^.location.register:=reg32toreg16(getregister32);
-                          exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_W,newreference(p^.left^.location.reference),
-                            p^.location.register)));
+                          emit_ref_reg(A_MOV,S_W,newreference(p^.left^.location.reference),
+                            p^.location.register);
                        end;
                    end
                  else p^.location.register:=p^.left^.location.register;
                  if p^.inlinenumber=in_hi_word then
-                   exprasmlist^.concat(new(pai386,op_const_reg(A_SHR,S_W,8,p^.location.register)));
+                   emit_const_reg(A_SHR,S_W,8,p^.location.register);
                  p^.location.register:=reg16toreg8(p^.location.register);
               end;
             in_sizeof_x,
@@ -918,9 +918,9 @@ implementation
                  if p^.left^.treetype=typen then
                    begin
                       p^.location.register:=getregister32;
-                      exprasmlist^.concat(new(pai386,op_sym_ofs_reg(A_MOV,
+                      emit_sym_ofs_reg(A_MOV,
                         S_L,newasmsymbol(pobjectdef(p^.left^.resulttype)^.vmt_mangledname),0,
-                        p^.location.register)));
+                        p^.location.register);
                    end
                  else
                    begin
@@ -931,9 +931,9 @@ implementation
                       { load VMT pointer }
                       inc(p^.left^.location.reference.offset,
                         pobjectdef(p^.left^.resulttype)^.vmt_offset);
-                      exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
+                      emit_ref_reg(A_MOV,S_L,
                       newreference(p^.left^.location.reference),
-                        p^.location.register)));
+                        p^.location.register);
                    end;
                  { in sizeof load size }
                  if p^.inlinenumber=in_sizeof_x then
@@ -941,8 +941,8 @@ implementation
                       new(r);
                       reset_reference(r^);
                       r^.base:=p^.location.register;
-                      exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,r,
-                        p^.location.register)));
+                      emit_ref_reg(A_MOV,S_L,r,
+                        p^.location.register);
                    end;
               end;
             in_lo_long,
@@ -962,13 +962,13 @@ implementation
                         begin
                            del_reference(p^.left^.location.reference);
                            p^.location.register:=getregister32;
-                           exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
-                             p^.location.register)));
+                           emit_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
+                             p^.location.register);
                         end;
                    end
                  else p^.location.register:=p^.left^.location.register;
                  if p^.inlinenumber=in_hi_long then
-                   exprasmlist^.concat(new(pai386,op_const_reg(A_SHR,S_L,16,p^.location.register)));
+                   emit_const_reg(A_SHR,S_L,16,p^.location.register);
                  p^.location.register:=reg32toreg16(p^.location.register);
               end;
             in_lo_qword,
@@ -994,8 +994,8 @@ implementation
                          r:=newreference(p^.left^.location.reference);
                          if p^.inlinenumber=in_hi_qword then
                            inc(r^.offset,4);
-                         exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                           r,p^.location.register)));
+                         emit_ref_reg(A_MOV,S_L,
+                           r,p^.location.register);
                       end;
                     LOC_REGISTER:
                       begin
@@ -1066,18 +1066,18 @@ implementation
                       else
                         begin
                            del_reference(p^.left^.location.reference);
-                           exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,newreference(p^.left^.location.reference),
-                             p^.location.register)));
+                           emit_ref_reg(A_MOV,opsize,newreference(p^.left^.location.reference),
+                             p^.location.register);
                         end;
                    end
                  else p^.location.register:=p^.left^.location.register;
 
                  if not (cs_check_overflow in aktlocalswitches) then
-                   exprasmlist^.concat(new(pai386,op_reg(asmop,opsize,
-                     p^.location.register)))
+                   emit_reg(asmop,opsize,
+                     p^.location.register)
                  else
-                   exprasmlist^.concat(new(pai386,op_const_reg(asmop,opsize,1,
-                     p^.location.register)));
+                   emit_const_reg(asmop,opsize,1,
+                     p^.location.register);
                  emitoverflowcheck(p);
                  emitrangecheck(p,p^.resulttype);
               end;
@@ -1124,16 +1124,16 @@ implementation
                   LOC_REFERENCE : begin
                                     del_reference(p^.left^.right^.left^.location.reference);
                                     hregister:=getregister32;
-                                    exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                      newreference(p^.left^.right^.left^.location.reference),hregister)));
+                                    emit_ref_reg(A_MOV,S_L,
+                                      newreference(p^.left^.right^.left^.location.reference),hregister);
                                   end;
                        else
                         internalerror(10082);
                        end;
                     { insert multiply with addvalue if its >1 }
                       if addvalue>1 then
-                       exprasmlist^.concat(new(pai386,op_const_reg(A_IMUL,opsize,
-                         addvalue,hregister)));
+                       emit_const_reg(A_IMUL,opsize,
+                         addvalue,hregister);
                       addconstant:=false;
                     end;
                  end;
@@ -1143,20 +1143,20 @@ implementation
                    if (addvalue=1) and not(cs_check_overflow in aktlocalswitches) then
                      begin
                         if p^.left^.left^.location.loc=LOC_CREGISTER then
-                          exprasmlist^.concat(new(pai386,op_reg(incdecop[p^.inlinenumber],opsize,
-                            p^.left^.left^.location.register)))
+                          emit_reg(incdecop[p^.inlinenumber],opsize,
+                            p^.left^.left^.location.register)
                         else
-                          exprasmlist^.concat(new(pai386,op_ref(incdecop[p^.inlinenumber],opsize,
-                            newreference(p^.left^.left^.location.reference))))
+                          emit_ref(incdecop[p^.inlinenumber],opsize,
+                            newreference(p^.left^.left^.location.reference))
                      end
                    else
                      begin
                         if p^.left^.left^.location.loc=LOC_CREGISTER then
-                          exprasmlist^.concat(new(pai386,op_const_reg(addsubop[p^.inlinenumber],opsize,
-                            addvalue,p^.left^.left^.location.register)))
+                          emit_const_reg(addsubop[p^.inlinenumber],opsize,
+                            addvalue,p^.left^.left^.location.register)
                         else
-                          exprasmlist^.concat(new(pai386,op_const_ref(addsubop[p^.inlinenumber],opsize,
-                            addvalue,newreference(p^.left^.left^.location.reference))));
+                          emit_const_ref(addsubop[p^.inlinenumber],opsize,
+                            addvalue,newreference(p^.left^.left^.location.reference));
                      end
                  end
                 else
@@ -1172,11 +1172,11 @@ implementation
                       S_W : hregister:=makereg16(hregister);
                     end;
                     if p^.left^.left^.location.loc=LOC_CREGISTER then
-                      exprasmlist^.concat(new(pai386,op_reg_reg(addsubop[p^.inlinenumber],opsize,
-                        hregister,p^.left^.left^.location.register)))
+                      emit_reg_reg(addsubop[p^.inlinenumber],opsize,
+                        hregister,p^.left^.left^.location.register)
                     else
-                      exprasmlist^.concat(new(pai386,op_reg_ref(addsubop[p^.inlinenumber],opsize,
-                        hregister,newreference(p^.left^.left^.location.reference))));
+                      emit_reg_ref(addsubop[p^.inlinenumber],opsize,
+                        hregister,newreference(p^.left^.left^.location.reference));
                     case opsize of
                       S_B : hregister:=reg8toreg32(hregister);
                       S_W : hregister:=reg16toreg32(hregister);
@@ -1192,15 +1192,15 @@ implementation
                  p^.location.loc:=LOC_FLAGS;
                  if (p^.left^.left^.location.loc in [LOC_REGISTER,LOC_CREGISTER]) then
                    begin
-                      exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,S_L,
+                      emit_reg_reg(A_OR,S_L,
                         p^.left^.left^.location.register,
-                        p^.left^.left^.location.register)));
+                        p^.left^.left^.location.register);
                       ungetregister32(p^.left^.left^.location.register);
                    end
                  else
                    begin
-                      exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_L,0,
-                        newreference(p^.left^.left^.location.reference))));
+                      emit_const_ref(A_CMP,S_L,0,
+                        newreference(p^.left^.left^.location.reference));
                       del_reference(p^.left^.left^.location.reference);
                    end;
                  p^.location.resflags:=F_NE;
@@ -1208,7 +1208,7 @@ implementation
              in_reset_typedfile,in_rewrite_typedfile :
                begin
                   pushusedregisters(pushed,$ff);
-                  exprasmlist^.concat(new(pai386,op_const(A_PUSH,S_L,pfiledef(p^.left^.resulttype)^.typed_as^.size)));
+                  emit_const(A_PUSH,S_L,pfiledef(p^.left^.resulttype)^.typed_as^.size);
                   secondpass(p^.left);
                   emitpushreferenceaddr(p^.left^.location.reference);
                   if p^.inlinenumber=in_reset_typedfile then
@@ -1254,14 +1254,14 @@ implementation
                       if (p^.left^.left^.location.loc=LOC_REFERENCE) then
                         begin
                            inc(p^.left^.left^.location.reference.offset,(p^.left^.right^.left^.value div 32)*4);
-                           exprasmlist^.concat(new(pai386,op_const_ref(asmop,S_L,
-                             l,newreference(p^.left^.left^.location.reference))));
+                           emit_const_ref(asmop,S_L,
+                             l,newreference(p^.left^.left^.location.reference));
                            del_reference(p^.left^.left^.location.reference);
                         end
                       else
                         { LOC_CREGISTER }
-                        exprasmlist^.concat(new(pai386,op_const_reg(asmop,S_L,
-                          l,p^.left^.left^.location.register)));
+                        emit_const_reg(asmop,S_L,
+                          l,p^.left^.left^.location.register);
                    end
                  else
                    begin
@@ -1287,15 +1287,15 @@ implementation
                                  op:=A_MOV
                                 else
                                  op:=A_MOVZX;
-                                exprasmlist^.concat(new(pai386,op_ref_reg(op,opsize,
-                                  newreference(p^.left^.right^.left^.location.reference),R_EDI)));
+                                emit_ref_reg(op,opsize,
+                                  newreference(p^.left^.right^.left^.location.reference),R_EDI);
                              end;
                           if (p^.left^.left^.location.loc=LOC_REFERENCE) then
-                            exprasmlist^.concat(new(pai386,op_reg_ref(asmop,S_L,hregister,
-                              newreference(p^.left^.left^.location.reference))))
+                            emit_reg_ref(asmop,S_L,hregister,
+                              newreference(p^.left^.left^.location.reference))
                           else
-                            exprasmlist^.concat(new(pai386,op_reg_reg(asmop,S_L,hregister,
-                              p^.left^.left^.location.register)));
+                            emit_reg_reg(asmop,S_L,hregister,
+                              p^.left^.left^.location.register);
                         end
                       else
                         begin
@@ -1319,7 +1319,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.67  1999-08-10 13:21:08  pierre
+  Revision 1.68  1999-08-19 13:08:47  pierre
+   * emit_??? used
+
+  Revision 1.67  1999/08/10 13:21:08  pierre
    * fpuvaroffset not increased for f32bit float type
 
   Revision 1.66  1999/08/10 12:47:53  pierre

compiler/cg386ld.pas

@@ -79,16 +79,16 @@ implementation
                    if pconstsym(p^.symtableentry)^.consttype=constresourcestring then
                      begin
                          pushusedregisters(pushed,$ff);
-                         exprasmlist^.concat(new(pai386,op_const(A_PUSH,S_L,
-                         pconstsym(p^.symtableentry)^.reshash)));
+                         emit_const(A_PUSH,S_L,
+                           pconstsym(p^.symtableentry)^.reshash);
                          emitcall('FPC_GETRESOURCESTRING');
 
                          hregister:=getexplicitregister32(R_EAX);
                          emit_reg_reg(A_MOV,S_L,R_EAX,hregister);
                          if gettempansistringreference(hr) then
                            decrstringref(p^.resulttype,hr);
-                         exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,hregister,
-                           newreference(hr))));
+                         emit_reg_ref(A_MOV,S_L,hregister,
+                           newreference(hr));
                         ungetregister32(hregister);
                         popusedregisters(pushed);
 
@@ -111,7 +111,7 @@ implementation
                       begin
                          hregister:=getregister32;
                          p^.location.reference.symbol:=newasmsymbol(p^.symtableentry^.mangledname);
-                         exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.location.reference),hregister)));
+                         emit_ref_reg(A_MOV,S_L,newreference(p^.location.reference),hregister);
                          p^.location.reference.symbol:=nil;
                          p^.location.reference.base:=hregister;
                       end
@@ -125,9 +125,9 @@ implementation
                       begin
                          popeax:=not(R_EAX in unused);
                          if popeax then
-                           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
+                           emit_reg(A_PUSH,S_L,R_EAX);
                          p^.location.reference.symbol:=newasmsymbol(p^.symtableentry^.mangledname);
-                         exprasmlist^.concat(new(pai386,op_ref(A_PUSH,S_L,newreference(p^.location.reference))));
+                         emit_ref(A_PUSH,S_L,newreference(p^.location.reference));
                          { the called procedure isn't allowed to change }
                          { any register except EAX                    }
                          emitcall('FPC_RELOCATE_THREADVAR');
@@ -136,7 +136,7 @@ implementation
                          p^.location.reference.base:=getregister32;
                          emit_reg_reg(A_MOV,S_L,R_EAX,p^.location.reference.base);
                          if popeax then
-                           exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EAX)));
+                           emit_reg(A_POP,S_L,R_EAX);
 
                       end
                     { normal variable }
@@ -183,7 +183,7 @@ implementation
                                         hp:=new_reference(procinfo.framepointer,
                                           procinfo.framepointer_offset);
 
-                                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,hp,hregister)));
+                                        emit_ref_reg(A_MOV,S_L,hp,hregister);
 
                                         simple_loadn:=false;
                                         i:=lexlevel-1;
@@ -191,7 +191,7 @@ implementation
                                           begin
                                              { make a reference }
                                              hp:=new_reference(hregister,8);
-                                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,hp,hregister)));
+                                             emit_ref_reg(A_MOV,S_L,hp,hregister);
                                              dec(i);
                                           end;
                                         p^.location.reference.base:=hregister;
@@ -230,7 +230,7 @@ implementation
 {                                       hp:=new_reference(procinfo.framepointer,
                                           p^.symtable^.datasize);
 
-                                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,hp,hregister)));}
+                                        emit_ref_reg(A_MOV,S_L,hp,hregister);}
 
                                         if ptree(pwithsymtable(p^.symtable)^.withnode)^.islocal then
                                          begin
@@ -240,9 +240,9 @@ implementation
                                          begin
                                            hregister:=getregister32;
                                            p^.location.reference.base:=hregister;
-                                           exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
+                                           emit_ref_reg(A_MOV,S_L,
                                              newreference(ptree(pwithsymtable(p^.symtable)^.withnode)^.withreference^),
-                                             hregister)));
+                                             hregister);
                                          end;
                                         inc(p^.location.reference.offset,pvarsym(p^.symtableentry)^.address);
                                      end;
@@ -261,15 +261,15 @@ implementation
                                 hregister:=getregister32;
                               if p^.location.loc=LOC_CREGISTER then
                                 begin
-                                   exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,S_L,
-                                     p^.location.register,hregister)));
+                                   emit_reg_reg(A_MOV,S_L,
+                                     p^.location.register,hregister);
                                    p^.location.loc:=LOC_REFERENCE;
                                 end
                               else
                                 begin
-                                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
+                                   emit_ref_reg(A_MOV,S_L,
                                      newreference(p^.location.reference),
-                                     hregister)));
+                                     hregister);
                                 end;
                               reset_reference(p^.location.reference);
                               p^.location.reference.base:=hregister;
@@ -300,8 +300,8 @@ implementation
                             LOC_REFERENCE:
                               begin
                                  hregister:=R_EDI;
-                                 exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                   newreference(p^.left^.location.reference),R_EDI)));
+                                 emit_ref_reg(A_MOV,S_L,
+                                   newreference(p^.left^.location.reference),R_EDI);
                                  del_reference(p^.left^.location.reference);
                                  ungetiftemp(p^.left^.location.reference);
                               end;
@@ -312,8 +312,8 @@ implementation
                          new(hp);
                          hp^:=p^.location.reference;
                          inc(hp^.offset,4);
-                         exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,
-                           hregister,hp)));
+                         emit_reg_ref(A_MOV,S_L,
+                           hregister,hp);
 
                          { virtual method ? }
                          if (po_virtualmethod in pprocsym(p^.symtableentry)^.definition^.procoptions) then
@@ -322,8 +322,8 @@ implementation
                               reset_reference(hp^);
                               hp^.base:=hregister;
                               { load vmt pointer }
-                              exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                hp,R_EDI)));
+                              emit_ref_reg(A_MOV,S_L,
+                                hp,R_EDI);
 {$IfDef regallocfix}
                               del_reference(hp^);
 {$EndIf regallocfix}
@@ -333,17 +333,17 @@ implementation
                               hp^.base:=R_EDI;
                               hp^.offset:=pprocsym(p^.symtableentry)^.definition^._class^.vmtmethodoffset(
                                 pprocsym(p^.symtableentry)^.definition^.extnumber);
-                              exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                                hp,R_EDI)));
+                              emit_ref_reg(A_MOV,S_L,
+                                hp,R_EDI);
                               { ... and store it }
-                              exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,
-                                R_EDI,newreference(p^.location.reference))));
+                              emit_reg_ref(A_MOV,S_L,
+                                R_EDI,newreference(p^.location.reference));
                            end
                          else
                            begin
                               s:=newasmsymbol(pprocsym(p^.symtableentry)^.definition^.mangledname);
-                              exprasmlist^.concat(new(pai386,op_sym_ofs_ref(A_MOV,S_L,s,0,
-                                newreference(p^.location.reference))));
+                              emit_sym_ofs_ref(A_MOV,S_L,s,0,
+                                newreference(p^.location.reference));
                            end;
                       end
                     else
@@ -397,9 +397,9 @@ implementation
                                 begin
                                    del_reference(p^.left^.location.reference);
                                    hregister:=getregister32;
-                                   exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,newreference(
+                                   emit_ref_reg(A_LEA,S_L,newreference(
                                      p^.left^.location.reference),
-                                     hregister)));
+                                     hregister);
                                    reset_reference(p^.left^.location.reference);
                                    p^.left^.location.reference.base:=hregister;
                                    p^.left^.location.reference.index:=R_NO;
@@ -466,8 +466,8 @@ implementation
                       if (p^.right^.treetype=stringconstn) and
                          (p^.right^.length=0) then
                         begin
-                          exprasmlist^.concat(new(pai386,op_const_ref(A_MOV,S_B,
-                            0,newreference(p^.left^.location.reference))));
+                          emit_const_ref(A_MOV,S_B,
+                            0,newreference(p^.left^.location.reference));
 {$IfDef regallocfix}
                           del_reference(p^.left^.location.reference);
 {$EndIf regallocfix}
@@ -510,15 +510,15 @@ implementation
                               end;
                               if loc=LOC_CREGISTER then
                                 begin
-                                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
+                                  emit_ref_reg(A_MOV,opsize,
                                     newreference(p^.right^.location.reference),
-                                    p^.left^.location.register)));
+                                    p^.left^.location.register);
                                   if is_64bitint(p^.right^.resulttype) then
                                     begin
                                        r:=newreference(p^.right^.location.reference);
                                        inc(r^.offset,4);
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,r,
-                                         p^.left^.location.registerhigh)));
+                                       emit_ref_reg(A_MOV,opsize,r,
+                                         p^.left^.location.registerhigh);
                                     end;
 {$IfDef regallocfix}
                                   del_reference(p^.right^.location.reference);
@@ -526,32 +526,32 @@ implementation
                                 end
                               else
                                 begin
-                                  exprasmlist^.concat(new(pai386,op_const_ref(A_MOV,opsize,
+                                  emit_const_ref(A_MOV,opsize,
                                     p^.right^.location.reference.offset,
-                                    newreference(p^.left^.location.reference))));
+                                    newreference(p^.left^.location.reference));
                                   if is_64bitint(p^.right^.resulttype) then
                                     begin
                                        r:=newreference(p^.left^.location.reference);
                                        inc(r^.offset,4);
-                                       exprasmlist^.concat(new(pai386,op_const_ref(A_MOV,opsize,
-                                         0,r)));
+                                       emit_const_ref(A_MOV,opsize,
+                                         0,r);
                                     end;
 {$IfDef regallocfix}
                                   del_reference(p^.left^.location.reference);
 {$EndIf regallocfix}
-                                {exprasmlist^.concat(new(pai386,op_const_loc(A_MOV,opsize,
+                                {emit_const_loc(A_MOV,opsize,
                                     p^.right^.location.reference.offset,
-                                    p^.left^.location)));}
+                                    p^.left^.location);}
                                 end;
 
                            end
                          else if loc=LOC_CFPUREGISTER then
                            begin
                               floatloadops(pfloatdef(p^.right^.resulttype)^.typ,op,opsize);
-                              exprasmlist^.concat(new(pai386,op_ref(op,opsize,
-                                newreference(p^.right^.location.reference))));
-                              exprasmlist^.concat(new(pai386,op_reg(A_FSTP,S_NO,
-                                correct_fpuregister(p^.left^.location.register,fpuvaroffset+1))));
+                              emit_ref(op,opsize,
+                                newreference(p^.right^.location.reference));
+                              emit_reg(A_FSTP,S_NO,
+                                correct_fpuregister(p^.left^.location.register,fpuvaroffset+1));
                            end
                          else
                            begin
@@ -570,16 +570,14 @@ implementation
                                    emitpushreferenceaddr(r^);
 
                                    emitpushreferenceaddr(p^.right^.location.reference);
-                                   exprasmlist^.concat(new(pai386,
-                                     op_sym(A_CALL,S_NO,newasmsymbol('FPC_ADDREF'))));
+                                   emitcall('FPC_ADDREF');
                                    { decrement destination reference counter }
                                    new(r);
                                    reset_reference(r^);
                                    r^.symbol:=p^.left^.resulttype^.get_inittable_label;
                                    emitpushreferenceaddr(r^);
                                    emitpushreferenceaddr(p^.left^.location.reference);
-                                   exprasmlist^.concat(new(pai386,
-                                     op_sym(A_CALL,S_NO,newasmsymbol('FPC_DECREF'))));
+                                   emitcall('FPC_DECREF');
                                 end;
 
 {$ifdef regallocfix}
@@ -598,11 +596,11 @@ implementation
             LOC_MMXREGISTER:
               begin
                  if loc=LOC_CMMXREGISTER then
-                   exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVQ,S_NO,
-                   p^.right^.location.register,p^.left^.location.register)))
+                   emit_reg_reg(A_MOVQ,S_NO,
+                   p^.right^.location.register,p^.left^.location.register)
                  else
-                   exprasmlist^.concat(new(pai386,op_reg_ref(A_MOVQ,S_NO,
-                     p^.right^.location.register,newreference(p^.left^.location.reference))));
+                   emit_reg_ref(A_MOVQ,S_NO,
+                     p^.right^.location.register,newreference(p^.left^.location.reference));
               end;
 {$endif SUPPORT_MMX}
             LOC_REGISTER,
@@ -616,18 +614,18 @@ implementation
                               { simplified with op_reg_loc       }
                               if loc=LOC_CREGISTER then
                                 begin
-                                  exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,opsize,
+                                  emit_reg_reg(A_MOV,opsize,
                                     p^.right^.location.register,
-                                    p^.left^.location.register)));
+                                    p^.left^.location.register);
 {$IfDef regallocfix}
                                  ungetregister(p^.right^.location.register);
 {$EndIf regallocfix}
                                 end
                               else
                                 Begin
-                                  exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,opsize,
+                                  emit_reg_ref(A_MOV,opsize,
                                     p^.right^.location.register,
-                                    newreference(p^.left^.location.reference))));
+                                    newreference(p^.left^.location.reference));
 {$IfDef regallocfix}
                                   ungetregister(p^.right^.location.register);
                                   del_reference(p^.left^.location.reference);
@@ -637,20 +635,20 @@ implementation
                                 begin
                                    { simplified with op_reg_loc  }
                                    if loc=LOC_CREGISTER then
-                                     exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,opsize,
+                                     emit_reg_reg(A_MOV,opsize,
                                        p^.right^.location.registerhigh,
-                                       p^.left^.location.registerhigh)))
+                                       p^.left^.location.registerhigh)
                                    else
                                      begin
                                         r:=newreference(p^.left^.location.reference);
                                         inc(r^.offset,4);
-                                        exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,opsize,
-                                          p^.right^.location.registerhigh,r)));
+                                        emit_reg_ref(A_MOV,opsize,
+                                          p^.right^.location.registerhigh,r);
                                      end;
                                 end;
-                              {exprasmlist^.concat(new(pai386,op_reg_loc(A_MOV,opsize,
+                              {emit_reg_loc(A_MOV,opsize,
                                   p^.right^.location.register,
-                                  p^.left^.location)));      }
+                                  p^.left^.location);      }
 
                            end;
             LOC_FPU : begin
@@ -668,8 +666,8 @@ implementation
                               case loc of
                                  LOC_CFPUREGISTER:
                                    begin
-                                      exprasmlist^.concat(new(pai386,op_reg(A_FSTP,S_NO,
-                                        correct_fpuregister(p^.left^.location.register,fpuvaroffset))));
+                                      emit_reg(A_FSTP,S_NO,
+                                        correct_fpuregister(p^.left^.location.register,fpuvaroffset));
                                       dec(fpuvaroffset);
                                    end;
                                  LOC_REFERENCE:
@@ -690,14 +688,14 @@ implementation
                                 fputyp:=pfloatdef(p^.right^.left^.resulttype)^.typ
                               else
                                 fputyp:=s32real;
-                              exprasmlist^.concat(new(pai386,op_reg(A_FLD,S_NO,
-                                correct_fpuregister(p^.right^.location.register,fpuvaroffset))));
+                              emit_reg(A_FLD,S_NO,
+                                correct_fpuregister(p^.right^.location.register,fpuvaroffset));
                               inc(fpuvaroffset);
                               case loc of
                                  LOC_CFPUREGISTER:
                                    begin
-                                      exprasmlist^.concat(new(pai386,op_reg(A_FSTP,S_NO,
-                                        correct_fpuregister(p^.right^.location.register,fpuvaroffset))));
+                                      emit_reg(A_FSTP,S_NO,
+                                        correct_fpuregister(p^.right^.location.register,fpuvaroffset));
                                       dec(fpuvaroffset);
                                    end;
                                  LOC_REFERENCE:
@@ -710,23 +708,23 @@ implementation
                               getlabel(hlabel);
                               emitlab(truelabel);
                               if loc=LOC_CREGISTER then
-                                exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_B,
-                                  1,p^.left^.location.register)))
+                                emit_const_reg(A_MOV,S_B,
+                                  1,p^.left^.location.register)
                               else
-                                exprasmlist^.concat(new(pai386,op_const_ref(A_MOV,S_B,
-                                  1,newreference(p^.left^.location.reference))));
-                              {exprasmlist^.concat(new(pai386,op_const_loc(A_MOV,S_B,
-                                  1,p^.left^.location)));}
+                                emit_const_ref(A_MOV,S_B,
+                                  1,newreference(p^.left^.location.reference));
+                              {emit_const_loc(A_MOV,S_B,
+                                  1,p^.left^.location);}
                               emitjmp(C_None,hlabel);
                               emitlab(falselabel);
                               if loc=LOC_CREGISTER then
-                                exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_B,
+                                emit_reg_reg(A_XOR,S_B,
                                   p^.left^.location.register,
-                                  p^.left^.location.register)))
+                                  p^.left^.location.register)
                               else
                                 begin
-                                  exprasmlist^.concat(new(pai386,op_const_ref(A_MOV,S_B,
-                                    0,newreference(p^.left^.location.reference))));
+                                  emit_const_ref(A_MOV,S_B,
+                                    0,newreference(p^.left^.location.reference));
 {$IfDef regallocfix}
                                   del_reference(p^.left^.location.reference);
 {$EndIf regallocfix}
@@ -773,14 +771,14 @@ implementation
               hr_valid:=true;
               hp:=new_reference(procinfo.framepointer,
                 procinfo.framepointer_offset);
-              exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,hp,hr)));
+              emit_ref_reg(A_MOV,S_L,hp,hr);
               pp:=procinfo.parent;
               { walk up the stack frame }
               while pp<>pprocinfo(p^.funcretprocinfo) do
                 begin
                    hp:=new_reference(hr,
                      pp^.framepointer_offset);
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,hp,hr)));
+                   emit_ref_reg(A_MOV,S_L,hp,hr);
                    pp:=pp^.parent;
                 end;
               p^.location.reference.base:=hr;
@@ -792,7 +790,7 @@ implementation
            begin
               if not hr_valid then
                 hr:=getregister32;
-              exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.location.reference),hr)));
+              emit_ref_reg(A_MOV,S_L,newreference(p^.location.reference),hr);
               p^.location.reference.base:=hr;
               p^.location.reference.offset:=0;
            end;
@@ -927,8 +925,8 @@ implementation
                  else
                   begin
                     { update href to the vtype field and write it }
-                    exprasmlist^.concat(new(pai386,op_const_ref(A_MOV,S_L,
-                      vtype,newreference(href))));
+                    emit_const_ref(A_MOV,S_L,
+                      vtype,newreference(href));
                     inc(href.offset,4);
                     { write changing field update href to the next element }
                     if vaddr then
@@ -966,7 +964,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.74  1999-08-17 13:26:06  peter
+  Revision 1.75  1999-08-19 13:08:49  pierre
+   * emit_??? used
+
+  Revision 1.74  1999/08/17 13:26:06  peter
     * arrayconstructor -> arrayofconst fixed when arraycosntructor was not
       variant.
 

compiler/cg386mat.pas

@@ -118,8 +118,8 @@ implementation
                      begin
                        del_reference(p^.left^.location.reference);
                        hreg1:=getregister32;
-                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
-                         hreg1)));
+                       emit_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
+                         hreg1);
                      end;
                    clear_location(p^.left^.location);
                    p^.left^.location.loc:=LOC_REGISTER;
@@ -136,25 +136,25 @@ implementation
                      "Cardinal($ffffffff) div 16" overflows! (JM)}
                     If is_signed(p^.left^.resulttype) Then
                       Begin
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,S_L,hreg1,hreg1)));
+                        emit_reg_reg(A_OR,S_L,hreg1,hreg1);
                         getlabel(hl);
                         emitjmp(C_NS,hl);
                         if power=1 then
-                          exprasmlist^.concat(new(pai386,op_reg(A_INC,S_L,hreg1)))
+                          emit_reg(A_INC,S_L,hreg1)
                         else
-                          exprasmlist^.concat(new(pai386,op_const_reg(A_ADD,S_L,p^.right^.value-1,hreg1)));
+                          emit_const_reg(A_ADD,S_L,p^.right^.value-1,hreg1);
                         emitlab(hl);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_SAR,S_L,power,hreg1)));
+                        emit_const_reg(A_SAR,S_L,power,hreg1);
                       End
                     Else
-                      exprasmlist^.concat(new(pai386,op_const_reg(A_SHR,S_L,power,hreg1)));
+                      emit_const_reg(A_SHR,S_L,power,hreg1);
                   End
                 else
                   if (p^.treetype=modn) and (p^.right^.treetype=ordconstn) and
                     ispowerof2(p^.right^.value,power) and Not(is_signed(p^.left^.resulttype)) Then
                    {is there a similar trick for MOD'ing signed numbers? (JM)}
                    Begin
-                     exprasmlist^.concat(new(pai386,op_const_reg(A_AND,S_L,p^.right^.value-1,hreg1)));
+                     emit_const_reg(A_AND,S_L,p^.right^.value-1,hreg1);
                      andmod := true;
                    End
                 else
@@ -168,7 +168,7 @@ implementation
                      begin
                        del_reference(p^.right^.location.reference);
                        p^.left^.location.loc:=LOC_REGISTER;
-                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),R_EDI)));
+                       emit_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),R_EDI);
                      end
                    else
                      begin
@@ -181,7 +181,7 @@ implementation
                      begin
                        if not(R_EAX in unused) then
                           begin
-                             exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
+                             emit_reg(A_PUSH,S_L,R_EAX);
                              popeax:=true;
                           end;
                        emit_reg_reg(A_MOV,S_L,R_EDX,R_EAX);
@@ -190,14 +190,14 @@ implementation
                      begin
                         if not(R_EDX in unused) then
                           begin
-                             exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EDX)));
+                             emit_reg(A_PUSH,S_L,R_EDX);
                              popedx:=true;
                           end;
                         if hreg1<>R_EAX then
                           begin
                              if not(R_EAX in unused) then
                                begin
-                                  exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_EAX)));
+                                  emit_reg(A_PUSH,S_L,R_EAX);
                                   popeax:=true;
                                end;
                              emit_reg_reg(A_MOV,S_L,hreg1,R_EAX);
@@ -205,15 +205,15 @@ implementation
                      end;
                    { sign extension depends on the left type }
                    if porddef(p^.left^.resulttype)^.typ=u32bit then
-                      exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,R_EDX,R_EDX)))
+                      emit_reg_reg(A_XOR,S_L,R_EDX,R_EDX)
                    else
-                      exprasmlist^.concat(new(pai386,op_none(A_CDQ,S_NO)));
+                      emit_none(A_CDQ,S_NO);
 
                    { division depends on the right type }
                    if porddef(p^.right^.resulttype)^.typ=u32bit then
-                     exprasmlist^.concat(new(pai386,op_reg(A_DIV,S_L,R_EDI)))
+                     emit_reg(A_DIV,S_L,R_EDI)
                    else
-                     exprasmlist^.concat(new(pai386,op_reg(A_IDIV,S_L,R_EDI)));
+                     emit_reg(A_IDIV,S_L,R_EDI);
                    if p^.treetype=divn then
                      begin
                         { if result register is busy then copy }
@@ -254,9 +254,9 @@ implementation
                              emit_reg_reg(A_MOV,S_L,R_EDX,hreg1);;
                          End;
                    if popeax then
-                     exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EAX)));
+                     emit_reg(A_POP,S_L,R_EAX);
                    if popedx then
-                     exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_EDX)));
+                     emit_reg(A_POP,S_L,R_EDX);
                   end;
               If not(andmod or shrdiv) then
                {andmod and shrdiv only use hreg1 (which is already in usedinproc,
@@ -314,12 +314,12 @@ implementation
                         del_reference(p^.left^.location.reference);
                         hregisterlow:=getregister32;
                         hregisterhigh:=getregister32;
-                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
-                          hregisterlow)));
+                        emit_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
+                          hregisterlow);
                         hr:=newreference(p^.left^.location.reference);
                         inc(hr^.offset,4);
-                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,hr,
-                          hregisterhigh)));
+                        emit_ref_reg(A_MOV,S_L,hr,
+                          hregisterhigh);
                      end;
                 end
               else
@@ -336,17 +336,17 @@ implementation
                      begin
                         if p^.treetype=shln then
                           begin
-                             exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterhigh,
-                               hregisterhigh)));
-                             exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,p^.right^.value and 31,
-                               hregisterlow)));
+                             emit_reg_reg(A_XOR,S_L,hregisterhigh,
+                               hregisterhigh);
+                             emit_const_reg(A_SHL,S_L,p^.right^.value and 31,
+                               hregisterlow);
                           end
                         else
                           begin
-                             exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterlow,
-                               hregisterlow)));
-                             exprasmlist^.concat(new(pai386,op_const_reg(A_SHR,S_L,p^.right^.value and 31,
-                               hregisterhigh)));
+                             emit_reg_reg(A_XOR,S_L,hregisterlow,
+                               hregisterlow);
+                             emit_const_reg(A_SHR,S_L,p^.right^.value and 31,
+                               hregisterhigh);
                           end;
                         p^.location.registerhigh:=hregisterlow;
                         p^.location.registerlow:=hregisterhigh;
@@ -355,17 +355,17 @@ implementation
                      begin
                         if p^.treetype=shln then
                           begin
-                             exprasmlist^.concat(new(pai386,op_const_reg_reg(A_SHLD,S_L,p^.right^.value and 31,
-                               hregisterlow,hregisterhigh)));
-                             exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,p^.right^.value and 31,
-                               hregisterlow)));
+                             emit_const_reg_reg(A_SHLD,S_L,p^.right^.value and 31,
+                               hregisterlow,hregisterhigh);
+                             emit_const_reg(A_SHL,S_L,p^.right^.value and 31,
+                               hregisterlow);
                           end
                         else
                           begin
-                             exprasmlist^.concat(new(pai386,op_const_reg_reg(A_SHRD,S_L,p^.right^.value and 31,
-                               hregisterhigh,hregisterlow)));
-                             exprasmlist^.concat(new(pai386,op_const_reg(A_SHR,S_L,p^.right^.value and 31,
-                               hregisterhigh)));
+                             emit_const_reg_reg(A_SHRD,S_L,p^.right^.value and 31,
+                               hregisterhigh,hregisterlow);
+                             emit_const_reg(A_SHR,S_L,p^.right^.value and 31,
+                               hregisterhigh);
                           end;
                         p^.location.registerlow:=hregisterlow;
                         p^.location.registerhigh:=hregisterhigh;
@@ -387,8 +387,8 @@ implementation
                           begin
                              del_reference(p^.right^.location.reference);
                              hregister2:=getexplicitregister32(R_ECX);
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),
-                               hregister2)));
+                             emit_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),
+                               hregister2);
                           end;
                      end
                    else
@@ -421,7 +421,7 @@ implementation
                         if not (R_ECX in unused) then
                          begin
                            popecx:=true;
-                           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ECX)));
+                           emit_reg(A_PUSH,S_L,R_ECX);
                          end;
                         emit_reg_reg(A_MOV,S_L,hregister2,R_ECX);
                      end;
@@ -435,25 +435,25 @@ implementation
                         getlabel(l1);
                         getlabel(l2);
                         getlabel(l3);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,S_L,64,R_ECX)));
+                        emit_const_reg(A_CMP,S_L,64,R_ECX);
                         emitjmp(C_L,l1);
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterlow,hregisterlow)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterhigh,hregisterhigh)));
+                        emit_reg_reg(A_XOR,S_L,hregisterlow,hregisterlow);
+                        emit_reg_reg(A_XOR,S_L,hregisterhigh,hregisterhigh);
                         emitjmp(C_None,l3);
                         emitlab(l1);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,S_L,32,R_ECX)));
+                        emit_const_reg(A_CMP,S_L,32,R_ECX);
                         emitjmp(C_L,l2);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_SUB,S_L,32,R_ECX)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_SHL,S_L,R_CL,
-                          hregisterlow)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,S_L,hregisterlow,hregisterhigh)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterlow,hregisterlow)));
+                        emit_const_reg(A_SUB,S_L,32,R_ECX);
+                        emit_reg_reg(A_SHL,S_L,R_CL,
+                          hregisterlow);
+                        emit_reg_reg(A_MOV,S_L,hregisterlow,hregisterhigh);
+                        emit_reg_reg(A_XOR,S_L,hregisterlow,hregisterlow);
                         emitjmp(C_None,l3);
                         emitlab(l2);
-                        exprasmlist^.concat(new(pai386,op_reg_reg_reg(A_SHLD,S_L,R_CL,
-                          hregisterlow,hregisterhigh)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_SHL,S_L,R_CL,
-                          hregisterlow)));
+                        emit_reg_reg_reg(A_SHLD,S_L,R_CL,
+                          hregisterlow,hregisterhigh);
+                        emit_reg_reg(A_SHL,S_L,R_CL,
+                          hregisterlow);
                         emitlab(l3);
                      end
                    else
@@ -461,32 +461,32 @@ implementation
                         getlabel(l1);
                         getlabel(l2);
                         getlabel(l3);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,S_L,64,R_ECX)));
+                        emit_const_reg(A_CMP,S_L,64,R_ECX);
                         emitjmp(C_L,l1);
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterlow,hregisterlow)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterhigh,hregisterhigh)));
+                        emit_reg_reg(A_XOR,S_L,hregisterlow,hregisterlow);
+                        emit_reg_reg(A_XOR,S_L,hregisterhigh,hregisterhigh);
                         emitjmp(C_None,l3);
                         emitlab(l1);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,S_L,32,R_ECX)));
+                        emit_const_reg(A_CMP,S_L,32,R_ECX);
                         emitjmp(C_L,l2);
-                        exprasmlist^.concat(new(pai386,op_const_reg(A_SUB,S_L,32,R_ECX)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_SHR,S_L,R_CL,
-                          hregisterhigh)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,S_L,hregisterhigh,hregisterlow)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregisterhigh,hregisterhigh)));
+                        emit_const_reg(A_SUB,S_L,32,R_ECX);
+                        emit_reg_reg(A_SHR,S_L,R_CL,
+                          hregisterhigh);
+                        emit_reg_reg(A_MOV,S_L,hregisterhigh,hregisterlow);
+                        emit_reg_reg(A_XOR,S_L,hregisterhigh,hregisterhigh);
                         emitjmp(C_None,l3);
                         emitlab(l2);
-                        exprasmlist^.concat(new(pai386,op_reg_reg_reg(A_SHRD,S_L,R_CL,
-                          hregisterhigh,hregisterlow)));
-                        exprasmlist^.concat(new(pai386,op_reg_reg(A_SHR,S_L,R_CL,
-                          hregisterhigh)));
+                        emit_reg_reg_reg(A_SHRD,S_L,R_CL,
+                          hregisterhigh,hregisterlow);
+                        emit_reg_reg(A_SHR,S_L,R_CL,
+                          hregisterhigh);
                         emitlab(l3);
 
                      end;
 
                    { maybe put ECX back }
                    if popecx then
-                     exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_ECX)));
+                     emit_reg(A_POP,S_L,R_ECX);
 
                    p^.location.registerlow:=hregisterlow;
                    p^.location.registerhigh:=hregisterhigh;
@@ -507,8 +507,8 @@ implementation
                      begin
                         del_reference(p^.left^.location.reference);
                         hregister1:=getregister32;
-                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
-                          hregister1)));
+                        emit_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
+                          hregister1);
                      end;
                 end
               else
@@ -526,12 +526,12 @@ implementation
                    { l shl 32 should 0 imho, but neither TP nor Delphi do it in this way (FK)
                    if p^.right^.value<=31 then
                    }
-                     exprasmlist^.concat(new(pai386,op_const_reg(op,S_L,p^.right^.value and 31,
-                       hregister1)));
+                     emit_const_reg(op,S_L,p^.right^.value and 31,
+                       hregister1);
                    {
                    else
-                     exprasmlist^.concat(new(pai386,op_reg_reg(A_XOR,S_L,hregister1,
-                       hregister1)));
+                     emit_reg_reg(A_XOR,S_L,hregister1,
+                       hregister1);
                    }
                    p^.location.loc:=LOC_REGISTER;
                    p^.location.register:=hregister1;
@@ -551,8 +551,8 @@ implementation
                           begin
                              del_reference(p^.right^.location.reference);
                              hregister2:=getexplicitregister32(R_ECX);
-                             exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),
-                               hregister2)));
+                             emit_ref_reg(A_MOV,S_L,newreference(p^.right^.location.reference),
+                               hregister2);
                           end;
                      end
                    else
@@ -576,7 +576,7 @@ implementation
                         if not (R_ECX in unused) then
                          begin
                            popecx:=true;
-                           exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,R_ECX)));
+                           emit_reg(A_PUSH,S_L,R_ECX);
                          end;
                         emit_reg_reg(A_MOV,S_L,hregister2,R_ECX);
                      end;
@@ -585,7 +585,7 @@ implementation
                    emit_reg_reg(op,S_L,R_CL,hregister1);
                    { maybe ECX back }
                    if popecx then
-                     exprasmlist^.concat(new(pai386,op_reg(A_POP,S_L,R_ECX)));
+                     emit_reg(A_POP,S_L,R_ECX);
                    p^.location.register:=hregister1;
                 end;
            end;
@@ -655,17 +655,17 @@ implementation
                      del_reference(p^.left^.location.reference);
                      p^.location.registerlow:=getregister32;
                      p^.location.registerhigh:=getregister32;
-                     exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                       newreference(p^.left^.location.reference),p^.location.registerlow)));
+                     emit_ref_reg(A_MOV,S_L,
+                       newreference(p^.left^.location.reference),p^.location.registerlow);
                      hr:=newreference(p^.left^.location.reference);
                      inc(hr^.offset,4);
-                     exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                       hr,p^.location.registerhigh)));
+                     emit_ref_reg(A_MOV,S_L,
+                       hr,p^.location.registerhigh);
                   end;
               end;
-            exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.registerlow)));
-            exprasmlist^.concat(new(pai386,op_const_reg(A_ADC,S_L,0,p^.location.registerhigh)));
-            exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.registerhigh)));
+            emit_reg(A_NEG,S_L,p^.location.registerlow);
+            emit_const_reg(A_ADC,S_L,0,p^.location.registerhigh);
+            emit_reg(A_NEG,S_L,p^.location.registerhigh);
            end
          else
            begin
@@ -675,14 +675,14 @@ implementation
                  LOC_REGISTER:
                    begin
                       p^.location.register:=p^.left^.location.register;
-                      exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.register)));
+                      emit_reg(A_NEG,S_L,p^.location.register);
                    end;
                  LOC_CREGISTER:
                    begin
                       p^.location.register:=getregister32;
                       emit_reg_reg(A_MOV,S_L,p^.location.register,
                         p^.location.register);
-                      exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.register)));
+                      emit_reg(A_NEG,S_L,p^.location.register);
                    end;
 {$ifdef SUPPORT_MMX}
                  LOC_MMXREGISTER:
@@ -709,40 +709,40 @@ implementation
                                         p^.location.loc:=LOC_FPU;
                                         floatload(pfloatdef(p^.left^.resulttype)^.typ,
                                           p^.left^.location.reference);
-                                        exprasmlist^.concat(new(pai386,op_none(A_FCHS,S_NO)));
+                                        emit_none(A_FCHS,S_NO);
                                      end
 {$ifdef SUPPORT_MMX}
                                    else if (cs_mmx in aktlocalswitches) and is_mmx_able_array(p^.left^.resulttype) then
                                      begin
                                         p^.location.register:=getregistermmx;
                                         emit_reg_reg(A_PXOR,S_NO,R_MM7,R_MM7);
-                                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVQ,S_NO,
+                                        emit_ref_reg(A_MOVQ,S_NO,
                                           newreference(p^.left^.location.reference),
-                                          p^.location.register)));
+                                          p^.location.register);
                                         do_mmx_neg;
                                      end
 {$endif SUPPORT_MMX}
                                    else
                                      begin
                                         p^.location.register:=getregister32;
-                                        exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
+                                        emit_ref_reg(A_MOV,S_L,
                                           newreference(p^.left^.location.reference),
-                                          p^.location.register)));
-                                        exprasmlist^.concat(new(pai386,op_reg(A_NEG,S_L,p^.location.register)));
+                                          p^.location.register);
+                                        emit_reg(A_NEG,S_L,p^.location.register);
                                      end;
                                 end;
                  LOC_FPU:
                    begin
                       p^.location.loc:=LOC_FPU;
-                      exprasmlist^.concat(new(pai386,op_none(A_FCHS,S_NO)));
+                      emit_none(A_FCHS,S_NO);
                    end;
                  LOC_CFPUREGISTER:
                    begin
-                      exprasmlist^.concat(new(pai386,op_reg(A_FLD,S_NO,
-                        correct_fpuregister(p^.right^.location.register,fpuvaroffset))));
+                      emit_reg(A_FLD,S_NO,
+                        correct_fpuregister(p^.right^.location.register,fpuvaroffset));
                       inc(fpuvaroffset);
                       p^.location.loc:=LOC_FPU;
-                      exprasmlist^.concat(new(pai386,op_none(A_FCHS,S_NO)));
+                      emit_none(A_FCHS,S_NO);
                    end;
               end;
            end;
@@ -795,11 +795,11 @@ implementation
                 begin
                   secondpass(p^.left);
                   {p^.location.register:=p^.left^.location.register;
-                  exprasmlist^.concat(new(pai386,op_const_reg(A_XOR,opsize,1,p^.location.register)));}
+                  emit_const_reg(A_XOR,opsize,1,p^.location.register);}
                   p^.location.loc:=LOC_FLAGS;
                   p^.location.resflags:=F_E;
-                  exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,
-                    p^.left^.location.register,p^.left^.location.register)));
+                  emit_reg_reg(A_TEST,opsize,
+                    p^.left^.location.register,p^.left^.location.register);
                   ungetregister(p^.left^.location.register);
                 end;
               LOC_CREGISTER :
@@ -809,7 +809,7 @@ implementation
                   p^.location.loc:=LOC_REGISTER;
                   p^.location.register:=def_getreg(p^.resulttype);
                   emit_reg_reg(A_MOV,opsize,p^.left^.location.register,p^.location.register);
-                  exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,p^.location.register,p^.location.register)));
+                  emit_reg_reg(A_TEST,opsize,p^.location.register,p^.location.register);
                   ungetregister(p^.location.register);
                   p^.location.loc:=LOC_FLAGS;
                   p^.location.resflags:=F_E;
@@ -823,9 +823,9 @@ implementation
                   del_reference(p^.left^.location.reference);
                   { this was placed before del_ref => internaalerror(10) }
                   p^.location.register:=def_getreg(p^.resulttype);
-                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,
-                    newreference(p^.left^.location.reference),p^.location.register)));
-                  exprasmlist^.concat(new(pai386,op_reg_reg(A_TEST,opsize,p^.location.register,p^.location.register)));
+                  emit_ref_reg(A_MOV,opsize,
+                    newreference(p^.left^.location.reference),p^.location.register);
+                  emit_reg_reg(A_TEST,opsize,p^.location.register,p^.location.register);
                   ungetregister(p^.location.register);
                   p^.location.loc:=LOC_FLAGS;
                   p^.location.resflags:=F_E;
@@ -839,7 +839,7 @@ implementation
              secondpass(p^.left);
              p^.location.loc:=LOC_MMXREGISTER;
              { prepare EDI }
-             exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_L,$ffffffff,R_EDI)));
+             emit_const_reg(A_MOV,S_L,$ffffffff,R_EDI);
              { load operand }
              case p^.left^.location.loc of
                LOC_MMXREGISTER:
@@ -853,8 +853,8 @@ implementation
                  begin
                    del_reference(p^.left^.location.reference);
                    p^.location.register:=getregistermmx;
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVQ,S_NO,
-                     newreference(p^.left^.location.reference),p^.location.register)));
+                   emit_ref_reg(A_MOVQ,S_NO,
+                     newreference(p^.left^.location.reference),p^.location.register);
                  end;
              end;
              { load mask }
@@ -862,7 +862,7 @@ implementation
              { lower 32 bit }
              emit_reg_reg(A_PXOR,S_D,R_MM7,p^.location.register);
              { shift mask }
-             exprasmlist^.concat(new(pai386,op_const_reg(A_PSLLQ,S_NO,32,R_MM7)));
+             emit_const_reg(A_PSLLQ,S_NO,32,R_MM7);
              { higher 32 bit }
              emit_reg_reg(A_PXOR,S_D,R_MM7,p^.location.register);
            end
@@ -877,8 +877,8 @@ implementation
                   begin
                      p^.location.registerlow:=p^.left^.location.registerlow;
                      p^.location.registerhigh:=p^.left^.location.registerhigh;
-                     exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerlow)));
-                     exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerhigh)));
+                     emit_reg(A_NOT,S_L,p^.location.registerlow);
+                     emit_reg(A_NOT,S_L,p^.location.registerhigh);
                   end;
                 LOC_CREGISTER :
                   begin
@@ -886,22 +886,22 @@ implementation
                      p^.location.registerhigh:=getregister32;
                      emit_reg_reg(A_MOV,S_L,p^.left^.location.registerlow,p^.location.registerlow);
                      emit_reg_reg(A_MOV,S_L,p^.left^.location.registerhigh,p^.location.registerhigh);
-                     exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerlow)));
-                     exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerhigh)));
+                     emit_reg(A_NOT,S_L,p^.location.registerlow);
+                     emit_reg(A_NOT,S_L,p^.location.registerhigh);
                   end;
                 LOC_REFERENCE,LOC_MEM :
                   begin
                      del_reference(p^.left^.location.reference);
                      p^.location.registerlow:=getregister32;
                      p^.location.registerhigh:=getregister32;
-                     exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                       newreference(p^.left^.location.reference),p^.location.registerlow)));
+                     emit_ref_reg(A_MOV,S_L,
+                       newreference(p^.left^.location.reference),p^.location.registerlow);
                      hr:=newreference(p^.left^.location.reference);
                      inc(hr^.offset,4);
-                     exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                       hr,p^.location.registerhigh)));
-                     exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerlow)));
-                     exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.registerhigh)));
+                     emit_ref_reg(A_MOV,S_L,
+                       hr,p^.location.registerhigh);
+                     emit_reg(A_NOT,S_L,p^.location.registerlow);
+                     emit_reg(A_NOT,S_L,p^.location.registerhigh);
                   end;
               end;
            end
@@ -914,21 +914,21 @@ implementation
               LOC_REGISTER :
                 begin
                   p^.location.register:=p^.left^.location.register;
-                  exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.register)));
+                  emit_reg(A_NOT,S_L,p^.location.register);
                 end;
               LOC_CREGISTER :
                 begin
                   p^.location.register:=getregister32;
                   emit_reg_reg(A_MOV,S_L,p^.left^.location.register,p^.location.register);
-                  exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.register)));
+                  emit_reg(A_NOT,S_L,p^.location.register);
                 end;
               LOC_REFERENCE,LOC_MEM :
                 begin
                   del_reference(p^.left^.location.reference);
                   p^.location.register:=getregister32;
-                  exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                    newreference(p^.left^.location.reference),p^.location.register)));
-                  exprasmlist^.concat(new(pai386,op_reg(A_NOT,S_L,p^.location.register)));
+                  emit_ref_reg(A_MOV,S_L,
+                    newreference(p^.left^.location.reference),p^.location.register);
+                  emit_reg(A_NOT,S_L,p^.location.register);
                 end;
             end;
           end;
@@ -939,7 +939,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.30  1999-08-04 13:45:23  florian
+  Revision 1.31  1999-08-19 13:08:50  pierre
+   * emit_??? used
+
+  Revision 1.30  1999/08/04 13:45:23  florian
     + floating point register variables !!
     * pairegalloc is now generated for register variables
 

compiler/cg386mem.pas

@@ -57,9 +57,9 @@ implementation
     procedure secondloadvmt(var p : ptree);
       begin
          p^.location.register:=getregister32;
-         exprasmlist^.concat(new(pai386,op_sym_ofs_reg(A_MOV,
+         emit_sym_ofs_reg(A_MOV,
             S_L,newasmsymbol(pobjectdef(pclassrefdef(p^.resulttype)^.definition)^.vmt_mangledname),0,
-            p^.location.register)));
+            p^.location.register);
       end;
 
 
@@ -133,16 +133,16 @@ implementation
             LOC_CREGISTER:
               begin
                  p^.location.reference.index:=getregister32;
-                 exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,S_L,
+                 emit_reg_reg(A_MOV,S_L,
                    p^.left^.location.register,
-                   p^.location.reference.index)));
+                   p^.location.reference.index);
               end;
             LOC_MEM,LOC_REFERENCE :
               begin
                  del_reference(p^.left^.location.reference);
                  p^.location.reference.index:=getregister32;
-                 exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
-                   p^.location.reference.index)));
+                 emit_ref_reg(A_MOV,S_L,newreference(p^.left^.location.reference),
+                   p^.location.reference.index);
               end;
          end;
       end;
@@ -169,8 +169,8 @@ implementation
 
          { push pointer adress }
          case p^.left^.location.loc of
-            LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,
-              p^.left^.location.register)));
+            LOC_CREGISTER : emit_reg(A_PUSH,S_L,
+              p^.left^.location.register);
             LOC_REFERENCE:
               emitpushreferenceaddr(p^.left^.location.reference);
          end;
@@ -187,8 +187,8 @@ implementation
                      emitpushreferenceaddr(r^);
                      { push pointer adress }
                      case p^.left^.location.loc of
-                        LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,
-                          p^.left^.location.register)));
+                        LOC_CREGISTER : emit_reg(A_PUSH,S_L,
+                          p^.left^.location.register);
                         LOC_REFERENCE:
                           emitpushreferenceaddr(p^.left^.location.reference);
                      end;
@@ -208,8 +208,8 @@ implementation
                      emitpushreferenceaddr(r^);
                      { push pointer adress }
                      case p^.left^.location.loc of
-                        LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,
-                          p^.left^.location.register)));
+                        LOC_CREGISTER : emit_reg(A_PUSH,S_L,
+                          p^.left^.location.register);
                         LOC_REFERENCE:
                           emitpushreferenceaddr(p^.left^.location.reference);
                      end;
@@ -244,13 +244,13 @@ implementation
            assigned(p^.left^.symtableentry) and
            (p^.left^.symtableentry^.typ=varsym) and
            (pvarsym(p^.left^.symtableentry)^.definition^.deftype=procvardef) then
-           exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
+           emit_ref_reg(A_MOV,S_L,
              newreference(p^.left^.location.reference),
-             p^.location.register)))
+             p^.location.register)
          else
-           exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
+           emit_ref_reg(A_LEA,S_L,
              newreference(p^.left^.location.reference),
-             p^.location.register)));
+             p^.location.register);
            { for use of other segments }
            if p^.left^.location.reference.segment<>R_NO then
              p^.location.segment:=p^.left^.location.reference.segment;
@@ -267,9 +267,9 @@ implementation
          p^.location.loc:=LOC_REGISTER;
          del_reference(p^.left^.location.reference);
          p^.location.register:=getregister32;
-         exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
+         emit_ref_reg(A_LEA,S_L,
          newreference(p^.left^.location.reference),
-           p^.location.register)));
+           p^.location.register);
       end;
 
 
@@ -300,9 +300,9 @@ implementation
 
                  { ...and reserve one for the pointer }
                  hr:=getregister32;
-                 exprasmlist^.concat(new(pai386,op_ref_reg(
+                 emit_ref_reg(
                    A_MOV,S_L,newreference(p^.left^.location.reference),
-                   hr)));
+                   hr);
                  p^.location.reference.base:=hr;
               end;
          end;
@@ -312,8 +312,8 @@ implementation
             (cs_gdb_heaptrc in aktglobalswitches) and
             (cs_checkpointer in aktglobalswitches) then
               begin
-                 exprasmlist^.concat(new(pai386,op_reg(
-                   A_PUSH,S_L,p^.location.reference.base)));
+                 emit_reg(
+                   A_PUSH,S_L,p^.location.reference.base);
                  emitcall('FPC_CHECKPOINTER');
               end;
       end;
@@ -352,9 +352,9 @@ implementation
 
                      { ... and reserve one for the pointer }
                      hr:=getregister32;
-                     exprasmlist^.concat(new(pai386,op_ref_reg(
+                     emit_ref_reg(
                        A_MOV,S_L,newreference(p^.left^.location.reference),
-                       hr)));
+                       hr);
                      p^.location.reference.base:=hr;
                   end;
              end;
@@ -394,9 +394,9 @@ implementation
             else
               begin
                  if ispowerof2(l1,l2) then
-                   exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,l2,ind)))
+                   emit_const_reg(A_SHL,S_L,l2,ind)
                  else
-                   exprasmlist^.concat(new(pai386,op_const_reg(A_IMUL,S_L,l1,ind)));
+                   emit_const_reg(A_IMUL,S_L,l1,ind);
               end;
             end;
           end;
@@ -450,9 +450,9 @@ implementation
                 begin
                    del_reference(p^.left^.location.reference);
                    p^.location.reference.base:=getregister32;
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
+                   emit_ref_reg(A_MOV,S_L,
                      newreference(p^.left^.location.reference),
-                     p^.location.reference.base)));
+                     p^.location.reference.base);
                 end;
 
               { check for a zero length string,
@@ -460,7 +460,7 @@ implementation
               if (cs_check_range in aktlocalswitches) then
                 begin
                    pushusedregisters(pushed,$ff);
-                   exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,p^.location.reference.base)));
+                   emit_reg(A_PUSH,S_L,p^.location.reference.base);
                    emitcall('FPC_ANSISTR_CHECKZERO');
                    maybe_loadesi;
                    popusedregisters(pushed);
@@ -473,8 +473,8 @@ implementation
                 begin
                    { in widestrings S[1] is pwchar(S)[0] !! }
                    dec(p^.location.reference.offset,2);
-                   exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,
-                     1,p^.location.reference.base)));
+                   emit_const_reg(A_SHL,S_L,
+                     1,p^.location.reference.base);
                 end;
 
               { we've also to keep left up-to-date, because it is used   }
@@ -528,7 +528,7 @@ implementation
                              push_int(p^.right^.value);
                              hp:=newreference(p^.location.reference);
                              dec(hp^.offset,7);
-                             exprasmlist^.concat(new(pai386,op_ref(A_PUSH,S_L,hp)));
+                             emit_ref(A_PUSH,S_L,hp);
                              emitcall('FPC_ANSISTR_RANGECHECK');
                              popusedregisters(pushed);
                              maybe_loadesi;
@@ -707,10 +707,10 @@ implementation
                          st_ansistring:
                            begin
                               pushusedregisters(pushed,$ff);
-                              exprasmlist^.concat(new(pai386,op_reg(A_PUSH,S_L,ind)));
+                              emit_reg(A_PUSH,S_L,ind);
                               hp:=newreference(p^.location.reference);
                               dec(hp^.offset,7);
-                              exprasmlist^.concat(new(pai386,op_ref(A_PUSH,S_L,hp)));
+                              emit_ref(A_PUSH,S_L,hp);
                               emitcall('FPC_ANSISTR_RANGECHECK');
                               popusedregisters(pushed);
                               maybe_loadesi;
@@ -737,9 +737,9 @@ implementation
                  if p^.location.reference.base=R_NO then
                   begin
                     case p^.location.reference.scalefactor of
-                     2 : exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,1,p^.location.reference.index)));
-                     4 : exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,2,p^.location.reference.index)));
-                     8 : exprasmlist^.concat(new(pai386,op_const_reg(A_SHL,S_L,3,p^.location.reference.index)));
+                     2 : emit_const_reg(A_SHL,S_L,1,p^.location.reference.index);
+                     4 : emit_const_reg(A_SHL,S_L,2,p^.location.reference.index);
+                     8 : emit_const_reg(A_SHL,S_L,3,p^.location.reference.index);
                     end;
                     calc_emit_mul;
                     p^.location.reference.base:=p^.location.reference.index;
@@ -747,9 +747,9 @@ implementation
                   end
                  else
                   begin
-                    exprasmlist^.concat(new(pai386,op_ref_reg(
+                    emit_ref_reg(
                       A_LEA,S_L,newreference(p^.location.reference),
-                      p^.location.reference.index)));
+                      p^.location.reference.index);
                     ungetregister32(p^.location.reference.base);
                     { the symbol offset is loaded,             }
                     { so release the symbol name and set symbol  }
@@ -812,14 +812,14 @@ implementation
                 if (p^.left^.resulttype^.deftype=objectdef) and
                    pobjectdef(p^.left^.resulttype)^.is_class then
                  begin
-                    exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                      newreference(p^.left^.location.reference),R_EDI)));
+                    emit_ref_reg(A_MOV,S_L,
+                      newreference(p^.left^.location.reference),R_EDI);
                     usetemp:=true;
                  end
                else
                  begin
-                   exprasmlist^.concat(new(pai386,op_ref_reg(A_LEA,S_L,
-                     newreference(p^.left^.location.reference),R_EDI)));
+                   emit_ref_reg(A_LEA,S_L,
+                     newreference(p^.left^.location.reference),R_EDI);
                    usetemp:=true;
                  end;
 
@@ -829,8 +829,8 @@ implementation
                   gettempofsizereference(4,p^.withreference^);
                   normaltemptopersistant(p^.withreference^.offset);
                   { move to temp reference }
-                  exprasmlist^.concat(new(pai386,op_reg_ref(A_MOV,S_L,
-                    R_EDI,newreference(p^.withreference^))));
+                  emit_reg_ref(A_MOV,S_L,
+                    R_EDI,newreference(p^.withreference^));
                   del_reference(p^.left^.location.reference);
                 end;
 
@@ -850,7 +850,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.51  1999-08-16 23:20:28  peter
+  Revision 1.52  1999-08-19 13:08:52  pierre
+   * emit_??? used
+
+  Revision 1.51  1999/08/16 23:20:28  peter
     * range check for array of const
 
   Revision 1.50  1999/08/14 00:36:05  peter

compiler/cg386set.pas

@@ -199,13 +199,13 @@ implementation
                pleftreg:=p^.left^.location.register;
                if pleftreg in [R_AX..R_DX] then
                 begin
-                  exprasmlist^.concat(new(pai386,op_const_reg(A_AND,S_W,255,pleftreg)));
+                  emit_const_reg(A_AND,S_W,255,pleftreg);
                   opsize:=S_W;
                 end
                else
                 if pleftreg in [R_EAX..R_EDI] then
                  begin
-                   exprasmlist^.concat(new(pai386,op_const_reg(A_AND,S_L,255,pleftreg)));
+                   emit_const_reg(A_AND,S_L,255,pleftreg);
                    opsize:=S_L;
                  end
                else
@@ -234,28 +234,28 @@ implementation
                  begin
                    case p^.left^.location.loc of
                   LOC_REGISTER,
-                 LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,
-                                   setparts[i].start,pleftreg)));
+                 LOC_CREGISTER : emit_const_reg(A_CMP,opsize,
+                                   setparts[i].start,pleftreg);
                    else
-                     exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_B,
-                       setparts[i].start,newreference(p^.left^.location.reference))));
+                     emit_const_ref(A_CMP,S_B,
+                       setparts[i].start,newreference(p^.left^.location.reference));
                    end;
                    { Result should be in carry flag when ranges are used }
                    if ranges then
-                     exprasmlist^.concat(new(pai386,op_none(A_STC,S_NO)));
+                     emit_none(A_STC,S_NO);
                    { If found, jump to end }
                    emitjmp(C_E,l);
                    case p^.left^.location.loc of
                   LOC_REGISTER,
-                 LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,
-                                   setparts[i].stop,pleftreg)));
+                 LOC_CREGISTER : emit_const_reg(A_CMP,opsize,
+                                   setparts[i].stop,pleftreg);
                    else
-                     exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_B,
-                       setparts[i].stop,newreference(p^.left^.location.reference))));
+                     emit_const_ref(A_CMP,S_B,
+                       setparts[i].stop,newreference(p^.left^.location.reference));
                    end;
                    { Result should be in carry flag when ranges are used }
                    if ranges then
-                     exprasmlist^.concat(new(pai386,op_none(A_STC,S_NO)));
+                     emit_none(A_STC,S_NO);
                    { If found, jump to end }
                    emitjmp(C_E,l);
                  end
@@ -267,11 +267,12 @@ implementation
                         set elements lower than 0 dont exist }
                       case p^.left^.location.loc of
                      LOC_REGISTER,
-                    LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,
-                                      setparts[i].start,pleftreg)));
+                    LOC_CREGISTER :
+                    emit_const_reg(A_CMP,opsize,
+                                      setparts[i].start,pleftreg);
                       else
-                        exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_B,
-                          setparts[i].start,newreference(p^.left^.location.reference))));
+                        emit_const_ref(A_CMP,S_B,
+                          setparts[i].start,newreference(p^.left^.location.reference));
                       end;
                       { If lower, jump to next check }
                       emitjmp(C_B,l2);
@@ -283,18 +284,18 @@ implementation
                     begin
                       case p^.left^.location.loc of
                      LOC_REGISTER,
-                    LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,
-                                      setparts[i].stop+1,pleftreg)));
+                    LOC_CREGISTER : emit_const_reg(A_CMP,opsize,
+                                      setparts[i].stop+1,pleftreg);
                       else
-                        exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_B,
-                          setparts[i].stop+1,newreference(p^.left^.location.reference))));
+                        emit_const_ref(A_CMP,S_B,
+                          setparts[i].stop+1,newreference(p^.left^.location.reference));
                       end;
                       { If higher, element is in set }
                       emitjmp(C_B,l);
                     end
                    else
                     begin
-                      exprasmlist^.concat(new(pai386,op_none(A_STC,S_NO)));
+                      emit_none(A_STC,S_NO);
                       emitjmp(C_None,l);
                     end;
                  end;
@@ -306,20 +307,20 @@ implementation
                 { Emit code to check if left is an element }
                 case p^.left^.location.loc of
                LOC_REGISTER,
-              LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,
-                                setparts[i].stop,pleftreg)));
+              LOC_CREGISTER : emit_const_reg(A_CMP,opsize,
+                                setparts[i].stop,pleftreg);
                 else
-                  exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_B,
-                    setparts[i].stop,newreference(p^.left^.location.reference))));
+                  emit_const_ref(A_CMP,S_B,
+                    setparts[i].stop,newreference(p^.left^.location.reference));
                 end;
                 { Result should be in carry flag when ranges are used }
                 if ranges then
-                 exprasmlist^.concat(new(pai386,op_none(A_STC,S_NO)));
+                 emit_none(A_STC,S_NO);
                 { If found, jump to end }
                 emitjmp(C_E,l);
               end;
              if ranges then
-              exprasmlist^.concat(new(pai386,op_none(A_CLC,S_NO)));
+              emit_none(A_CLC,S_NO);
              { To compensate for not doing a second pass }
              p^.right^.location.reference.symbol:=nil;
              { Now place the end label }
@@ -344,14 +345,14 @@ implementation
                      LOC_REGISTER,
                      LOC_CREGISTER:
                       begin
-                         exprasmlist^.concat(new(pai386,op_const_reg(A_TEST,S_L,
-                           1 shl (p^.left^.value and 31),p^.right^.location.register)));
+                         emit_const_reg(A_TEST,S_L,
+                           1 shl (p^.left^.value and 31),p^.right^.location.register);
                          ungetregister32(p^.right^.location.register);
                        end
                   else
                    begin
-                     exprasmlist^.concat(new(pai386,op_const_ref(A_TEST,S_L,1 shl (p^.left^.value and 31),
-                       newreference(p^.right^.location.reference))));
+                     emit_const_ref(A_TEST,S_L,1 shl (p^.left^.value and 31),
+                       newreference(p^.right^.location.reference));
                      del_reference(p^.right^.location.reference);
                    end;
                   end;
@@ -370,8 +371,8 @@ implementation
                       { the set element isn't never samller than a byte  }
                       { and because it's a small set we need only 5 bits }
                       { but 8 bits are easier to load               }
-                      exprasmlist^.concat(new(pai386,op_ref_reg(A_MOVZX,S_BL,
-                        newreference(p^.left^.location.reference),R_EDI)));
+                      emit_ref_reg(A_MOVZX,S_BL,
+                        newreference(p^.left^.location.reference),R_EDI);
                       hr:=R_EDI;
                       del_reference(p^.left^.location.reference);
                     end;
@@ -379,8 +380,8 @@ implementation
 
                   case p^.right^.location.loc of
                  LOC_REGISTER,
-                LOC_CREGISTER : exprasmlist^.concat(new(pai386,op_reg_reg(A_BT,S_L,hr,
-                                  p^.right^.location.register)));
+                LOC_CREGISTER : emit_reg_reg(A_BT,S_L,hr,
+                                  p^.right^.location.register);
                   else
                     begin
                       del_reference(p^.right^.location.reference);
@@ -389,14 +390,14 @@ implementation
                        { We have to load the value into a register because
                          btl does not accept values only refs or regs (PFV) }
                          hr2:=getregister32;
-                         exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_L,
-                           p^.right^.location.reference.offset,hr2)));
-                         exprasmlist^.concat(new(pai386,op_reg_reg(A_BT,S_L,hr,hr2)));
+                         emit_const_reg(A_MOV,S_L,
+                           p^.right^.location.reference.offset,hr2);
+                         emit_reg_reg(A_BT,S_L,hr,hr2);
                          ungetregister32(hr2);
                        end
                       else
-                        exprasmlist^.concat(new(pai386,op_reg_ref(A_BT,S_L,hr,
-                          newreference(p^.right^.location.reference))));
+                        emit_reg_ref(A_BT,S_L,hr,
+                          newreference(p^.right^.location.reference));
                     end;
                   end;
                   ungetregister32(hr);
@@ -418,8 +419,8 @@ implementation
                       hr:=getregister32;
                       p^.left^.location.loc:=LOC_REGISTER;
                       p^.left^.location.register:=hr;
-                      exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_L,
-                            p^.left^.value,hr)));
+                      emit_const_reg(A_MOV,S_L,
+                            p^.left^.value,hr);
                     end;
                   case p^.left^.location.loc of
                      LOC_REGISTER,
@@ -434,31 +435,31 @@ implementation
                                else
                                  AM:=A_MOVZX;
                                if p^.left^.location.register in [R_AX,R_DI] then
-                                 exprasmlist^.concat(new(pai386,op_reg_reg(AM,S_WL,
-                                   p^.left^.location.register,hr)))
+                                 emit_reg_reg(AM,S_WL,
+                                   p^.left^.location.register,hr)
                                else if p^.left^.location.register in [R_AL,R_DH] then
-                               exprasmlist^.concat(new(pai386,op_reg_reg(AM,S_BL,
-                                 p^.left^.location.register,hr)));
+                               emit_reg_reg(AM,S_BL,
+                                 p^.left^.location.register,hr);
                             end
                           else
 {$endif CORRECT_SET_IN_FPC}
                             begin
-                               exprasmlist^.concat(new(pai386,op_const_reg(A_AND,S_L,
-                                 255,hr)));
+                               emit_const_reg(A_AND,S_L,
+                                 255,hr);
                             end;
-                          exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,S_L,
-                            31,hr)));
+                          emit_const_reg(A_CMP,S_L,
+                            31,hr);
                           emitjmp(C_NA,l);
                         { reset carry flag }
-                          exprasmlist^.concat(new(pai386,op_none(A_CLC,S_NO)));
+                          emit_none(A_CLC,S_NO);
                           emitjmp(C_NONE,l2);
                           emitlab(l);
                         { We have to load the value into a register because
                           btl does not accept values only refs or regs (PFV) }
                           hr2:=getregister32;
-                          exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_L,
-                            p^.right^.location.reference.offset,hr2)));
-                          exprasmlist^.concat(new(pai386,op_reg_reg(A_BT,S_L,hr,hr2)));
+                          emit_const_reg(A_MOV,S_L,
+                            p^.right^.location.reference.offset,hr2);
+                          emit_reg_reg(A_BT,S_L,hr,hr2);
                           ungetregister32(hr2);
                        end;
                   else
@@ -468,29 +469,29 @@ implementation
                             begin
                             {***WARNING only correct if
                               reference is 32 bits (PM) *****}
-                               exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_L,
-                                 31,newreference(p^.left^.location.reference))));
+                               emit_const_ref(A_CMP,S_L,
+                                 31,newreference(p^.left^.location.reference));
                             end
                           else
 {$endif CORRECT_SET_IN_FPC}
                             begin
-                               exprasmlist^.concat(new(pai386,op_const_ref(A_CMP,S_B,
-                                 31,newreference(p^.left^.location.reference))));
+                               emit_const_ref(A_CMP,S_B,
+                                 31,newreference(p^.left^.location.reference));
                             end;
                        emitjmp(C_NA,l);
                      { reset carry flag }
-                       exprasmlist^.concat(new(pai386,op_none(A_CLC,S_NO)));
+                       emit_none(A_CLC,S_NO);
                        emitjmp(C_NONE,l2);
                        emitlab(l);
                        hr:=getregister32;
-                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,S_L,
-                         newreference(p^.left^.location.reference),hr)));
+                       emit_ref_reg(A_MOV,S_L,
+                         newreference(p^.left^.location.reference),hr);
                      { We have to load the value into a register because
                        btl does not accept values only refs or regs (PFV) }
                        hr2:=getregister32;
-                       exprasmlist^.concat(new(pai386,op_const_reg(A_MOV,S_L,
-                         p^.right^.location.reference.offset,hr2)));
-                       exprasmlist^.concat(new(pai386,op_reg_reg(A_BT,S_L,hr,hr2)));
+                       emit_const_reg(A_MOV,S_L,
+                         p^.right^.location.reference.offset,hr2);
+                       emit_reg_reg(A_BT,S_L,hr,hr2);
                        ungetregister32(hr2);
                       del_reference(p^.left^.location.reference);
                     end;
@@ -503,8 +504,8 @@ implementation
                 begin
                   p^.location.resflags:=F_NE;
                   inc(p^.right^.location.reference.offset,p^.left^.value shr 3);
-                  exprasmlist^.concat(new(pai386,op_const_ref(A_TEST,S_B,1 shl (p^.left^.value and 7),
-                    newreference(p^.right^.location.reference))));
+                  emit_const_ref(A_TEST,S_B,1 shl (p^.left^.value and 7),
+                    newreference(p^.right^.location.reference));
                   del_reference(p^.right^.location.reference);
                 end
                else
@@ -565,7 +566,7 @@ implementation
          { no range label: }
          if p^._low=p^._high then
            begin
-              exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,p^._low,hregister)));
+              emit_const_reg(A_CMP,opsize,p^._low,hregister);
               if greaterlabel=lesslabel then
                 emitjmp(C_NE,lesslabel)
               else
@@ -577,9 +578,9 @@ implementation
            end
          else
            begin
-              exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,p^._low,hregister)));
+              emit_const_reg(A_CMP,opsize,p^._low,hregister);
               emitjmp(jmp_le,lesslabel);
-                exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,p^._high,hregister)));
+              emit_const_reg(A_CMP,opsize,p^._high,hregister);
               emitjmp(jmp_gt,greaterlabel);
               emitjmp(C_None,p^.statement);
            end;
@@ -604,17 +605,17 @@ implementation
              { need we to test the first value }
              if first and (t^._low>get_min_value(p^.left^.resulttype)) then
                begin
-                  exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,t^._low,hregister)));
+                  emit_const_reg(A_CMP,opsize,t^._low,hregister);
                   emitjmp(jmp_le,elselabel);
                end;
              if t^._low=t^._high then
                begin
                   if t^._low-last=1 then
-                    exprasmlist^.concat(new(pai386,op_reg(A_DEC,opsize,hregister)))
+                    emit_reg(A_DEC,opsize,hregister)
                   else if t^._low-last=0 then
-                    exprasmlist^.concat(new(pai386,op_reg_reg(A_OR,opsize,hregister,hregister)))
+                    emit_reg_reg(A_OR,opsize,hregister,hregister)
                   else
-                    exprasmlist^.concat(new(pai386,op_const_reg(A_SUB,opsize,t^._low-last,hregister)));
+                    emit_const_reg(A_SUB,opsize,t^._low-last,hregister);
                   last:=t^._low;
                   emitjmp(C_Z,t^.statement);
                end
@@ -629,11 +630,11 @@ implementation
                        if t^._low>get_min_value(p^.left^.resulttype) then
                          begin
                             if t^._low=1 then
-                              exprasmlist^.concat(new(pai386,op_reg(A_DEC,opsize,
-                                hregister)))
+                              emit_reg(A_DEC,opsize,
+                                hregister)
                             else
-                              exprasmlist^.concat(new(pai386,op_const_reg(A_SUB,opsize,
-                                t^._low,hregister)));
+                              emit_const_reg(A_SUB,opsize,
+                                t^._low,hregister);
                          end;
                     end
                   else
@@ -642,12 +643,12 @@ implementation
                   { immediately. else check the range in between:       }
                   if (t^._low-last>1) then
                     begin
-                       exprasmlist^.concat(new(pai386,op_const_reg(A_SUB,opsize,t^._low-last,hregister)));
+                       emit_const_reg(A_SUB,opsize,t^._low-last,hregister);
                        emitjmp(jmp_le,elselabel);
                     end
                   else
-                    exprasmlist^.concat(new(pai386,op_reg(A_DEC,opsize,hregister)));
-                  exprasmlist^.concat(new(pai386,op_const_reg(A_SUB,opsize,t^._high-t^._low,hregister)));
+                    emit_reg(A_DEC,opsize,hregister);
+                  emit_const_reg(A_SUB,opsize,t^._high-t^._low,hregister);
                   emitjmp(jmp_lee,t^.statement);
 
                   last:=t^._high;
@@ -692,10 +693,10 @@ implementation
           begin
            if not(jumptable_no_range) then
              begin
-                exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,min_,hregister)));
+                emit_const_reg(A_CMP,opsize,min_,hregister);
                 { case expr less than min_ => goto elselabel }
                 emitjmp(jmp_le,elselabel);
-                exprasmlist^.concat(new(pai386,op_const_reg(A_CMP,opsize,max_,hregister)));
+                emit_const_reg(A_CMP,opsize,max_,hregister);
                 emitjmp(jmp_gt,elselabel);
              end;
            getlabel(table);
@@ -703,21 +704,21 @@ implementation
            if opsize=S_W then
              begin
                 if with_sign then
-                  exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVSX,S_WL,hregister,
-                    reg16toreg32(hregister))))
+                  emit_reg_reg(A_MOVSX,S_WL,hregister,
+                    reg16toreg32(hregister))
                 else
-                  exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVZX,S_WL,hregister,
-                    reg16toreg32(hregister))));
+                  emit_reg_reg(A_MOVZX,S_WL,hregister,
+                    reg16toreg32(hregister));
                 hregister:=reg16toreg32(hregister);
              end
            else if opsize=S_B then
              begin
                 if with_sign then
-                  exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVSX,S_BL,hregister,
-                    reg8toreg32(hregister))))
+                  emit_reg_reg(A_MOVSX,S_BL,hregister,
+                    reg8toreg32(hregister))
                 else
-                  exprasmlist^.concat(new(pai386,op_reg_reg(A_MOVZX,S_BL,hregister,
-                    reg8toreg32(hregister))));
+                  emit_reg_reg(A_MOVZX,S_BL,hregister,
+                    reg8toreg32(hregister));
                 hregister:=reg8toreg32(hregister);
              end;
            new(hr);
@@ -726,7 +727,7 @@ implementation
            hr^.offset:=(-min_)*4;
            hr^.index:=hregister;
            hr^.scalefactor:=4;
-           exprasmlist^.concat(new(pai386,op_ref(A_JMP,S_NO,hr)));
+           emit_ref(A_JMP,S_NO,hr);
            { !!!!! generate tables
              if not(cs_littlesize in aktlocalswitches) then
              jumpsegment^.concat(new(pai386,op_const(A_ALIGN,S_NO,4)));
@@ -736,7 +737,7 @@ implementation
            genitem(hp);
              { !!!!!!!
            if not(cs_littlesize in aktlocalswitches) then
-             exprasmlist^.concat(new(pai386,op_const(A_ALIGN,S_NO,4)));
+             emit_const(A_ALIGN,S_NO,4);
            }
         end;
 
@@ -792,8 +793,8 @@ implementation
                     S_B : hregister:=reg32toreg8(hregister);
                     S_W : hregister:=reg32toreg16(hregister);
                  end;
-                 exprasmlist^.concat(new(pai386,op_reg_reg(A_MOV,opsize,
-                   p^.left^.location.register,hregister)));
+                 emit_reg_reg(A_MOV,opsize,
+                   p^.left^.location.register,hregister);
               end;
             LOC_MEM,LOC_REFERENCE : begin
                                        del_reference(p^.left^.location.reference);
@@ -802,8 +803,8 @@ implementation
                                           S_B : hregister:=reg32toreg8(hregister);
                                           S_W : hregister:=reg32toreg16(hregister);
                                        end;
-                                       exprasmlist^.concat(new(pai386,op_ref_reg(A_MOV,opsize,newreference(
-                                         p^.left^.location.reference),hregister)));
+                                       emit_ref_reg(A_MOV,opsize,newreference(
+                                         p^.left^.location.reference),hregister);
                                     end;
             else internalerror(2002);
          end;
@@ -918,7 +919,10 @@ implementation
 end.
 {
   $Log$
-  Revision 1.37  1999-08-04 00:22:54  florian
+  Revision 1.38  1999-08-19 13:08:53  pierre
+   * emit_??? used
+
+  Revision 1.37  1999/08/04 00:22:54  florian
     * renamed i386asm and i386base to cpuasm and cpubase
 
   Revision 1.36  1999/08/03 22:02:48  peter