podman

1
// cmd/9l/noop.c, cmd/9l/pass.c, cmd/9l/span.c from Vita Nuova.
2
//
3
//	Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
4
//	Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
5
//	Portions Copyright © 1997-1999 Vita Nuova Limited
6
//	Portions Copyright © 2000-2008 Vita Nuova Holdings Limited (www.vitanuova.com)
7
//	Portions Copyright © 2004,2006 Bruce Ellis
8
//	Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
9
//	Revisions Copyright © 2000-2008 Lucent Technologies Inc. and others
10
//	Portions Copyright © 2009 The Go Authors. All rights reserved.
11
//
12
// Permission is hereby granted, free of charge, to any person obtaining a copy
13
// of this software and associated documentation files (the "Software"), to deal
14
// in the Software without restriction, including without limitation the rights
15
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
16
// copies of the Software, and to permit persons to whom the Software is
17
// furnished to do so, subject to the following conditions:
18
//
19
// The above copyright notice and this permission notice shall be included in
20
// all copies or substantial portions of the Software.
21
//
22
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
25
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
27
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28
// THE SOFTWARE.
29

30
package ppc64
31

32
import (
33
	"github.com/twitchyliquid64/golang-asm/obj"
34
	"github.com/twitchyliquid64/golang-asm/objabi"
35
	"github.com/twitchyliquid64/golang-asm/sys"
36
)
37

38
func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
39
	p.From.Class = 0
40
	p.To.Class = 0
41

42
	c := ctxt9{ctxt: ctxt, newprog: newprog}
43

44
	// Rewrite BR/BL to symbol as TYPE_BRANCH.
45
	switch p.As {
46
	case ABR,
47
		ABL,
48
		obj.ARET,
49
		obj.ADUFFZERO,
50
		obj.ADUFFCOPY:
51
		if p.To.Sym != nil {
52
			p.To.Type = obj.TYPE_BRANCH
53
		}
54
	}
55

56
	// Rewrite float constants to values stored in memory.
57
	switch p.As {
58
	case AFMOVS:
59
		if p.From.Type == obj.TYPE_FCONST {
60
			f32 := float32(p.From.Val.(float64))
61
			p.From.Type = obj.TYPE_MEM
62
			p.From.Sym = ctxt.Float32Sym(f32)
63
			p.From.Name = obj.NAME_EXTERN
64
			p.From.Offset = 0
65
		}
66

67
	case AFMOVD:
68
		if p.From.Type == obj.TYPE_FCONST {
69
			f64 := p.From.Val.(float64)
70
			// Constant not needed in memory for float +/- 0
71
			if f64 != 0 {
72
				p.From.Type = obj.TYPE_MEM
73
				p.From.Sym = ctxt.Float64Sym(f64)
74
				p.From.Name = obj.NAME_EXTERN
75
				p.From.Offset = 0
76
			}
77
		}
78

79
		// Put >32-bit constants in memory and load them
80
	case AMOVD:
81
		if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE && p.From.Reg == 0 && int64(int32(p.From.Offset)) != p.From.Offset {
82
			p.From.Type = obj.TYPE_MEM
83
			p.From.Sym = ctxt.Int64Sym(p.From.Offset)
84
			p.From.Name = obj.NAME_EXTERN
85
			p.From.Offset = 0
86
		}
87
	}
88

89
	// Rewrite SUB constants into ADD.
90
	switch p.As {
91
	case ASUBC:
92
		if p.From.Type == obj.TYPE_CONST {
93
			p.From.Offset = -p.From.Offset
94
			p.As = AADDC
95
		}
96

97
	case ASUBCCC:
98
		if p.From.Type == obj.TYPE_CONST {
99
			p.From.Offset = -p.From.Offset
100
			p.As = AADDCCC
101
		}
102

103
	case ASUB:
104
		if p.From.Type == obj.TYPE_CONST {
105
			p.From.Offset = -p.From.Offset
106
			p.As = AADD
107
		}
108
	}
109
	if c.ctxt.Headtype == objabi.Haix {
110
		c.rewriteToUseTOC(p)
111
	} else if c.ctxt.Flag_dynlink {
112
		c.rewriteToUseGot(p)
113
	}
114
}
115

116
// Rewrite p, if necessary, to access a symbol using its TOC anchor.
117
// This code is for AIX only.
118
func (c *ctxt9) rewriteToUseTOC(p *obj.Prog) {
119
	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
120
		return
121
	}
122

123
	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
124
		// ADUFFZERO/ADUFFCOPY is considered as an ABL except in dynamic
125
		// link where it should be an indirect call.
126
		if !c.ctxt.Flag_dynlink {
127
			return
128
		}
129
		//     ADUFFxxx $offset
130
		// becomes
131
		//     MOVD runtime.duffxxx@TOC, R12
132
		//     ADD $offset, R12
133
		//     MOVD R12, LR
134
		//     BL (LR)
135
		var sym *obj.LSym
136
		if p.As == obj.ADUFFZERO {
137
			sym = c.ctxt.Lookup("runtime.duffzero")
138
		} else {
139
			sym = c.ctxt.Lookup("runtime.duffcopy")
140
		}
141
		// Retrieve or create the TOC anchor.
142
		symtoc := c.ctxt.LookupInit("TOC."+sym.Name, func(s *obj.LSym) {
143
			s.Type = objabi.SDATA
144
			s.Set(obj.AttrDuplicateOK, true)
145
			s.Set(obj.AttrStatic, true)
146
			c.ctxt.Data = append(c.ctxt.Data, s)
147
			s.WriteAddr(c.ctxt, 0, 8, sym, 0)
148
		})
149

150
		offset := p.To.Offset
151
		p.As = AMOVD
152
		p.From.Type = obj.TYPE_MEM
153
		p.From.Name = obj.NAME_TOCREF
154
		p.From.Sym = symtoc
155
		p.To.Type = obj.TYPE_REG
156
		p.To.Reg = REG_R12
157
		p.To.Name = obj.NAME_NONE
158
		p.To.Offset = 0
159
		p.To.Sym = nil
160
		p1 := obj.Appendp(p, c.newprog)
161
		p1.As = AADD
162
		p1.From.Type = obj.TYPE_CONST
163
		p1.From.Offset = offset
