| @@ -0,0 +1,371 @@ | ||
| // Inferno utils/5a/lex.c | ||
| // http://code.google.com/p/inferno-os/source/browse/utils/5a/lex.c | ||
| // | ||
| // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved. | ||
| // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net) | ||
| // Portions Copyright © 1997-1999 Vita Nuova Limited | ||
| // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com) | ||
| // Portions Copyright © 2004,2006 Bruce Ellis | ||
| // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net) | ||
| // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others | ||
| // Portions Copyright © 2009 The Go Authors. All rights reserved. | ||
| // | ||
| // Permission is hereby granted, free of charge, to any person obtaining a copy | ||
| // of this software and associated documentation files (the "Software"), to deal | ||
| // in the Software without restriction, including without limitation the rights | ||
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
| // copies of the Software, and to permit persons to whom the Software is | ||
| // furnished to do so, subject to the following conditions: | ||
| // | ||
| // The above copyright notice and this permission notice shall be included in | ||
| // all copies or substantial portions of the Software. | ||
| // | ||
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
| // THE SOFTWARE. | ||
|
|
||
| //go:generate go tool yacc a.y | ||
|
|
||
| package main | ||
|
|
||
| import ( | ||
| "cmd/internal/asm" | ||
| "cmd/internal/obj" | ||
| "cmd/internal/obj/arm" | ||
| ) | ||
|
|
||
| var ( | ||
| yyerror = asm.Yyerror | ||
| nullgen obj.Addr | ||
| stmtline int32 | ||
| ) | ||
|
|
||
| const Always = arm.C_SCOND_NONE | ||
|
|
||
| func main() { | ||
| cinit() | ||
|
|
||
| asm.LSCONST = LSCONST | ||
| asm.LCONST = LCONST | ||
| asm.LFCONST = LFCONST | ||
| asm.LNAME = LNAME | ||
| asm.LVAR = LVAR | ||
| asm.LLAB = LLAB | ||
|
|
||
| asm.Lexinit = lexinit | ||
| asm.Cclean = cclean | ||
| asm.Yyparse = yyparse | ||
|
|
||
| asm.Thechar = '5' | ||
| asm.Thestring = "arm" | ||
| asm.Thelinkarch = &arm.Linkarm | ||
|
|
||
| asm.Main() | ||
| } | ||
|
|
||
| type yy struct{} | ||
|
|
||
| func (yy) Lex(v *yySymType) int { | ||
| var av asm.Yylval | ||
| tok := asm.Yylex(&av) | ||
| v.sym = av.Sym | ||
| v.lval = int32(av.Lval) | ||
| v.sval = av.Sval | ||
| v.dval = av.Dval | ||
| return tok | ||
| } | ||
|
|
||
| func (yy) Error(msg string) { | ||
| asm.Yyerror("%s", msg) | ||
| } | ||
|
|
||
| func yyparse() { | ||
| yyParse(yy{}) | ||
| } | ||
|
|
||
| var lexinit = []asm.Lextab{ | ||
| {"SP", LSP, obj.NAME_AUTO}, | ||
| {"SB", LSB, obj.NAME_EXTERN}, | ||
| {"FP", LFP, obj.NAME_PARAM}, | ||
| {"PC", LPC, obj.TYPE_BRANCH}, | ||
|
|
||
| {"R", LR, 0}, | ||
|
|
||
| {"R0", LREG, arm.REG_R0}, | ||
| {"R1", LREG, arm.REG_R1}, | ||
| {"R2", LREG, arm.REG_R2}, | ||
| {"R3", LREG, arm.REG_R3}, | ||
| {"R4", LREG, arm.REG_R4}, | ||
| {"R5", LREG, arm.REG_R5}, | ||
| {"R6", LREG, arm.REG_R6}, | ||
| {"R7", LREG, arm.REG_R7}, | ||
| {"R8", LREG, arm.REG_R8}, | ||
| {"R9", LREG, arm.REG_R9}, | ||
| {"g", LREG, arm.REG_R10}, // avoid unintentionally clobber g using R10 | ||
| {"R11", LREG, arm.REG_R11}, | ||
| {"R12", LREG, arm.REG_R12}, | ||
| {"R13", LREG, arm.REG_R13}, | ||
| {"R14", LREG, arm.REG_R14}, | ||
| {"R15", LREG, arm.REG_R15}, | ||
| {"F", LF, 0}, | ||
| {"F0", LFREG, arm.REG_F0}, | ||
| {"F1", LFREG, arm.REG_F1}, | ||
| {"F2", LFREG, arm.REG_F2}, | ||
| {"F3", LFREG, arm.REG_F3}, | ||
| {"F4", LFREG, arm.REG_F4}, | ||
| {"F5", LFREG, arm.REG_F5}, | ||
| {"F6", LFREG, arm.REG_F6}, | ||
| {"F7", LFREG, arm.REG_F7}, | ||
| {"F8", LFREG, arm.REG_F8}, | ||
| {"F9", LFREG, arm.REG_F9}, | ||
| {"F10", LFREG, arm.REG_F10}, | ||
| {"F11", LFREG, arm.REG_F11}, | ||
| {"F12", LFREG, arm.REG_F12}, | ||
| {"F13", LFREG, arm.REG_F13}, | ||
| {"F14", LFREG, arm.REG_F14}, | ||
| {"F15", LFREG, arm.REG_F15}, | ||
| {"C", LC, 0}, | ||
| {"C0", LCREG, 0}, | ||
| {"C1", LCREG, 1}, | ||
| {"C2", LCREG, 2}, | ||
| {"C3", LCREG, 3}, | ||
| {"C4", LCREG, 4}, | ||
| {"C5", LCREG, 5}, | ||
| {"C6", LCREG, 6}, | ||
| {"C7", LCREG, 7}, | ||
| {"C8", LCREG, 8}, | ||
| {"C9", LCREG, 9}, | ||
| {"C10", LCREG, 10}, | ||
| {"C11", LCREG, 11}, | ||
| {"C12", LCREG, 12}, | ||
| {"C13", LCREG, 13}, | ||
| {"C14", LCREG, 14}, | ||
| {"C15", LCREG, 15}, | ||
| {"CPSR", LPSR, arm.REG_CPSR}, | ||
| {"SPSR", LPSR, arm.REG_SPSR}, | ||
| {"FPSR", LFCR, arm.REG_FPSR}, | ||
| {"FPCR", LFCR, arm.REG_FPCR}, | ||
| {".EQ", LCOND, arm.C_SCOND_EQ}, | ||
| {".NE", LCOND, arm.C_SCOND_NE}, | ||
| {".CS", LCOND, arm.C_SCOND_HS}, | ||
| {".HS", LCOND, arm.C_SCOND_HS}, | ||
| {".CC", LCOND, arm.C_SCOND_LO}, | ||
| {".LO", LCOND, arm.C_SCOND_LO}, | ||
| {".MI", LCOND, arm.C_SCOND_MI}, | ||
| {".PL", LCOND, arm.C_SCOND_PL}, | ||
| {".VS", LCOND, arm.C_SCOND_VS}, | ||
| {".VC", LCOND, arm.C_SCOND_VC}, | ||
| {".HI", LCOND, arm.C_SCOND_HI}, | ||
| {".LS", LCOND, arm.C_SCOND_LS}, | ||
| {".GE", LCOND, arm.C_SCOND_GE}, | ||
| {".LT", LCOND, arm.C_SCOND_LT}, | ||
| {".GT", LCOND, arm.C_SCOND_GT}, | ||
| {".LE", LCOND, arm.C_SCOND_LE}, | ||
| {".AL", LCOND, arm.C_SCOND_NONE}, | ||
| {".U", LS, arm.C_UBIT}, | ||
| {".S", LS, arm.C_SBIT}, | ||
| {".W", LS, arm.C_WBIT}, | ||
| {".P", LS, arm.C_PBIT}, | ||
| {".PW", LS, arm.C_WBIT | arm.C_PBIT}, | ||
| {".WP", LS, arm.C_WBIT | arm.C_PBIT}, | ||
| {".F", LS, arm.C_FBIT}, | ||
| {".IBW", LS, arm.C_WBIT | arm.C_PBIT | arm.C_UBIT}, | ||
| {".IAW", LS, arm.C_WBIT | arm.C_UBIT}, | ||
| {".DBW", LS, arm.C_WBIT | arm.C_PBIT}, | ||
| {".DAW", LS, arm.C_WBIT}, | ||
| {".IB", LS, arm.C_PBIT | arm.C_UBIT}, | ||
| {".IA", LS, arm.C_UBIT}, | ||
| {".DB", LS, arm.C_PBIT}, | ||
| {".DA", LS, 0}, | ||
| {"@", LAT, 0}, | ||
| {"AND", LTYPE1, arm.AAND}, | ||
| {"EOR", LTYPE1, arm.AEOR}, | ||
| {"SUB", LTYPE1, arm.ASUB}, | ||
| {"RSB", LTYPE1, arm.ARSB}, | ||
| {"ADD", LTYPE1, arm.AADD}, | ||
| {"ADC", LTYPE1, arm.AADC}, | ||
| {"SBC", LTYPE1, arm.ASBC}, | ||
| {"RSC", LTYPE1, arm.ARSC}, | ||
| {"ORR", LTYPE1, arm.AORR}, | ||
| {"BIC", LTYPE1, arm.ABIC}, | ||
| {"SLL", LTYPE1, arm.ASLL}, | ||
| {"SRL", LTYPE1, arm.ASRL}, | ||
| {"SRA", LTYPE1, arm.ASRA}, | ||
| {"MUL", LTYPE1, arm.AMUL}, | ||
| {"MULA", LTYPEN, arm.AMULA}, | ||
| {"DIV", LTYPE1, arm.ADIV}, | ||
| {"MOD", LTYPE1, arm.AMOD}, | ||
| {"MULL", LTYPEM, arm.AMULL}, | ||
| {"MULAL", LTYPEM, arm.AMULAL}, | ||
| {"MULLU", LTYPEM, arm.AMULLU}, | ||
| {"MULALU", LTYPEM, arm.AMULALU}, | ||
| {"MVN", LTYPE2, arm.AMVN}, /* op2 ignored */ | ||
| {"MOVB", LTYPE3, arm.AMOVB}, | ||
| {"MOVBU", LTYPE3, arm.AMOVBU}, | ||
| {"MOVH", LTYPE3, arm.AMOVH}, | ||
| {"MOVHU", LTYPE3, arm.AMOVHU}, | ||
| {"MOVW", LTYPE3, arm.AMOVW}, | ||
| {"MOVD", LTYPE3, arm.AMOVD}, | ||
| {"MOVDF", LTYPE3, arm.AMOVDF}, | ||
| {"MOVDW", LTYPE3, arm.AMOVDW}, | ||
| {"MOVF", LTYPE3, arm.AMOVF}, | ||
| {"MOVFD", LTYPE3, arm.AMOVFD}, | ||
| {"MOVFW", LTYPE3, arm.AMOVFW}, | ||
| {"MOVWD", LTYPE3, arm.AMOVWD}, | ||
| {"MOVWF", LTYPE3, arm.AMOVWF}, | ||
| {"LDREX", LTYPE3, arm.ALDREX}, | ||
| {"LDREXD", LTYPE3, arm.ALDREXD}, | ||
| {"STREX", LTYPE9, arm.ASTREX}, | ||
| {"STREXD", LTYPE9, arm.ASTREXD}, | ||
|
|
||
| /* | ||
| {"NEGF", LTYPEI, ANEGF}, | ||
| {"NEGD", LTYPEI, ANEGD}, | ||
| {"SQTF", LTYPEI, ASQTF}, | ||
| {"SQTD", LTYPEI, ASQTD}, | ||
| {"RNDF", LTYPEI, ARNDF}, | ||
| {"RNDD", LTYPEI, ARNDD}, | ||
| {"URDF", LTYPEI, AURDF}, | ||
| {"URDD", LTYPEI, AURDD}, | ||
| {"NRMF", LTYPEI, ANRMF}, | ||
| {"NRMD", LTYPEI, ANRMD}, | ||
| */ | ||
| {"ABSF", LTYPEI, arm.AABSF}, | ||
| {"ABSD", LTYPEI, arm.AABSD}, | ||
| {"SQRTF", LTYPEI, arm.ASQRTF}, | ||
| {"SQRTD", LTYPEI, arm.ASQRTD}, | ||
| {"CMPF", LTYPEL, arm.ACMPF}, | ||
| {"CMPD", LTYPEL, arm.ACMPD}, | ||
| {"ADDF", LTYPEK, arm.AADDF}, | ||
| {"ADDD", LTYPEK, arm.AADDD}, | ||
| {"SUBF", LTYPEK, arm.ASUBF}, | ||
| {"SUBD", LTYPEK, arm.ASUBD}, | ||
| {"MULF", LTYPEK, arm.AMULF}, | ||
| {"MULD", LTYPEK, arm.AMULD}, | ||
| {"DIVF", LTYPEK, arm.ADIVF}, | ||
| {"DIVD", LTYPEK, arm.ADIVD}, | ||
| {"B", LTYPE4, arm.AB}, | ||
| {"BL", LTYPE4, arm.ABL}, | ||
| {"BX", LTYPEBX, arm.ABX}, | ||
| {"BEQ", LTYPE5, arm.ABEQ}, | ||
| {"BNE", LTYPE5, arm.ABNE}, | ||
| {"BCS", LTYPE5, arm.ABCS}, | ||
| {"BHS", LTYPE5, arm.ABHS}, | ||
| {"BCC", LTYPE5, arm.ABCC}, | ||
| {"BLO", LTYPE5, arm.ABLO}, | ||
| {"BMI", LTYPE5, arm.ABMI}, | ||
| {"BPL", LTYPE5, arm.ABPL}, | ||
| {"BVS", LTYPE5, arm.ABVS}, | ||
| {"BVC", LTYPE5, arm.ABVC}, | ||
| {"BHI", LTYPE5, arm.ABHI}, | ||
| {"BLS", LTYPE5, arm.ABLS}, | ||
| {"BGE", LTYPE5, arm.ABGE}, | ||
| {"BLT", LTYPE5, arm.ABLT}, | ||
| {"BGT", LTYPE5, arm.ABGT}, | ||
| {"BLE", LTYPE5, arm.ABLE}, | ||
| {"BCASE", LTYPE5, arm.ABCASE}, | ||
| {"SWI", LTYPE6, arm.ASWI}, | ||
| {"CMP", LTYPE7, arm.ACMP}, | ||
| {"TST", LTYPE7, arm.ATST}, | ||
| {"TEQ", LTYPE7, arm.ATEQ}, | ||
| {"CMN", LTYPE7, arm.ACMN}, | ||
| {"MOVM", LTYPE8, arm.AMOVM}, | ||
| {"SWPBU", LTYPE9, arm.ASWPBU}, | ||
| {"SWPW", LTYPE9, arm.ASWPW}, | ||
| {"RET", LTYPEA, obj.ARET}, | ||
| {"RFE", LTYPEA, arm.ARFE}, | ||
| {"TEXT", LTYPEB, obj.ATEXT}, | ||
| {"GLOBL", LGLOBL, obj.AGLOBL}, | ||
| {"DATA", LTYPEC, obj.ADATA}, | ||
| {"CASE", LTYPED, arm.ACASE}, | ||
| {"END", LTYPEE, obj.AEND}, | ||
| {"WORD", LTYPEH, arm.AWORD}, | ||
| {"NOP", LTYPEI, obj.ANOP}, | ||
| {"MCR", LTYPEJ, 0}, | ||
| {"MRC", LTYPEJ, 1}, | ||
| {"PLD", LTYPEPLD, arm.APLD}, | ||
| {"UNDEF", LTYPEE, obj.AUNDEF}, | ||
| {"CLZ", LTYPE2, arm.ACLZ}, | ||
| {"MULWT", LTYPE1, arm.AMULWT}, | ||
| {"MULWB", LTYPE1, arm.AMULWB}, | ||
| {"MULAWT", LTYPEN, arm.AMULAWT}, | ||
| {"MULAWB", LTYPEN, arm.AMULAWB}, | ||
| {"USEFIELD", LTYPEN, obj.AUSEFIELD}, | ||
| {"PCDATA", LTYPEPC, obj.APCDATA}, | ||
| {"FUNCDATA", LTYPEF, obj.AFUNCDATA}, | ||
| } | ||
|
|
||
| func cinit() { | ||
| } | ||
|
|
||
| func isreg(g *obj.Addr) bool { | ||
| return true | ||
| } | ||
|
|
||
| func cclean() { | ||
| outcode(obj.AEND, Always, &nullgen, 0, &nullgen) | ||
| } | ||
|
|
||
| var bcode = []int{ | ||
| arm.ABEQ, | ||
| arm.ABNE, | ||
| arm.ABCS, | ||
| arm.ABCC, | ||
| arm.ABMI, | ||
| arm.ABPL, | ||
| arm.ABVS, | ||
| arm.ABVC, | ||
| arm.ABHI, | ||
| arm.ABLS, | ||
| arm.ABGE, | ||
| arm.ABLT, | ||
| arm.ABGT, | ||
| arm.ABLE, | ||
| arm.AB, | ||
| obj.ANOP, | ||
| } | ||
|
|
||
| var lastpc *obj.Prog | ||
|
|
||
| func outcode(a, scond int32, g1 *obj.Addr, reg int32, g2 *obj.Addr) { | ||
| var p *obj.Prog | ||
| var pl *obj.Plist | ||
|
|
||
| /* hack to make B.NE etc. work: turn it into the corresponding conditional */ | ||
| if a == arm.AB { | ||
| a = int32(bcode[(scond^arm.C_SCOND_XOR)&0xf]) | ||
| scond = (scond &^ 0xf) | Always | ||
| } | ||
|
|
||
| if asm.Pass == 1 { | ||
| goto out | ||
| } | ||
|
|
||
| p = new(obj.Prog) | ||
| *p = obj.Prog{} | ||
| p.Ctxt = asm.Ctxt | ||
| p.As = int16(a) | ||
| p.Lineno = stmtline | ||
| p.Scond = uint8(scond) | ||
| p.From = *g1 | ||
| p.Reg = int16(reg) | ||
| p.To = *g2 | ||
| p.Pc = int64(asm.PC) | ||
|
|
||
| if lastpc == nil { | ||
| pl = obj.Linknewplist(asm.Ctxt) | ||
| pl.Firstpc = p | ||
| } else { | ||
| lastpc.Link = p | ||
| } | ||
| lastpc = p | ||
|
|
||
| out: | ||
| if a != obj.AGLOBL && a != obj.ADATA { | ||
| asm.PC++ | ||
| } | ||
| } |
| @@ -0,0 +1,85 @@ | ||
| // Copyright 2009 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 main | ||
|
|
||
| import ( | ||
| "cmd/internal/obj" | ||
| "cmd/internal/obj/arm" | ||
| ) | ||
| import "cmd/internal/gc" | ||
|
|
||
| var thechar int = '5' | ||
|
|
||
| var thestring string = "arm" | ||
|
|
||
| var thelinkarch *obj.LinkArch = &arm.Linkarm | ||
|
|
||
| func linkarchinit() { | ||
| } | ||
|
|
||
| var MAXWIDTH int64 = (1 << 32) - 1 | ||
|
|
||
| /* | ||
| * go declares several platform-specific type aliases: | ||
| * int, uint, float, and uintptr | ||
| */ | ||
| var typedefs = []gc.Typedef{ | ||
| gc.Typedef{"int", gc.TINT, gc.TINT32}, | ||
| gc.Typedef{"uint", gc.TUINT, gc.TUINT32}, | ||
| gc.Typedef{"uintptr", gc.TUINTPTR, gc.TUINT32}, | ||
| } | ||
|
|
||
| func betypeinit() { | ||
| gc.Widthptr = 4 | ||
| gc.Widthint = 4 | ||
| gc.Widthreg = 4 | ||
|
|
||
| } | ||
|
|
||
| func main() { | ||
| gc.Thearch.Thechar = thechar | ||
| gc.Thearch.Thestring = thestring | ||
| gc.Thearch.Thelinkarch = thelinkarch | ||
| gc.Thearch.Typedefs = typedefs | ||
| gc.Thearch.REGSP = arm.REGSP | ||
| gc.Thearch.REGCTXT = arm.REGCTXT | ||
| gc.Thearch.MAXWIDTH = MAXWIDTH | ||
| gc.Thearch.Anyregalloc = anyregalloc | ||
| gc.Thearch.Betypeinit = betypeinit | ||
| gc.Thearch.Bgen = bgen | ||
| gc.Thearch.Cgen = cgen | ||
| gc.Thearch.Cgen_call = cgen_call | ||
| gc.Thearch.Cgen_callinter = cgen_callinter | ||
| gc.Thearch.Cgen_ret = cgen_ret | ||
| gc.Thearch.Clearfat = clearfat | ||
| gc.Thearch.Defframe = defframe | ||
| gc.Thearch.Excise = excise | ||
| gc.Thearch.Expandchecks = expandchecks | ||
| gc.Thearch.Gclean = gclean | ||
| gc.Thearch.Ginit = ginit | ||
| gc.Thearch.Gins = gins | ||
| gc.Thearch.Ginscall = ginscall | ||
| gc.Thearch.Igen = igen | ||
| gc.Thearch.Linkarchinit = linkarchinit | ||
| gc.Thearch.Peep = peep | ||
| gc.Thearch.Proginfo = proginfo | ||
| gc.Thearch.Regalloc = regalloc | ||
| gc.Thearch.Regfree = regfree | ||
| gc.Thearch.Regtyp = regtyp | ||
| gc.Thearch.Sameaddr = sameaddr | ||
| gc.Thearch.Smallindir = smallindir | ||
| gc.Thearch.Stackaddr = stackaddr | ||
| gc.Thearch.Excludedregs = excludedregs | ||
| gc.Thearch.RtoB = RtoB | ||
| gc.Thearch.FtoB = RtoB | ||
| gc.Thearch.BtoR = BtoR | ||
| gc.Thearch.BtoF = BtoF | ||
| gc.Thearch.Optoas = optoas | ||
| gc.Thearch.Doregbits = doregbits | ||
| gc.Thearch.Regnames = regnames | ||
|
|
||
| gc.Main() | ||
| gc.Exit(0) | ||
| } |
| @@ -0,0 +1,32 @@ | ||
| // Copyright 2009 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 main | ||
|
|
||
| import "cmd/internal/obj/arm" | ||
|
|
||
| // Copyright 2009 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. | ||
|
|
||
| const ( | ||
| REGALLOC_R0 = arm.REG_R0 | ||
| REGALLOC_RMAX = arm.REGEXT | ||
| REGALLOC_F0 = arm.REG_F0 | ||
| REGALLOC_FMAX = arm.FREGEXT | ||
| ) | ||
|
|
||
| var reg [REGALLOC_FMAX + 1]uint8 | ||
|
|
||
| /* | ||
| * cgen | ||
| */ | ||
|
|
||
| /* | ||
| * list.c | ||
| */ | ||
|
|
||
| /* | ||
| * reg.c | ||
| */ |
| @@ -0,0 +1,163 @@ | ||
| // Copyright 2013 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 main | ||
|
|
||
| import ( | ||
| "cmd/internal/obj" | ||
| "cmd/internal/obj/arm" | ||
| ) | ||
| import "cmd/internal/gc" | ||
|
|
||
| const ( | ||
| RightRdwr = gc.RightRead | gc.RightWrite | ||
| ) | ||
|
|
||
| // This table gives the basic information about instruction | ||
| // generated by the compiler and processed in the optimizer. | ||
| // See opt.h for bit definitions. | ||
| // | ||
| // Instructions not generated need not be listed. | ||
| // As an exception to that rule, we typically write down all the | ||
| // size variants of an operation even if we just use a subset. | ||
| // | ||
| // The table is formatted for 8-space tabs. | ||
| var progtable = [arm.ALAST]gc.ProgInfo{ | ||
| obj.ATYPE: gc.ProgInfo{gc.Pseudo | gc.Skip, 0, 0, 0}, | ||
| obj.ATEXT: gc.ProgInfo{gc.Pseudo, 0, 0, 0}, | ||
| obj.AFUNCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0}, | ||
| obj.APCDATA: gc.ProgInfo{gc.Pseudo, 0, 0, 0}, | ||
| obj.AUNDEF: gc.ProgInfo{gc.Break, 0, 0, 0}, | ||
| obj.AUSEFIELD: gc.ProgInfo{gc.OK, 0, 0, 0}, | ||
| obj.ACHECKNIL: gc.ProgInfo{gc.LeftRead, 0, 0, 0}, | ||
| obj.AVARDEF: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0}, | ||
| obj.AVARKILL: gc.ProgInfo{gc.Pseudo | gc.RightWrite, 0, 0, 0}, | ||
|
|
||
| // NOP is an internal no-op that also stands | ||
| // for USED and SET annotations, not the Intel opcode. | ||
| obj.ANOP: gc.ProgInfo{gc.LeftRead | gc.RightWrite, 0, 0, 0}, | ||
|
|
||
| // Integer. | ||
| arm.AADC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AADD: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AAND: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ABIC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ACMN: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0}, | ||
| arm.ACMP: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0}, | ||
| arm.ADIVU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ADIV: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AEOR: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AMODU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AMOD: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AMULALU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0}, | ||
| arm.AMULAL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0}, | ||
| arm.AMULA: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | RightRdwr, 0, 0, 0}, | ||
| arm.AMULU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AMUL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AMULL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AMULLU: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AMVN: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.AORR: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ARSB: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ARSC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ASBC: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ASLL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ASRA: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ASRL: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ASUB: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RegRead | gc.RightWrite, 0, 0, 0}, | ||
| arm.ATEQ: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0}, | ||
| arm.ATST: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightRead, 0, 0, 0}, | ||
|
|
||
| // Floating point. | ||
| arm.AADDD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
| arm.AADDF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
| arm.ACMPD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightRead, 0, 0, 0}, | ||
| arm.ACMPF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightRead, 0, 0, 0}, | ||
| arm.ADIVD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
| arm.ADIVF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
| arm.AMULD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
| arm.AMULF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
| arm.ASUBD: gc.ProgInfo{gc.SizeD | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
| arm.ASUBF: gc.ProgInfo{gc.SizeF | gc.LeftRead | RightRdwr, 0, 0, 0}, | ||
|
|
||
| // Conversions. | ||
| arm.AMOVWD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVWF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVDF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVDW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVFD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVFW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
|
|
||
| // Moves. | ||
| arm.AMOVB: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0}, | ||
| arm.AMOVD: gc.ProgInfo{gc.SizeD | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0}, | ||
| arm.AMOVF: gc.ProgInfo{gc.SizeF | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0}, | ||
| arm.AMOVH: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0}, | ||
| arm.AMOVW: gc.ProgInfo{gc.SizeL | gc.LeftRead | gc.RightWrite | gc.Move, 0, 0, 0}, | ||
|
|
||
| // In addtion, duffzero reads R0,R1 and writes R1. This fact is | ||
| // encoded in peep.c | ||
| obj.ADUFFZERO: gc.ProgInfo{gc.Call, 0, 0, 0}, | ||
|
|
||
| // In addtion, duffcopy reads R1,R2 and writes R0,R1,R2. This fact is | ||
| // encoded in peep.c | ||
| obj.ADUFFCOPY: gc.ProgInfo{gc.Call, 0, 0, 0}, | ||
|
|
||
| // These should be split into the two different conversions instead | ||
| // of overloading the one. | ||
| arm.AMOVBS: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVBU: gc.ProgInfo{gc.SizeB | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVHS: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
| arm.AMOVHU: gc.ProgInfo{gc.SizeW | gc.LeftRead | gc.RightWrite | gc.Conv, 0, 0, 0}, | ||
|
|
||
| // Jumps. | ||
| arm.AB: gc.ProgInfo{gc.Jump | gc.Break, 0, 0, 0}, | ||
| arm.ABL: gc.ProgInfo{gc.Call, 0, 0, 0}, | ||
| arm.ABEQ: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABNE: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABCS: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABHS: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABCC: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABLO: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABMI: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABPL: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABVS: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABVC: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABHI: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABLS: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABGE: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABLT: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABGT: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| arm.ABLE: gc.ProgInfo{gc.Cjmp, 0, 0, 0}, | ||
| obj.ARET: gc.ProgInfo{gc.Break, 0, 0, 0}, | ||
| } | ||
|
|
||
| func proginfo(info *gc.ProgInfo, p *obj.Prog) { | ||
| *info = progtable[p.As] | ||
| if info.Flags == 0 { | ||
| gc.Fatal("unknown instruction %v", p) | ||
| } | ||
|
|
||
| if p.From.Type == obj.TYPE_ADDR && p.From.Sym != nil && (info.Flags&gc.LeftRead != 0) { | ||
| info.Flags &^= gc.LeftRead | ||
| info.Flags |= gc.LeftAddr | ||
| } | ||
|
|
||
| if (info.Flags&gc.RegRead != 0) && p.Reg == 0 { | ||
| info.Flags &^= gc.RegRead | ||
| info.Flags |= gc.CanRegRead | gc.RightRead | ||
| } | ||
|
|
||
| if (p.Scond&arm.C_SCOND != arm.C_SCOND_NONE) && (info.Flags&gc.RightWrite != 0) { | ||
| info.Flags |= gc.RightRead | ||
| } | ||
|
|
||
| switch p.As { | ||
| case arm.ADIV, | ||
| arm.ADIVU, | ||
| arm.AMOD, | ||
| arm.AMODU: | ||
| info.Regset |= RtoB(arm.REG_R12) | ||
| } | ||
| } |
| @@ -0,0 +1,12 @@ | ||
| // Copyright 2015 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 main | ||
|
|
||
| func bool2int(b bool) int { | ||
| if b { | ||
| return 1 | ||
| } | ||
| return 0 | ||
| } |
| @@ -0,0 +1,110 @@ | ||
| // Copyright 2009 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 main | ||
|
|
||
| import ( | ||
| "cmd/internal/obj" | ||
| "cmd/internal/obj/x86" | ||
| ) | ||
| import "cmd/internal/gc" | ||
|
|
||
| var thechar int = '6' | ||
|
|
||
| var thestring string = "amd64" | ||
|
|
||
| var thelinkarch *obj.LinkArch = &x86.Linkamd64 | ||
|
|
||
| func linkarchinit() { | ||
| if obj.Getgoarch() == "amd64p32" { | ||
| thelinkarch = &x86.Linkamd64p32 | ||
| gc.Thearch.Thelinkarch = thelinkarch | ||
| thestring = "amd64p32" | ||
| gc.Thearch.Thestring = "amd64p32" | ||
| } | ||
| } | ||
|
|
||
| var MAXWIDTH int64 = 1 << 50 | ||
|
|
||
| var addptr int = x86.AADDQ | ||
|
|
||
| var movptr int = x86.AMOVQ | ||
|
|
||
| var leaptr int = x86.ALEAQ | ||
|
|
||
| var cmpptr int = x86.ACMPQ | ||
|
|
||
| /* | ||
| * go declares several platform-specific type aliases: | ||
| * int, uint, float, and uintptr | ||
| */ | ||
| var typedefs = []gc.Typedef{ | ||
| gc.Typedef{"int", gc.TINT, gc.TINT64}, | ||
| gc.Typedef{"uint", gc.TUINT, gc.TUINT64}, | ||
| gc.Typedef{"uintptr", gc.TUINTPTR, gc.TUINT64}, | ||
| } | ||
|
|
||
| func betypeinit() { | ||
| gc.Widthptr = 8 | ||
| gc.Widthint = 8 | ||
| gc.Widthreg = 8 | ||
| if obj.Getgoarch() == "amd64p32" { | ||
| gc.Widthptr = 4 | ||
| gc.Widthint = 4 | ||
| addptr = x86.AADDL | ||
| movptr = x86.AMOVL | ||
| leaptr = x86.ALEAL | ||
| cmpptr = x86.ACMPL | ||
| typedefs[0].Sameas = gc.TINT32 | ||
| typedefs[1].Sameas = gc.TUINT32 | ||
| typedefs[2].Sameas = gc.TUINT32 | ||
| } | ||
|
|
||
| } | ||
|
|
||
| func main() { | ||
| gc.Thearch.Thechar = thechar | ||
| gc.Thearch.Thestring = thestring | ||
| gc.Thearch.Thelinkarch = thelinkarch | ||
| gc.Thearch.Typedefs = typedefs | ||
| gc.Thearch.REGSP = x86.REGSP | ||
| gc.Thearch.REGCTXT = x86.REGCTXT | ||
| gc.Thearch.MAXWIDTH = MAXWIDTH | ||
| gc.Thearch.Anyregalloc = anyregalloc | ||
| gc.Thearch.Betypeinit = betypeinit | ||
| gc.Thearch.Bgen = bgen | ||
| gc.Thearch.Cgen = cgen | ||
| gc.Thearch.Cgen_call = cgen_call | ||
| gc.Thearch.Cgen_callinter = cgen_callinter | ||
| gc.Thearch.Cgen_ret = cgen_ret | ||
| gc.Thearch.Clearfat = clearfat | ||
| gc.Thearch.Defframe = defframe | ||
| gc.Thearch.Excise = excise | ||
| gc.Thearch.Expandchecks = expandchecks | ||
| gc.Thearch.Gclean = gclean | ||
| gc.Thearch.Ginit = ginit | ||
| gc.Thearch.Gins = gins | ||
| gc.Thearch.Ginscall = ginscall | ||
| gc.Thearch.Igen = igen | ||
| gc.Thearch.Linkarchinit = linkarchinit | ||
| gc.Thearch.Peep = peep | ||
| gc.Thearch.Proginfo = proginfo | ||
| gc.Thearch.Regalloc = regalloc | ||
| gc.Thearch.Regfree = regfree | ||
| gc.Thearch.Regtyp = regtyp | ||
| gc.Thearch.Sameaddr = sameaddr | ||
| gc.Thearch.Smallindir = smallindir | ||
| gc.Thearch.Stackaddr = stackaddr | ||
| gc.Thearch.Excludedregs = excludedregs | ||
| gc.Thearch.RtoB = RtoB | ||
| gc.Thearch.FtoB = FtoB | ||
| gc.Thearch.BtoR = BtoR | ||
| gc.Thearch.BtoF = BtoF | ||
| gc.Thearch.Optoas = optoas | ||
| gc.Thearch.Doregbits = doregbits | ||
| gc.Thearch.Regnames = regnames | ||
|
|
||
| gc.Main() | ||
| gc.Exit(0) | ||
| } |
| @@ -0,0 +1,24 @@ | ||
| // Copyright 2009 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 main | ||
|
|
||
| import "cmd/internal/obj/x86" | ||
| import "cmd/internal/gc" | ||
|
|
||
| // Copyright 2009 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. | ||
|
|
||
| var reg [x86.MAXREG]uint8 | ||
|
|
||
| var panicdiv *gc.Node | ||
|
|
||
| /* | ||
| * cgen.c | ||
| */ | ||
|
|
||
| /* | ||
| * list.c | ||
| */ |
| @@ -0,0 +1,12 @@ | ||
| // Copyright 2015 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 main | ||
|
|
||
| func bool2int(b bool) int { | ||
| if b { | ||
| return 1 | ||
| } | ||
| return 0 | ||
| } |