RET

// cgocallback(fn, frame unsafe.Pointer, ctxt uintptr)
// See cgocall.go for more details.
TEXT ·cgocallback(SB),NOSPLIT,$24-24
	NO_LOCAL_POINTERS

	// Skip cgocallbackg, just dropm when fn is nil, and frame is the saved g.
	// It is used to dropm while thread is exiting.
	MOVD	fn+0(FP), R1
	CMPBNE	R1, $0, loadg
	// Restore the g from frame.
	MOVD	frame+8(FP), g
	BR	dropm

loadg:

}
/* Shows details of frame that is under the mouse */
#current-details {
  position: absolute;
  top: 5px;
  right: 5px;
  z-index: 2;
  font-size: 12pt;
}
/* Background of a single flame-graph frame */
.boxbg {
  border-width: 0px;
  position: absolute;
  overflow: hidden;
  box-sizing: border-box;
  background: #d8d8d8;
}
.positive { position: absolute; background: #caa; }

	MOVD R12, CTR
	BR (CTR)


TEXT _rt0_ppc64_aix_lib(SB),NOSPLIT,$-8
	// Start with standard C stack frame layout and linkage.
	MOVD	LR, R0
	MOVD	R0, 16(R1) // Save LR in caller's frame.
	MOVW	CR, R0	   // Save CR in caller's frame
	MOVD	R0, 8(R1)

	MOVDU	R1, -344(R1) // Allocate frame.

	// Preserve callee-save registers.
	MOVD	R14, 48(R1)
	MOVD	R15, 56(R1)
	MOVD	R16, 64(R1)
	MOVD	R17, 72(R1)

            }
        }

        private void appendFrame(String prefix, StackTraceElement frame, StackTraceRelevance relevance) throws IOException {
            listener.beforeFrame(frame, relevance);

            builder.append(prefix)
                .append("\tat ")
                .append(frame.toString())
                .append(lineSeparator);
        }

	atom.Del:        sets.NewString("cite"),
	atom.Embed:      sets.NewString("src"),
	atom.Form:       sets.NewString("action"),
	atom.Frame:      sets.NewString("longdesc", "src"),
	atom.Head:       sets.NewString("profile"),
	atom.Html:       sets.NewString("manifest"),
	atom.Iframe:     sets.NewString("longdesc", "src"),
	atom.Img:        sets.NewString("longdesc", "src", "usemap"),

		// and registers that ever contain a pointer.
		if frame.varp != 0 {
			size := frame.varp - frame.sp
			if size > 0 {
				scanConservative(frame.sp, size, nil, gcw, state)
			}
		}

		// Scan arguments to this frame.
		if n := frame.argBytes(); n != 0 {
			// TODO: We could pass the entry argument map
			// to narrow this down further.
			scanConservative(frame.argp, n, nil, gcw, state)
		}

		return nil, nil
	}

	// Find assembly files to work on.
	var sfiles []string
	for _, fname := range pass.OtherFiles {
		if strings.HasSuffix(fname, ".s") && pass.Pkg.Path() != "runtime" {
			sfiles = append(sfiles, fname)
		}
	}

	for _, fname := range sfiles {
		content, tf, err := analysisutil.ReadFile(pass, fname)
		if err != nil {
			return nil, err
		}

		lines := strings.SplitAfter(string(content), "\n")

	textstksiz := p.To.Offset
	if textstksiz == -8 {
		// Historical way to mark NOFRAME.
		p.From.Sym.Set(obj.AttrNoFrame, true)
		textstksiz = 0
	}
	if textstksiz < 0 {
		c.ctxt.Diag("negative frame size %d - did you mean NOFRAME?", textstksiz)
	}
	if p.From.Sym.NoFrame() {
		if textstksiz != 0 {
			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", textstksiz)
		}
	}

	MOVW	R2, ret+8(FP)
	RET

// cgocallback(fn, frame unsafe.Pointer, ctxt uintptr)
// See cgocall.go for more details.
TEXT ·cgocallback(SB),NOSPLIT,$12-12
	NO_LOCAL_POINTERS

	// Skip cgocallbackg, just dropm when fn is nil, and frame is the saved g.
	// It is used to dropm while thread is exiting.
	MOVW	fn+0(FP), R5
	BNE	R5, loadg
	// Restore the g from frame.
	MOVW	frame+4(FP), g
	JMP	dropm

loadg:

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package trace

// Frame is a frame in stack traces.
type Frame struct {
	PC   uint64
	Fn   string
	File string
	Line int
}

const (
	// Special P identifiers:
	FakeP    = 1000000 + iota
	TimerP   // depicts timer unblocks
	NetpollP // depicts network unblocks