164
		p1.To.Type = obj.TYPE_REG
165
		p1.To.Reg = REG_R12
166
		p2 := obj.Appendp(p1, c.newprog)
167
		p2.As = AMOVD
168
		p2.From.Type = obj.TYPE_REG
169
		p2.From.Reg = REG_R12
170
		p2.To.Type = obj.TYPE_REG
171
		p2.To.Reg = REG_LR
172
		p3 := obj.Appendp(p2, c.newprog)
173
		p3.As = obj.ACALL
174
		p3.To.Type = obj.TYPE_REG
175
		p3.To.Reg = REG_LR
176
	}
177

178
	var source *obj.Addr
179
	if p.From.Name == obj.NAME_EXTERN || p.From.Name == obj.NAME_STATIC {
180
		if p.From.Type == obj.TYPE_ADDR {
181
			if p.As == ADWORD {
182
				// ADWORD $sym doesn't need TOC anchor
183
				return
184
			}
185
			if p.As != AMOVD {
186
				c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v", p)
187
				return
188
			}
189
			if p.To.Type != obj.TYPE_REG {
190
				c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v", p)
191
				return
192
			}
193
		} else if p.From.Type != obj.TYPE_MEM {
194
			c.ctxt.Diag("do not know how to handle %v without TYPE_MEM", p)
195
			return
196
		}
197
		source = &p.From
198

199
	} else if p.To.Name == obj.NAME_EXTERN || p.To.Name == obj.NAME_STATIC {
200
		if p.To.Type != obj.TYPE_MEM {
201
			c.ctxt.Diag("do not know how to handle %v without TYPE_MEM", p)
202
			return
203
		}
204
		if source != nil {
205
			c.ctxt.Diag("cannot handle symbols on both sides in %v", p)
206
			return
207
		}
208
		source = &p.To
209
	} else {
210
		return
211

212
	}
213

214
	if source.Sym == nil {
215
		c.ctxt.Diag("do not know how to handle nil symbol in %v", p)
216
		return
217
	}
218

219
	if source.Sym.Type == objabi.STLSBSS {
220
		return
221
	}
222

223
	// Retrieve or create the TOC anchor.
224
	symtoc := c.ctxt.LookupInit("TOC."+source.Sym.Name, func(s *obj.LSym) {
225
		s.Type = objabi.SDATA
226
		s.Set(obj.AttrDuplicateOK, true)
227
		s.Set(obj.AttrStatic, true)
228
		c.ctxt.Data = append(c.ctxt.Data, s)
229
		s.WriteAddr(c.ctxt, 0, 8, source.Sym, 0)
230
	})
231

232
	if source.Type == obj.TYPE_ADDR {
233
		// MOVD $sym, Rx becomes MOVD symtoc, Rx
234
		// MOVD $sym+<off>, Rx becomes MOVD symtoc, Rx; ADD <off>, Rx
235
		p.From.Type = obj.TYPE_MEM
236
		p.From.Sym = symtoc
237
		p.From.Name = obj.NAME_TOCREF
238

239
		if p.From.Offset != 0 {
240
			q := obj.Appendp(p, c.newprog)
241
			q.As = AADD
242
			q.From.Type = obj.TYPE_CONST
243
			q.From.Offset = p.From.Offset
244
			p.From.Offset = 0
245
			q.To = p.To
246
		}
247
		return
248

249
	}
250

251
	// MOVx sym, Ry becomes MOVD symtoc, REGTMP; MOVx (REGTMP), Ry
252
	// MOVx Ry, sym becomes MOVD symtoc, REGTMP; MOVx Ry, (REGTMP)
253
	// An addition may be inserted between the two MOVs if there is an offset.
254

255
	q := obj.Appendp(p, c.newprog)
256
	q.As = AMOVD
257
	q.From.Type = obj.TYPE_MEM
258
	q.From.Sym = symtoc
259
	q.From.Name = obj.NAME_TOCREF
260
	q.To.Type = obj.TYPE_REG
261
	q.To.Reg = REGTMP
262

263
	q = obj.Appendp(q, c.newprog)
264
	q.As = p.As
265
	q.From = p.From
266
	q.To = p.To
267
	if p.From.Name != obj.NAME_NONE {
268
		q.From.Type = obj.TYPE_MEM
269
		q.From.Reg = REGTMP
270
		q.From.Name = obj.NAME_NONE
271
		q.From.Sym = nil
272
	} else if p.To.Name != obj.NAME_NONE {
273
		q.To.Type = obj.TYPE_MEM
274
		q.To.Reg = REGTMP
275
		q.To.Name = obj.NAME_NONE
276
		q.To.Sym = nil
277
	} else {
278
		c.ctxt.Diag("unreachable case in rewriteToUseTOC with %v", p)
279
	}
280

281
	obj.Nopout(p)
282
}
283

