Example #1
0
                    private static void zeroAuto(ref gc.Progs pp, ref gc.Node n)
                    {
                        // Note: this code must not clobber any registers.
                        var sym  = n.Sym.Linksym();
                        var size = n.Type.Size();
                        var p    = pp.Prog(arm.AMOVW);

                        p.From.Type   = obj.TYPE_CONST;
                        p.From.Offset = 0L;
                        p.To.Type     = obj.TYPE_REG;
                        p.To.Reg      = arm.REGTMP;
                        {
                            var i = int64(0L);

                            while (i < size)
                            {
                                p           = pp.Prog(arm.AMOVW);
                                p.From.Type = obj.TYPE_REG;
                                p.From.Reg  = arm.REGTMP;
                                p.To.Type   = obj.TYPE_MEM;
                                p.To.Name   = obj.NAME_AUTO;
                                p.To.Reg    = arm.REGSP;
                                p.To.Offset = n.Xoffset + i;
                                p.To.Sym    = sym;
                                i          += 4L;
                            }
                        }
                    }
Example #2
0
                    private static void zeroAuto(ref gc.Progs pp, ref gc.Node n)
                    {
                        // Note: this code must not clobber any registers.
                        var op = x86.AMOVQ;

                        if (gc.Widthptr == 4L)
                        {
                            op = x86.AMOVL;
                        }
                        var sym  = n.Sym.Linksym();
                        var size = n.Type.Size();
                        {
                            var i = int64(0L);

                            while (i < size)
                            {
                                var p = pp.Prog(op);
                                p.From.Type   = obj.TYPE_CONST;
                                p.From.Offset = 0L;
                                p.To.Type     = obj.TYPE_MEM;
                                p.To.Name     = obj.NAME_AUTO;
                                p.To.Reg      = x86.REG_SP;
                                p.To.Offset   = n.Xoffset + i;
                                p.To.Sym      = sym;
                                i            += int64(gc.Widthptr);
                            }
                        }
                    }
Example #3
0
                    private static void ginsnop(ref gc.Progs pp)
                    {
                        var p = pp.Prog(arm.AAND);

                        p.From.Type = obj.TYPE_REG;
                        p.From.Reg  = arm.REG_R0;
                        p.To.Type   = obj.TYPE_REG;
                        p.To.Reg    = arm.REG_R0;
                        p.Scond     = arm.C_SCOND_EQ;
                    }
Example #4
0
                    private static void ginsnop(ref gc.Progs pp)
                    {
                        // This is actually not the x86 NOP anymore,
                        // but at the point where it gets used, AX is dead
                        // so it's okay if we lose the high bits.
                        var p = pp.Prog(x86.AXCHGL);

                        p.From.Type = obj.TYPE_REG;
                        p.From.Reg  = x86.REG_AX;
                        p.To.Type   = obj.TYPE_REG;
                        p.To.Reg    = x86.REG_AX;
                    }
Example #5
0
                    private static void ginsnop(ref gc.Progs pp)
                    {
                        var p = pp.Prog(arm64.AHINT);

                        p.From.Type = obj.TYPE_CONST;
                    }