284
// Rewrite p, if necessary, to access global data via the global offset table.
285
func (c *ctxt9) rewriteToUseGot(p *obj.Prog) {
286
	if p.As == obj.ADUFFCOPY || p.As == obj.ADUFFZERO {
287
		//     ADUFFxxx $offset
288
		// becomes
289
		//     MOVD runtime.duffxxx@GOT, R12
290
		//     ADD $offset, R12
291
		//     MOVD R12, LR
292
		//     BL (LR)
293
		var sym *obj.LSym
294
		if p.As == obj.ADUFFZERO {
295
			sym = c.ctxt.Lookup("runtime.duffzero")
296
		} else {
297
			sym = c.ctxt.Lookup("runtime.duffcopy")
298
		}
299
		offset := p.To.Offset
300
		p.As = AMOVD
301
		p.From.Type = obj.TYPE_MEM
302
		p.From.Name = obj.NAME_GOTREF
303
		p.From.Sym = sym
304
		p.To.Type = obj.TYPE_REG
305
		p.To.Reg = REG_R12
306
		p.To.Name = obj.NAME_NONE
307
		p.To.Offset = 0
308
		p.To.Sym = nil
309
		p1 := obj.Appendp(p, c.newprog)
310
		p1.As = AADD
311
		p1.From.Type = obj.TYPE_CONST
312
		p1.From.Offset = offset
313
		p1.To.Type = obj.TYPE_REG
314
		p1.To.Reg = REG_R12
315
		p2 := obj.Appendp(p1, c.newprog)
316
		p2.As = AMOVD
317
		p2.From.Type = obj.TYPE_REG
318
		p2.From.Reg = REG_R12
319
		p2.To.Type = obj.TYPE_REG
320
		p2.To.Reg = REG_LR
321
		p3 := obj.Appendp(p2, c.newprog)
322
		p3.As = obj.ACALL
323
		p3.To.Type = obj.TYPE_REG
324
		p3.To.Reg = REG_LR
325
	}
326

327
	// We only care about global data: NAME_EXTERN means a global
328
	// symbol in the Go sense, and p.Sym.Local is true for a few
329
	// internally defined symbols.
330
	if p.From.Type == obj.TYPE_ADDR && p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
331
		// MOVD $sym, Rx becomes MOVD sym@GOT, Rx
332
		// MOVD $sym+<off>, Rx becomes MOVD sym@GOT, Rx; ADD <off>, Rx
333
		if p.As != AMOVD {
334
			c.ctxt.Diag("do not know how to handle TYPE_ADDR in %v with -dynlink", p)
335
		}
336
		if p.To.Type != obj.TYPE_REG {
337
			c.ctxt.Diag("do not know how to handle LEAQ-type insn to non-register in %v with -dynlink", p)
338
		}
339
		p.From.Type = obj.TYPE_MEM
340
		p.From.Name = obj.NAME_GOTREF
341
		if p.From.Offset != 0 {
342
			q := obj.Appendp(p, c.newprog)
343
			q.As = AADD
344
			q.From.Type = obj.TYPE_CONST
345
			q.From.Offset = p.From.Offset
346
			q.To = p.To
347
			p.From.Offset = 0
348
		}
349
	}
350
	if p.GetFrom3() != nil && p.GetFrom3().Name == obj.NAME_EXTERN {
351
		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
352
	}
353
	var source *obj.Addr
354
	// MOVx sym, Ry becomes MOVD sym@GOT, REGTMP; MOVx (REGTMP), Ry
355
	// MOVx Ry, sym becomes MOVD sym@GOT, REGTMP; MOVx Ry, (REGTMP)
356
	// An addition may be inserted between the two MOVs if there is an offset.
357
	if p.From.Name == obj.NAME_EXTERN && !p.From.Sym.Local() {
358
		if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
359
			c.ctxt.Diag("cannot handle NAME_EXTERN on both sides in %v with -dynlink", p)
360
		}
361
		source = &p.From
362
	} else if p.To.Name == obj.NAME_EXTERN && !p.To.Sym.Local() {
363
		source = &p.To
364
	} else {
365
		return
366
	}
367
	if p.As == obj.ATEXT || p.As == obj.AFUNCDATA || p.As == obj.ACALL || p.As == obj.ARET || p.As == obj.AJMP {
368
		return
369
	}
370
	if source.Sym.Type == objabi.STLSBSS {
371
		return
372
	}
373
	if source.Type != obj.TYPE_MEM {
374
		c.ctxt.Diag("don't know how to handle %v with -dynlink", p)
375
	}
376
	p1 := obj.Appendp(p, c.newprog)
377
	p2 := obj.Appendp(p1, c.newprog)
378

379
	p1.As = AMOVD
380
	p1.From.Type = obj.TYPE_MEM
381
	p1.From.Sym = source.Sym
382
	p1.From.Name = obj.NAME_GOTREF
383
	p1.To.Type = obj.TYPE_REG
384
	p1.To.Reg = REGTMP
385

386
	p2.As = p.As
387
	p2.From = p.From
388
	p2.To = p.To
389
	if p.From.Name == obj.NAME_EXTERN {
390
		p2.From.Reg = REGTMP
391
		p2.From.Name = obj.NAME_NONE
392
		p2.From.Sym = nil
393
	} else if p.To.Name == obj.NAME_EXTERN {
394
		p2.To.Reg = REGTMP
395
		p2.To.Name = obj.NAME_NONE
396
		p2.To.Sym = nil
397
	} else {
398
		return
399
	}
400
	obj.Nopout(p)
401
}
402

403
func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) {
404
	// TODO(minux): add morestack short-cuts with small fixed frame-size.
405
	if cursym.Func.Text == nil || cursym.Func.Text.Link == nil {
406
		return
407
	}
408

409
	c := ctxt9{ctxt: ctxt, cursym: cursym, newprog: newprog}
410

411
	p := c.cursym.Func.Text
412
	textstksiz := p.To.Offset
413
	if textstksiz == -8 {
414
		// Compatibility hack.
415
		p.From.Sym.Set(obj.AttrNoFrame, true)
416
		textstksiz = 0
417
	}
418
	if textstksiz%8 != 0 {
419
		c.ctxt.Diag("frame size %d not a multiple of 8", textstksiz)
420
	}
421
	if p.From.Sym.NoFrame() {
422
		if textstksiz != 0 {
423
			c.ctxt.Diag("NOFRAME functions must have a frame size of 0, not %d", textstksiz)
424
		}
425
	}
426

427
	c.cursym.Func.Args = p.To.Val.(int32)
428
	c.cursym.Func.Locals = int32(textstksiz)
429

430
	/*
431
	 * find leaf subroutines
432
	 * expand RET
433
	 * expand BECOME pseudo
434
	 */
435

436
	var q *obj.Prog
437
	var q1 *obj.Prog
438
	for p := c.cursym.Func.Text; p != nil; p = p.Link {
439
		switch p.As {
440
		/* too hard, just leave alone */
441
		case obj.ATEXT:
442
			q = p
443

444
			p.Mark |= LABEL | LEAF | SYNC
445
			if p.Link != nil {
446
				p.Link.Mark |= LABEL
447
			}
448

449
		case ANOR:
450
			q = p
451
			if p.To.Type == obj.TYPE_REG {
452
				if p.To.Reg == REGZERO {
453
					p.Mark |= LABEL | SYNC
454
				}
455
			}
456

457
		case ALWAR,
458
			ALBAR,
459
			ASTBCCC,
460
			ASTWCCC,
461
			AECIWX,
462
			AECOWX,
463
			AEIEIO,
464
			AICBI,
465
			AISYNC,
466
			ATLBIE,
467
			ATLBIEL,
468
			ASLBIA,
469
			ASLBIE,
470
			ASLBMFEE,
471
			ASLBMFEV,
472
			ASLBMTE,
473
			ADCBF,
474
			ADCBI,
475
			ADCBST,
476
			ADCBT,
477
			ADCBTST,
478
			ADCBZ,
479
			ASYNC,
480
			ATLBSYNC,
481
			APTESYNC,
482
			ALWSYNC,
483
			ATW,
484
			AWORD,
485
			ARFI,
486
			ARFCI,
487
			ARFID,
488
			AHRFID:
489
			q = p
490
			p.Mark |= LABEL | SYNC
491
			continue
492

493
		case AMOVW, AMOVWZ, AMOVD:
494
			q = p
495
			if p.From.Reg >= REG_SPECIAL || p.To.Reg >= REG_SPECIAL {
496
				p.Mark |= LABEL | SYNC
497
			}
498
			continue
499

500
		case AFABS,
501
			AFABSCC,
502
			AFADD,
503
			AFADDCC,
504
			AFCTIW,
505
			AFCTIWCC,
506
			AFCTIWZ,
507
			AFCTIWZCC,
508
			AFDIV,
509
			AFDIVCC,
510
			AFMADD,
511
			AFMADDCC,
512
			AFMOVD,
513
			AFMOVDU,
514
			/* case AFMOVDS: */
515
			AFMOVS,
516
			AFMOVSU,
517

518
			/* case AFMOVSD: */
519
			AFMSUB,
520
			AFMSUBCC,
521
			AFMUL,
522
			AFMULCC,
523
			AFNABS,
524
			AFNABSCC,
525
			AFNEG,
526
			AFNEGCC,
527
			AFNMADD,
528
			AFNMADDCC,
529
			AFNMSUB,
530
			AFNMSUBCC,
531
			AFRSP,
532
			AFRSPCC,
533
			AFSUB,
534
			AFSUBCC:
535
			q = p
536

537
			p.Mark |= FLOAT
538
			continue
539

540
		case ABL,
541
			ABCL,
542
			obj.ADUFFZERO,
543
			obj.ADUFFCOPY:
544
			c.cursym.Func.Text.Mark &^= LEAF
545
			fallthrough
546

547
		case ABC,
548
			ABEQ,
549
			ABGE,
550
			ABGT,
551
			ABLE,
552
			ABLT,
553
			ABNE,
554
			ABR,
555
			ABVC,
556
			ABVS:
557
			p.Mark |= BRANCH
558
			q = p
559
			q1 = p.To.Target()
560
			if q1 != nil {
561
				// NOPs are not removed due to #40689.
562

563
				if q1.Mark&LEAF == 0 {
564
					q1.Mark |= LABEL
565
				}
566
			} else {
567
				p.Mark |= LABEL
568
			}
569
			q1 = p.Link
570
			if q1 != nil {
571
				q1.Mark |= LABEL
572
			}
573
			continue
574

575
		case AFCMPO, AFCMPU:
576
			q = p
577
			p.Mark |= FCMP | FLOAT
578
			continue
579

580
		case obj.ARET:
581
			q = p
582
			if p.Link != nil {
583
				p.Link.Mark |= LABEL
584
			}
585
			continue
586

587
		case obj.ANOP:
588
			// NOPs are not removed due to
589
			// #40689
590
			continue
591

592
		default:
593
			q = p
594
			continue
595
		}
596
	}
597

598
	autosize := int32(0)
599
	var p1 *obj.Prog
600
	var p2 *obj.Prog
601
	for p := c.cursym.Func.Text; p != nil; p = p.Link {
602
		o := p.As
603
		switch o {
604
		case obj.ATEXT:
605
			autosize = int32(textstksiz)
606

607
			if p.Mark&LEAF != 0 && autosize == 0 {
608
				// A leaf function with no locals has no frame.
609
				p.From.Sym.Set(obj.AttrNoFrame, true)
610
			}
611

612
			if !p.From.Sym.NoFrame() {
613
				// If there is a stack frame at all, it includes
614
				// space to save the LR.
615
				autosize += int32(c.ctxt.FixedFrameSize())
616
			}
617

618
			if p.Mark&LEAF != 0 && autosize < objabi.StackSmall {
619
				// A leaf function with a small stack can be marked
620
				// NOSPLIT, avoiding a stack check.
621
				p.From.Sym.Set(obj.AttrNoSplit, true)
622
			}
623

624
			p.To.Offset = int64(autosize)
625

626
			q = p
627

628
			if c.ctxt.Flag_shared && c.cursym.Name != "runtime.duffzero" && c.cursym.Name != "runtime.duffcopy" {
629
				// When compiling Go into PIC, all functions must start
630
				// with instructions to load the TOC pointer into r2:
631
				//
632
				//	addis r2, r12, .TOC.-func@ha
633
				//	addi r2, r2, .TOC.-func@l+4
634
				//
635
				// We could probably skip this prologue in some situations
636
				// but it's a bit subtle. However, it is both safe and
637
				// necessary to leave the prologue off duffzero and
638
				// duffcopy as we rely on being able to jump to a specific
639
				// instruction offset for them.
640
				//
641
				// These are AWORDS because there is no (afaict) way to
642
				// generate the addis instruction except as part of the
643
				// load of a large constant, and in that case there is no
644
				// way to use r12 as the source.
645
				//
646
				// Note that the same condition is tested in
647
				// putelfsym in cmd/link/internal/ld/symtab.go
648
				// where we set the st_other field to indicate
649
				// the presence of these instructions.
650
				q = obj.Appendp(q, c.newprog)
651
				q.As = AWORD
652
				q.Pos = p.Pos
653
				q.From.Type = obj.TYPE_CONST
654
				q.From.Offset = 0x3c4c0000
655
				q = obj.Appendp(q, c.newprog)
656
				q.As = AWORD
657
				q.Pos = p.Pos
658
				q.From.Type = obj.TYPE_CONST
659
				q.From.Offset = 0x38420000
660
				rel := obj.Addrel(c.cursym)
661
				rel.Off = 0
662
				rel.Siz = 8
663
				rel.Sym = c.ctxt.Lookup(".TOC.")
664
				rel.Type = objabi.R_ADDRPOWER_PCREL
665
			}
666

667
			if !c.cursym.Func.Text.From.Sym.NoSplit() {
668
				q = c.stacksplit(q, autosize) // emit split check
669
			}
670

671
			// Special handling of the racecall thunk. Assume that its asm code will
672
			// save the link register and update the stack, since that code is
673
			// called directly from C/C++ and can't clobber REGTMP (R31).
674
			if autosize != 0 && c.cursym.Name != "runtime.racecallbackthunk" {
675
				// Save the link register and update the SP.  MOVDU is used unless
676
				// the frame size is too large.  The link register must be saved
677
				// even for non-empty leaf functions so that traceback works.
678
				if autosize >= -BIG && autosize <= BIG {
679
					// Use MOVDU to adjust R1 when saving R31, if autosize is small.
680
					q = obj.Appendp(q, c.newprog)
681
					q.As = AMOVD
682
					q.Pos = p.Pos
683
					q.From.Type = obj.TYPE_REG
684
					q.From.Reg = REG_LR
685
					q.To.Type = obj.TYPE_REG
686
					q.To.Reg = REGTMP
687

688
					q = obj.Appendp(q, c.newprog)
689
					q.As = AMOVDU
690
					q.Pos = p.Pos
691
					q.From.Type = obj.TYPE_REG
692
					q.From.Reg = REGTMP
693
					q.To.Type = obj.TYPE_MEM
694
					q.To.Offset = int64(-autosize)
695
					q.To.Reg = REGSP
696
					q.Spadj = autosize
697
				} else {
698
					// Frame size is too large for a MOVDU instruction.
699
					// Store link register before decrementing SP, so if a signal comes
700
					// during the execution of the function prologue, the traceback
701
					// code will not see a half-updated stack frame.
702
					// This sequence is not async preemptible, as if we open a frame
703
					// at the current SP, it will clobber the saved LR.
704
					q = obj.Appendp(q, c.newprog)
705
					q.As = AMOVD
706
					q.Pos = p.Pos
707
					q.From.Type = obj.TYPE_REG
708
					q.From.Reg = REG_LR
709
					q.To.Type = obj.TYPE_REG
710
					q.To.Reg = REG_R29 // REGTMP may be used to synthesize large offset in the next instruction
711

712
					q = c.ctxt.StartUnsafePoint(q, c.newprog)
713

714
					q = obj.Appendp(q, c.newprog)
715
					q.As = AMOVD
716
					q.Pos = p.Pos
717
					q.From.Type = obj.TYPE_REG
718
					q.From.Reg = REG_R29
719
					q.To.Type = obj.TYPE_MEM
720
					q.To.Offset = int64(-autosize)
721
					q.To.Reg = REGSP
722

723
					q = obj.Appendp(q, c.newprog)
724
					q.As = AADD
725
					q.Pos = p.Pos
726
					q.From.Type = obj.TYPE_CONST
727
					q.From.Offset = int64(-autosize)
728
					q.To.Type = obj.TYPE_REG
729
					q.To.Reg = REGSP
730
					q.Spadj = +autosize
731

732
					q = c.ctxt.EndUnsafePoint(q, c.newprog, -1)
733

734
				}
735
			} else if c.cursym.Func.Text.Mark&LEAF == 0 {
736
				// A very few functions that do not return to their caller
737
				// (e.g. gogo) are not identified as leaves but still have
738
				// no frame.
739
				c.cursym.Func.Text.Mark |= LEAF
740
			}
741

742
			if c.cursym.Func.Text.Mark&LEAF != 0 {
743
				c.cursym.Set(obj.AttrLeaf, true)
744
				break
745
			}
746

747
			if c.ctxt.Flag_shared {
748
				q = obj.Appendp(q, c.newprog)
749
				q.As = AMOVD
750
				q.Pos = p.Pos
751
				q.From.Type = obj.TYPE_REG
752
				q.From.Reg = REG_R2
753
				q.To.Type = obj.TYPE_MEM
754
				q.To.Reg = REGSP
755
				q.To.Offset = 24
756
			}
757

758
			if c.cursym.Func.Text.From.Sym.Wrapper() {
759
				// if(g->panic != nil && g->panic->argp == FP) g->panic->argp = bottom-of-frame
760
				//
761
				//	MOVD g_panic(g), R3
762
				//	CMP R0, R3
763
				//	BEQ end
764
				//	MOVD panic_argp(R3), R4
765
				//	ADD $(autosize+8), R1, R5
766
				//	CMP R4, R5
767
				//	BNE end
768
				//	ADD $8, R1, R6
769
				//	MOVD R6, panic_argp(R3)
770
				// end:
771
				//	NOP
772
				//
773
				// The NOP is needed to give the jumps somewhere to land.
774
				// It is a liblink NOP, not a ppc64 NOP: it encodes to 0 instruction bytes.
775

776
				q = obj.Appendp(q, c.newprog)
777

778
				q.As = AMOVD
779
				q.From.Type = obj.TYPE_MEM
780
				q.From.Reg = REGG
781
				q.From.Offset = 4 * int64(c.ctxt.Arch.PtrSize) // G.panic
782
				q.To.Type = obj.TYPE_REG
783
				q.To.Reg = REG_R3
784

785
				q = obj.Appendp(q, c.newprog)
786
				q.As = ACMP
787
				q.From.Type = obj.TYPE_REG
788
				q.From.Reg = REG_R0
789
				q.To.Type = obj.TYPE_REG
790
				q.To.Reg = REG_R3
791

792
				q = obj.Appendp(q, c.newprog)
793
				q.As = ABEQ
794
				q.To.Type = obj.TYPE_BRANCH
795
				p1 = q
796

797
				q = obj.Appendp(q, c.newprog)
798
				q.As = AMOVD
799
				q.From.Type = obj.TYPE_MEM
800
				q.From.Reg = REG_R3
801
				q.From.Offset = 0 // Panic.argp
802
				q.To.Type = obj.TYPE_REG
803
				q.To.Reg = REG_R4
804

805
				q = obj.Appendp(q, c.newprog)
806
				q.As = AADD
807
				q.From.Type = obj.TYPE_CONST
808
				q.From.Offset = int64(autosize) + c.ctxt.FixedFrameSize()
809
				q.Reg = REGSP
810
				q.To.Type = obj.TYPE_REG
811
				q.To.Reg = REG_R5
812

813
				q = obj.Appendp(q, c.newprog)
814
				q.As = ACMP
815
				q.From.Type = obj.TYPE_REG
816
				q.From.Reg = REG_R4
817
				q.To.Type = obj.TYPE_REG
818
				q.To.Reg = REG_R5
819

820
				q = obj.Appendp(q, c.newprog)
821
				q.As = ABNE
822
				q.To.Type = obj.TYPE_BRANCH
823
				p2 = q
824

825
				q = obj.Appendp(q, c.newprog)
826
				q.As = AADD
827
				q.From.Type = obj.TYPE_CONST
828
				q.From.Offset = c.ctxt.FixedFrameSize()
829
				q.Reg = REGSP
830
				q.To.Type = obj.TYPE_REG
831
				q.To.Reg = REG_R6
832

833
				q = obj.Appendp(q, c.newprog)
834
				q.As = AMOVD
835
				q.From.Type = obj.TYPE_REG
836
				q.From.Reg = REG_R6
837
				q.To.Type = obj.TYPE_MEM
838
				q.To.Reg = REG_R3
839
				q.To.Offset = 0 // Panic.argp
840

841
				q = obj.Appendp(q, c.newprog)
842

843
				q.As = obj.ANOP
844
				p1.To.SetTarget(q)
845
				p2.To.SetTarget(q)
846
			}
847

848
		case obj.ARET:
849
			if p.From.Type == obj.TYPE_CONST {
850
				c.ctxt.Diag("using BECOME (%v) is not supported!", p)
851
				break
852
			}
853

854
			retTarget := p.To.Sym
855

856
			if c.cursym.Func.Text.Mark&LEAF != 0 {
857
				if autosize == 0 || c.cursym.Name == "runtime.racecallbackthunk" {
858
					p.As = ABR
859
					p.From = obj.Addr{}
860
					if retTarget == nil {
861
						p.To.Type = obj.TYPE_REG
862
						p.To.Reg = REG_LR
863
					} else {
864
						p.To.Type = obj.TYPE_BRANCH
865
						p.To.Sym = retTarget
866
					}
867
					p.Mark |= BRANCH
868
					break
869
				}
870

871
				p.As = AADD
872
				p.From.Type = obj.TYPE_CONST
873
				p.From.Offset = int64(autosize)
874
				p.To.Type = obj.TYPE_REG
875
				p.To.Reg = REGSP
876
				p.Spadj = -autosize
877

878
				q = c.newprog()
879
				q.As = ABR
880
				q.Pos = p.Pos
881
				q.To.Type = obj.TYPE_REG
882
				q.To.Reg = REG_LR
883
				q.Mark |= BRANCH
884
				q.Spadj = +autosize
885

886
				q.Link = p.Link
887
				p.Link = q
888
				break
889
			}
890

891
			p.As = AMOVD
892
			p.From.Type = obj.TYPE_MEM
893
			p.From.Offset = 0
894
			p.From.Reg = REGSP
895
			p.To.Type = obj.TYPE_REG
896
			p.To.Reg = REGTMP
897

898
			q = c.newprog()
899
			q.As = AMOVD
900
			q.Pos = p.Pos
901
			q.From.Type = obj.TYPE_REG
902
			q.From.Reg = REGTMP
903
			q.To.Type = obj.TYPE_REG
904
			q.To.Reg = REG_LR
905

906
			q.Link = p.Link
907
			p.Link = q
908
			p = q
909

910
			if false {
911
				// Debug bad returns
912
				q = c.newprog()
913

914
				q.As = AMOVD
915
				q.Pos = p.Pos
916
				q.From.Type = obj.TYPE_MEM
917
				q.From.Offset = 0
918
				q.From.Reg = REGTMP
919
				q.To.Type = obj.TYPE_REG
920
				q.To.Reg = REGTMP
921

922
				q.Link = p.Link
923
				p.Link = q
924
				p = q
925
			}
926
			prev := p
927
			if autosize != 0 && c.cursym.Name != "runtime.racecallbackthunk" {
928
				q = c.newprog()
929
				q.As = AADD
930
				q.Pos = p.Pos
931
				q.From.Type = obj.TYPE_CONST
932
				q.From.Offset = int64(autosize)
933
				q.To.Type = obj.TYPE_REG
934
				q.To.Reg = REGSP
935
				q.Spadj = -autosize
936

937
				q.Link = p.Link
938
				prev.Link = q
939
				prev = q
940
			}
941

942
			q1 = c.newprog()
943
			q1.As = ABR
944
			q1.Pos = p.Pos
945
			if retTarget == nil {
946
				q1.To.Type = obj.TYPE_REG
947
				q1.To.Reg = REG_LR
948
			} else {
949
				q1.To.Type = obj.TYPE_BRANCH
950
				q1.To.Sym = retTarget
951
			}
952
			q1.Mark |= BRANCH
953
			q1.Spadj = +autosize
954

955
			q1.Link = q.Link
956
			prev.Link = q1
957
		case AADD:
958
			if p.To.Type == obj.TYPE_REG && p.To.Reg == REGSP && p.From.Type == obj.TYPE_CONST {
959
				p.Spadj = int32(-p.From.Offset)
960
			}
961
		case AMOVDU:
962
			if p.To.Type == obj.TYPE_MEM && p.To.Reg == REGSP {
963
				p.Spadj = int32(-p.To.Offset)
964
			}
965
			if p.From.Type == obj.TYPE_MEM && p.From.Reg == REGSP {
966
				p.Spadj = int32(-p.From.Offset)
967
			}
968
		case obj.AGETCALLERPC:
969
			if cursym.Leaf() {
970
				/* MOVD LR, Rd */
971
				p.As = AMOVD
972
				p.From.Type = obj.TYPE_REG
973
				p.From.Reg = REG_LR
974
			} else {
975
				/* MOVD (RSP), Rd */
976
				p.As = AMOVD
977
				p.From.Type = obj.TYPE_MEM
978
				p.From.Reg = REGSP
979
			}
980
		}
981
	}
982
}
983

984
/*
985
// instruction scheduling
986
	if(debug['Q'] == 0)
987
		return;
988

989
	curtext = nil;
990
	q = nil;	// p - 1
991
	q1 = firstp;	// top of block
992
	o = 0;		// count of instructions
993
	for(p = firstp; p != nil; p = p1) {
994
		p1 = p->link;
995
		o++;
996
		if(p->mark & NOSCHED){
997
			if(q1 != p){
998
				sched(q1, q);
999
			}
1000
			for(; p != nil; p = p->link){
1001
				if(!(p->mark & NOSCHED))
1002
					break;
1003
				q = p;
1004
			}
1005
			p1 = p;
1006
			q1 = p;
1007
			o = 0;
1008
			continue;
1009
		}
1010
		if(p->mark & (LABEL|SYNC)) {
1011
			if(q1 != p)
1012
				sched(q1, q);
1013
			q1 = p;
1014
			o = 1;
1015
		}
1016
		if(p->mark & (BRANCH|SYNC)) {
1017
			sched(q1, p);
1018
			q1 = p1;
1019
			o = 0;
1020
		}
1021
		if(o >= NSCHED) {
1022
			sched(q1, p);
1023
			q1 = p1;
1024
			o = 0;
1025
		}
1026
		q = p;
1027
	}
1028
*/
1029
func (c *ctxt9) stacksplit(p *obj.Prog, framesize int32) *obj.Prog {
1030
	p0 := p // save entry point, but skipping the two instructions setting R2 in shared mode
1031

1032
	// MOVD	g_stackguard(g), R3
1033
	p = obj.Appendp(p, c.newprog)
1034

1035
	p.As = AMOVD
1036
	p.From.Type = obj.TYPE_MEM
1037
	p.From.Reg = REGG
1038
	p.From.Offset = 2 * int64(c.ctxt.Arch.PtrSize) // G.stackguard0
1039
	if c.cursym.CFunc() {
1040
		p.From.Offset = 3 * int64(c.ctxt.Arch.PtrSize) // G.stackguard1
1041
	}
1042
	p.To.Type = obj.TYPE_REG
1043
	p.To.Reg = REG_R3
1044

1045
	// Mark the stack bound check and morestack call async nonpreemptible.
1046
	// If we get preempted here, when resumed the preemption request is
1047
	// cleared, but we'll still call morestack, which will double the stack
1048
	// unnecessarily. See issue #35470.
1049
	p = c.ctxt.StartUnsafePoint(p, c.newprog)
1050

1051
	var q *obj.Prog
1052
	if framesize <= objabi.StackSmall {
1053
		// small stack: SP < stackguard
1054
		//	CMP	stackguard, SP
1055
		p = obj.Appendp(p, c.newprog)
1056

1057
		p.As = ACMPU
1058
		p.From.Type = obj.TYPE_REG
1059
		p.From.Reg = REG_R3
1060
		p.To.Type = obj.TYPE_REG
1061
		p.To.Reg = REGSP
1062
	} else if framesize <= objabi.StackBig {
1063
		// large stack: SP-framesize < stackguard-StackSmall
1064
		//	ADD $-(framesize-StackSmall), SP, R4
1065
		//	CMP stackguard, R4
1066
		p = obj.Appendp(p, c.newprog)
1067

1068
		p.As = AADD
1069
		p.From.Type = obj.TYPE_CONST
1070
		p.From.Offset = -(int64(framesize) - objabi.StackSmall)
1071
		p.Reg = REGSP
1072
		p.To.Type = obj.TYPE_REG
1073
		p.To.Reg = REG_R4
1074

1075
		p = obj.Appendp(p, c.newprog)
1076
		p.As = ACMPU
1077
		p.From.Type = obj.TYPE_REG
1078
		p.From.Reg = REG_R3
1079
		p.To.Type = obj.TYPE_REG
1080
		p.To.Reg = REG_R4
1081
	} else {
1082
		// Such a large stack we need to protect against wraparound.
1083
		// If SP is close to zero:
1084
		//	SP-stackguard+StackGuard <= framesize + (StackGuard-StackSmall)
1085
		// The +StackGuard on both sides is required to keep the left side positive:
1086
		// SP is allowed to be slightly below stackguard. See stack.h.
1087
		//
1088
		// Preemption sets stackguard to StackPreempt, a very large value.
1089
		// That breaks the math above, so we have to check for that explicitly.
1090
		//	// stackguard is R3
1091
		//	CMP	R3, $StackPreempt
1092
		//	BEQ	label-of-call-to-morestack
1093
		//	ADD	$StackGuard, SP, R4
1094
		//	SUB	R3, R4
1095
		//	MOVD	$(framesize+(StackGuard-StackSmall)), R31
1096
		//	CMPU	R31, R4
1097
		p = obj.Appendp(p, c.newprog)
1098

1099
		p.As = ACMP
1100
		p.From.Type = obj.TYPE_REG
1101
		p.From.Reg = REG_R3
1102
		p.To.Type = obj.TYPE_CONST
1103
		p.To.Offset = objabi.StackPreempt
1104

1105
		p = obj.Appendp(p, c.newprog)
1106
		q = p
1107
		p.As = ABEQ
1108
		p.To.Type = obj.TYPE_BRANCH
1109

1110
		p = obj.Appendp(p, c.newprog)
1111
		p.As = AADD
1112
		p.From.Type = obj.TYPE_CONST
1113
		p.From.Offset = int64(objabi.StackGuard)
1114
		p.Reg = REGSP
1115
		p.To.Type = obj.TYPE_REG
1116
		p.To.Reg = REG_R4
1117

1118
		p = obj.Appendp(p, c.newprog)
1119
		p.As = ASUB
1120
		p.From.Type = obj.TYPE_REG
1121
		p.From.Reg = REG_R3
1122
		p.To.Type = obj.TYPE_REG
1123
		p.To.Reg = REG_R4
1124

1125
		p = obj.Appendp(p, c.newprog)
1126
		p.As = AMOVD
1127
		p.From.Type = obj.TYPE_CONST
1128
		p.From.Offset = int64(framesize) + int64(objabi.StackGuard) - objabi.StackSmall
1129
		p.To.Type = obj.TYPE_REG
1130
		p.To.Reg = REGTMP
1131

1132
		p = obj.Appendp(p, c.newprog)
1133
		p.As = ACMPU
1134
		p.From.Type = obj.TYPE_REG
1135
		p.From.Reg = REGTMP
1136
		p.To.Type = obj.TYPE_REG
1137
		p.To.Reg = REG_R4
1138
	}
1139

1140
	// q1: BLT	done
1141
	p = obj.Appendp(p, c.newprog)
1142
	q1 := p
1143

1144
	p.As = ABLT
1145
	p.To.Type = obj.TYPE_BRANCH
1146

1147
	// MOVD	LR, R5
1148
	p = obj.Appendp(p, c.newprog)
1149

1150
	p.As = AMOVD
1151
	p.From.Type = obj.TYPE_REG
1152
	p.From.Reg = REG_LR
1153
	p.To.Type = obj.TYPE_REG
1154
	p.To.Reg = REG_R5
1155
	if q != nil {
1156
		q.To.SetTarget(p)
1157
	}
1158

1159
	p = c.ctxt.EmitEntryStackMap(c.cursym, p, c.newprog)
1160

1161
	var morestacksym *obj.LSym
1162
	if c.cursym.CFunc() {
1163
		morestacksym = c.ctxt.Lookup("runtime.morestackc")
1164
	} else if !c.cursym.Func.Text.From.Sym.NeedCtxt() {
1165
		morestacksym = c.ctxt.Lookup("runtime.morestack_noctxt")
1166
	} else {
1167
		morestacksym = c.ctxt.Lookup("runtime.morestack")
1168
	}
1169

1170
	if c.ctxt.Flag_shared {
1171
		// In PPC64 PIC code, R2 is used as TOC pointer derived from R12
1172
		// which is the address of function entry point when entering
1173
		// the function. We need to preserve R2 across call to morestack.
1174
		// Fortunately, in shared mode, 8(SP) and 16(SP) are reserved in
1175
		// the caller's frame, but not used (0(SP) is caller's saved LR,
1176
		// 24(SP) is caller's saved R2). Use 8(SP) to save this function's R2.
1177

1178
		// MOVD R12, 8(SP)
1179
		p = obj.Appendp(p, c.newprog)
1180
		p.As = AMOVD
1181
		p.From.Type = obj.TYPE_REG
1182
		p.From.Reg = REG_R2
1183
		p.To.Type = obj.TYPE_MEM
1184
		p.To.Reg = REGSP
1185
		p.To.Offset = 8
1186
	}
1187

1188
	if c.ctxt.Flag_dynlink {
1189
		// Avoid calling morestack via a PLT when dynamically linking. The
1190
		// PLT stubs generated by the system linker on ppc64le when "std r2,
1191
		// 24(r1)" to save the TOC pointer in their callers stack
1192
		// frame. Unfortunately (and necessarily) morestack is called before
1193
		// the function that calls it sets up its frame and so the PLT ends
1194
		// up smashing the saved TOC pointer for its caller's caller.
1195
		//
1196
		// According to the ABI documentation there is a mechanism to avoid
1197
		// the TOC save that the PLT stub does (put a R_PPC64_TOCSAVE
1198
		// relocation on the nop after the call to morestack) but at the time
1199
		// of writing it is not supported at all by gold and my attempt to
1200
		// use it with ld.bfd caused an internal linker error. So this hack
1201
		// seems preferable.
1202

1203
		// MOVD $runtime.morestack(SB), R12
1204
		p = obj.Appendp(p, c.newprog)
1205
		p.As = AMOVD
1206
		p.From.Type = obj.TYPE_MEM
1207
		p.From.Sym = morestacksym
1208
		p.From.Name = obj.NAME_GOTREF
1209
		p.To.Type = obj.TYPE_REG
1210
		p.To.Reg = REG_R12
1211

1212
		// MOVD R12, LR
1213
		p = obj.Appendp(p, c.newprog)
1214
		p.As = AMOVD
1215
		p.From.Type = obj.TYPE_REG
1216
		p.From.Reg = REG_R12
1217
		p.To.Type = obj.TYPE_REG
1218
		p.To.Reg = REG_LR
1219

1220
		// BL LR
1221
		p = obj.Appendp(p, c.newprog)
1222
		p.As = obj.ACALL
1223
		p.To.Type = obj.TYPE_REG
1224
		p.To.Reg = REG_LR
1225
	} else {
1226
		// BL	runtime.morestack(SB)
1227
		p = obj.Appendp(p, c.newprog)
1228

1229
		p.As = ABL
1230
		p.To.Type = obj.TYPE_BRANCH
1231
		p.To.Sym = morestacksym
1232
	}
1233

1234
	if c.ctxt.Flag_shared {
1235
		// MOVD 8(SP), R2
1236
		p = obj.Appendp(p, c.newprog)
1237
		p.As = AMOVD
1238
		p.From.Type = obj.TYPE_MEM
1239
		p.From.Reg = REGSP
1240
		p.From.Offset = 8
1241
		p.To.Type = obj.TYPE_REG
1242
		p.To.Reg = REG_R2
1243
	}
1244

1245
	p = c.ctxt.EndUnsafePoint(p, c.newprog, -1)
1246

1247
	// BR	start
1248
	p = obj.Appendp(p, c.newprog)
1249
	p.As = ABR
1250
	p.To.Type = obj.TYPE_BRANCH
1251
	p.To.SetTarget(p0.Link)
1252

1253
	// placeholder for q1's jump target
1254
	p = obj.Appendp(p, c.newprog)
1255

1256
	p.As = obj.ANOP // zero-width place holder
1257
	q1.To.SetTarget(p)
1258

1259
	return p
1260
}
1261

1262
var Linkppc64 = obj.LinkArch{
1263
	Arch:           sys.ArchPPC64,
1264
	Init:           buildop,
1265
	Preprocess:     preprocess,
1266
	Assemble:       span9,
1267
	Progedit:       progedit,
1268
	DWARFRegisters: PPC64DWARFRegisters,
1269
}
1270

1271
var Linkppc64le = obj.LinkArch{
1272
	Arch:           sys.ArchPPC64LE,
1273
	Init:           buildop,
1274
	Preprocess:     preprocess,
1275
	Assemble:       span9,
1276
	Progedit:       progedit,
1277
	DWARFRegisters: PPC64DWARFRegisters,
1278
}
1279