Black Lives Matter. Support the Equal Justice Initiative.

Source file src/cmd/compile/internal/ssa/check.go

Documentation: cmd/compile/internal/ssa

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package ssa
     6  
     7  import (
     8  	"cmd/internal/obj/s390x"
     9  	"math"
    10  	"math/bits"
    11  )
    12  
    13  // checkFunc checks invariants of f.
    14  func checkFunc(f *Func) {
    15  	blockMark := make([]bool, f.NumBlocks())
    16  	valueMark := make([]bool, f.NumValues())
    17  
    18  	for _, b := range f.Blocks {
    19  		if blockMark[b.ID] {
    20  			f.Fatalf("block %s appears twice in %s!", b, f.Name)
    21  		}
    22  		blockMark[b.ID] = true
    23  		if b.Func != f {
    24  			f.Fatalf("%s.Func=%s, want %s", b, b.Func.Name, f.Name)
    25  		}
    26  
    27  		for i, e := range b.Preds {
    28  			if se := e.b.Succs[e.i]; se.b != b || se.i != i {
    29  				f.Fatalf("block pred/succ not crosslinked correctly %d:%s %d:%s", i, b, se.i, se.b)
    30  			}
    31  		}
    32  		for i, e := range b.Succs {
    33  			if pe := e.b.Preds[e.i]; pe.b != b || pe.i != i {
    34  				f.Fatalf("block succ/pred not crosslinked correctly %d:%s %d:%s", i, b, pe.i, pe.b)
    35  			}
    36  		}
    37  
    38  		switch b.Kind {
    39  		case BlockExit:
    40  			if len(b.Succs) != 0 {
    41  				f.Fatalf("exit block %s has successors", b)
    42  			}
    43  			if b.NumControls() != 1 {
    44  				f.Fatalf("exit block %s has no control value", b)
    45  			}
    46  			if !b.Controls[0].Type.IsMemory() {
    47  				f.Fatalf("exit block %s has non-memory control value %s", b, b.Controls[0].LongString())
    48  			}
    49  		case BlockRet:
    50  			if len(b.Succs) != 0 {
    51  				f.Fatalf("ret block %s has successors", b)
    52  			}
    53  			if b.NumControls() != 1 {
    54  				f.Fatalf("ret block %s has nil control", b)
    55  			}
    56  			if !b.Controls[0].Type.IsMemory() {
    57  				f.Fatalf("ret block %s has non-memory control value %s", b, b.Controls[0].LongString())
    58  			}
    59  		case BlockRetJmp:
    60  			if len(b.Succs) != 0 {
    61  				f.Fatalf("retjmp block %s len(Succs)==%d, want 0", b, len(b.Succs))
    62  			}
    63  			if b.NumControls() != 1 {
    64  				f.Fatalf("retjmp block %s has nil control", b)
    65  			}
    66  			if !b.Controls[0].Type.IsMemory() {
    67  				f.Fatalf("retjmp block %s has non-memory control value %s", b, b.Controls[0].LongString())
    68  			}
    69  			if b.Aux == nil {
    70  				f.Fatalf("retjmp block %s has nil Aux field", b)
    71  			}
    72  		case BlockPlain:
    73  			if len(b.Succs) != 1 {
    74  				f.Fatalf("plain block %s len(Succs)==%d, want 1", b, len(b.Succs))
    75  			}
    76  			if b.NumControls() != 0 {
    77  				f.Fatalf("plain block %s has non-nil control %s", b, b.Controls[0].LongString())
    78  			}
    79  		case BlockIf:
    80  			if len(b.Succs) != 2 {
    81  				f.Fatalf("if block %s len(Succs)==%d, want 2", b, len(b.Succs))
    82  			}
    83  			if b.NumControls() != 1 {
    84  				f.Fatalf("if block %s has no control value", b)
    85  			}
    86  			if !b.Controls[0].Type.IsBoolean() {
    87  				f.Fatalf("if block %s has non-bool control value %s", b, b.Controls[0].LongString())
    88  			}
    89  		case BlockDefer:
    90  			if len(b.Succs) != 2 {
    91  				f.Fatalf("defer block %s len(Succs)==%d, want 2", b, len(b.Succs))
    92  			}
    93  			if b.NumControls() != 1 {
    94  				f.Fatalf("defer block %s has no control value", b)
    95  			}
    96  			if !b.Controls[0].Type.IsMemory() {
    97  				f.Fatalf("defer block %s has non-memory control value %s", b, b.Controls[0].LongString())
    98  			}
    99  		case BlockFirst:
   100  			if len(b.Succs) != 2 {
   101  				f.Fatalf("plain/dead block %s len(Succs)==%d, want 2", b, len(b.Succs))
   102  			}
   103  			if b.NumControls() != 0 {
   104  				f.Fatalf("plain/dead block %s has a control value", b)
   105  			}
   106  		}
   107  		if len(b.Succs) != 2 && b.Likely != BranchUnknown {
   108  			f.Fatalf("likeliness prediction %d for block %s with %d successors", b.Likely, b, len(b.Succs))
   109  		}
   110  
   111  		for _, v := range b.Values {
   112  			// Check to make sure argument count makes sense (argLen of -1 indicates
   113  			// variable length args)
   114  			nArgs := opcodeTable[v.Op].argLen
   115  			if nArgs != -1 && int32(len(v.Args)) != nArgs {
   116  				f.Fatalf("value %s has %d args, expected %d", v.LongString(),
   117  					len(v.Args), nArgs)
   118  			}
   119  
   120  			// Check to make sure aux values make sense.
   121  			canHaveAux := false
   122  			canHaveAuxInt := false
   123  			// TODO: enforce types of Aux in this switch (like auxString does below)
   124  			switch opcodeTable[v.Op].auxType {
   125  			case auxNone:
   126  			case auxBool:
   127  				if v.AuxInt < 0 || v.AuxInt > 1 {
   128  					f.Fatalf("bad bool AuxInt value for %v", v)
   129  				}
   130  				canHaveAuxInt = true
   131  			case auxInt8:
   132  				if v.AuxInt != int64(int8(v.AuxInt)) {
   133  					f.Fatalf("bad int8 AuxInt value for %v", v)
   134  				}
   135  				canHaveAuxInt = true
   136  			case auxInt16:
   137  				if v.AuxInt != int64(int16(v.AuxInt)) {
   138  					f.Fatalf("bad int16 AuxInt value for %v", v)
   139  				}
   140  				canHaveAuxInt = true
   141  			case auxInt32:
   142  				if v.AuxInt != int64(int32(v.AuxInt)) {
   143  					f.Fatalf("bad int32 AuxInt value for %v", v)
   144  				}
   145  				canHaveAuxInt = true
   146  			case auxInt64, auxARM64BitField:
   147  				canHaveAuxInt = true
   148  			case auxInt128:
   149  				// AuxInt must be zero, so leave canHaveAuxInt set to false.
   150  			case auxUInt8:
   151  				if v.AuxInt != int64(uint8(v.AuxInt)) {
   152  					f.Fatalf("bad uint8 AuxInt value for %v", v)
   153  				}
   154  				canHaveAuxInt = true
   155  			case auxFloat32:
   156  				canHaveAuxInt = true
   157  				if math.IsNaN(v.AuxFloat()) {
   158  					f.Fatalf("value %v has an AuxInt that encodes a NaN", v)
   159  				}
   160  				if !isExactFloat32(v.AuxFloat()) {
   161  					f.Fatalf("value %v has an AuxInt value that is not an exact float32", v)
   162  				}
   163  			case auxFloat64:
   164  				canHaveAuxInt = true
   165  				if math.IsNaN(v.AuxFloat()) {
   166  					f.Fatalf("value %v has an AuxInt that encodes a NaN", v)
   167  				}
   168  			case auxString:
   169  				if _, ok := v.Aux.(string); !ok {
   170  					f.Fatalf("value %v has Aux type %T, want string", v, v.Aux)
   171  				}
   172  				canHaveAux = true
   173  			case auxCallOff:
   174  				canHaveAuxInt = true
   175  				fallthrough
   176  			case auxCall:
   177  				if ac, ok := v.Aux.(*AuxCall); ok {
   178  					if v.Op == OpStaticCall && ac.Fn == nil {
   179  						f.Fatalf("value %v has *AuxCall with nil Fn", v)
   180  					}
   181  				} else {
   182  					f.Fatalf("value %v has Aux type %T, want *AuxCall", v, v.Aux)
   183  				}
   184  				canHaveAux = true
   185  			case auxSym, auxTyp:
   186  				canHaveAux = true
   187  			case auxSymOff, auxSymValAndOff, auxTypSize:
   188  				canHaveAuxInt = true
   189  				canHaveAux = true
   190  			case auxCCop:
   191  				if opcodeTable[Op(v.AuxInt)].name == "OpInvalid" {
   192  					f.Fatalf("value %v has an AuxInt value that is a valid opcode", v)
   193  				}
   194  				canHaveAuxInt = true
   195  			case auxS390XCCMask:
   196  				if _, ok := v.Aux.(s390x.CCMask); !ok {
   197  					f.Fatalf("bad type %T for S390XCCMask in %v", v.Aux, v)
   198  				}
   199  				canHaveAux = true
   200  			case auxS390XRotateParams:
   201  				if _, ok := v.Aux.(s390x.RotateParams); !ok {
   202  					f.Fatalf("bad type %T for S390XRotateParams in %v", v.Aux, v)
   203  				}
   204  				canHaveAux = true
   205  			case auxFlagConstant:
   206  				if v.AuxInt < 0 || v.AuxInt > 15 {
   207  					f.Fatalf("bad FlagConstant AuxInt value for %v", v)
   208  				}
   209  				canHaveAuxInt = true
   210  			default:
   211  				f.Fatalf("unknown aux type for %s", v.Op)
   212  			}
   213  			if !canHaveAux && v.Aux != nil {
   214  				f.Fatalf("value %s has an Aux value %v but shouldn't", v.LongString(), v.Aux)
   215  			}
   216  			if !canHaveAuxInt && v.AuxInt != 0 {
   217  				f.Fatalf("value %s has an AuxInt value %d but shouldn't", v.LongString(), v.AuxInt)
   218  			}
   219  
   220  			for i, arg := range v.Args {
   221  				if arg == nil {
   222  					f.Fatalf("value %s has nil arg", v.LongString())
   223  				}
   224  				if v.Op != OpPhi {
   225  					// For non-Phi ops, memory args must be last, if present
   226  					if arg.Type.IsMemory() && i != len(v.Args)-1 {
   227  						f.Fatalf("value %s has non-final memory arg (%d < %d)", v.LongString(), i, len(v.Args)-1)
   228  					}
   229  				}
   230  			}
   231  
   232  			if valueMark[v.ID] {
   233  				f.Fatalf("value %s appears twice!", v.LongString())
   234  			}
   235  			valueMark[v.ID] = true
   236  
   237  			if v.Block != b {
   238  				f.Fatalf("%s.block != %s", v, b)
   239  			}
   240  			if v.Op == OpPhi && len(v.Args) != len(b.Preds) {
   241  				f.Fatalf("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b)
   242  			}
   243  
   244  			if v.Op == OpAddr {
   245  				if len(v.Args) == 0 {
   246  					f.Fatalf("no args for OpAddr %s", v.LongString())
   247  				}
   248  				if v.Args[0].Op != OpSB {
   249  					f.Fatalf("bad arg to OpAddr %v", v)
   250  				}
   251  			}
   252  
   253  			if v.Op == OpLocalAddr {
   254  				if len(v.Args) != 2 {
   255  					f.Fatalf("wrong # of args for OpLocalAddr %s", v.LongString())
   256  				}
   257  				if v.Args[0].Op != OpSP {
   258  					f.Fatalf("bad arg 0 to OpLocalAddr %v", v)
   259  				}
   260  				if !v.Args[1].Type.IsMemory() {
   261  					f.Fatalf("bad arg 1 to OpLocalAddr %v", v)
   262  				}
   263  			}
   264  
   265  			if f.RegAlloc != nil && f.Config.SoftFloat && v.Type.IsFloat() {
   266  				f.Fatalf("unexpected floating-point type %v", v.LongString())
   267  			}
   268  
   269  			// Check types.
   270  			// TODO: more type checks?
   271  			switch c := f.Config; v.Op {
   272  			case OpSP, OpSB:
   273  				if v.Type != c.Types.Uintptr {
   274  					f.Fatalf("bad %s type: want uintptr, have %s",
   275  						v.Op, v.Type.String())
   276  				}
   277  			case OpStringLen:
   278  				if v.Type != c.Types.Int {
   279  					f.Fatalf("bad %s type: want int, have %s",
   280  						v.Op, v.Type.String())
   281  				}
   282  			case OpLoad:
   283  				if !v.Args[1].Type.IsMemory() {
   284  					f.Fatalf("bad arg 1 type to %s: want mem, have %s",
   285  						v.Op, v.Args[1].Type.String())
   286  				}
   287  			case OpStore:
   288  				if !v.Type.IsMemory() {
   289  					f.Fatalf("bad %s type: want mem, have %s",
   290  						v.Op, v.Type.String())
   291  				}
   292  				if !v.Args[2].Type.IsMemory() {
   293  					f.Fatalf("bad arg 2 type to %s: want mem, have %s",
   294  						v.Op, v.Args[2].Type.String())
   295  				}
   296  			case OpCondSelect:
   297  				if !v.Args[2].Type.IsBoolean() {
   298  					f.Fatalf("bad arg 2 type to %s: want boolean, have %s",
   299  						v.Op, v.Args[2].Type.String())
   300  				}
   301  			case OpAddPtr:
   302  				if !v.Args[0].Type.IsPtrShaped() && v.Args[0].Type != c.Types.Uintptr {
   303  					f.Fatalf("bad arg 0 type to %s: want ptr, have %s", v.Op, v.Args[0].LongString())
   304  				}
   305  				if !v.Args[1].Type.IsInteger() {
   306  					f.Fatalf("bad arg 1 type to %s: want integer, have %s", v.Op, v.Args[1].LongString())
   307  				}
   308  
   309  			}
   310  
   311  			// TODO: check for cycles in values
   312  		}
   313  	}
   314  
   315  	// Check to make sure all Blocks referenced are in the function.
   316  	if !blockMark[f.Entry.ID] {
   317  		f.Fatalf("entry block %v is missing", f.Entry)
   318  	}
   319  	for _, b := range f.Blocks {
   320  		for _, c := range b.Preds {
   321  			if !blockMark[c.b.ID] {
   322  				f.Fatalf("predecessor block %v for %v is missing", c, b)
   323  			}
   324  		}
   325  		for _, c := range b.Succs {
   326  			if !blockMark[c.b.ID] {
   327  				f.Fatalf("successor block %v for %v is missing", c, b)
   328  			}
   329  		}
   330  	}
   331  
   332  	if len(f.Entry.Preds) > 0 {
   333  		f.Fatalf("entry block %s of %s has predecessor(s) %v", f.Entry, f.Name, f.Entry.Preds)
   334  	}
   335  
   336  	// Check to make sure all Values referenced are in the function.
   337  	for _, b := range f.Blocks {
   338  		for _, v := range b.Values {
   339  			for i, a := range v.Args {
   340  				if !valueMark[a.ID] {
   341  					f.Fatalf("%v, arg %d of %s, is missing", a, i, v.LongString())
   342  				}
   343  			}
   344  		}
   345  		for _, c := range b.ControlValues() {
   346  			if !valueMark[c.ID] {
   347  				f.Fatalf("control value for %s is missing: %v", b, c)
   348  			}
   349  		}
   350  	}
   351  	for b := f.freeBlocks; b != nil; b = b.succstorage[0].b {
   352  		if blockMark[b.ID] {
   353  			f.Fatalf("used block b%d in free list", b.ID)
   354  		}
   355  	}
   356  	for v := f.freeValues; v != nil; v = v.argstorage[0] {
   357  		if valueMark[v.ID] {
   358  			f.Fatalf("used value v%d in free list", v.ID)
   359  		}
   360  	}
   361  
   362  	// Check to make sure all args dominate uses.
   363  	if f.RegAlloc == nil {
   364  		// Note: regalloc introduces non-dominating args.
   365  		// See TODO in regalloc.go.
   366  		sdom := f.Sdom()
   367  		for _, b := range f.Blocks {
   368  			for _, v := range b.Values {
   369  				for i, arg := range v.Args {
   370  					x := arg.Block
   371  					y := b
   372  					if v.Op == OpPhi {
   373  						y = b.Preds[i].b
   374  					}
   375  					if !domCheck(f, sdom, x, y) {
   376  						f.Fatalf("arg %d of value %s does not dominate, arg=%s", i, v.LongString(), arg.LongString())
   377  					}
   378  				}
   379  			}
   380  			for _, c := range b.ControlValues() {
   381  				if !domCheck(f, sdom, c.Block, b) {
   382  					f.Fatalf("control value %s for %s doesn't dominate", c, b)
   383  				}
   384  			}
   385  		}
   386  	}
   387  
   388  	// Check loop construction
   389  	if f.RegAlloc == nil && f.pass != nil { // non-nil pass allows better-targeted debug printing
   390  		ln := f.loopnest()
   391  		if !ln.hasIrreducible {
   392  			po := f.postorder() // use po to avoid unreachable blocks.
   393  			for _, b := range po {
   394  				for _, s := range b.Succs {
   395  					bb := s.Block()
   396  					if ln.b2l[b.ID] == nil && ln.b2l[bb.ID] != nil && bb != ln.b2l[bb.ID].header {
   397  						f.Fatalf("block %s not in loop branches to non-header block %s in loop", b.String(), bb.String())
   398  					}
   399  					if ln.b2l[b.ID] != nil && ln.b2l[bb.ID] != nil && bb != ln.b2l[bb.ID].header && !ln.b2l[b.ID].isWithinOrEq(ln.b2l[bb.ID]) {
   400  						f.Fatalf("block %s in loop branches to non-header block %s in non-containing loop", b.String(), bb.String())
   401  					}
   402  				}
   403  			}
   404  		}
   405  	}
   406  
   407  	// Check use counts
   408  	uses := make([]int32, f.NumValues())
   409  	for _, b := range f.Blocks {
   410  		for _, v := range b.Values {
   411  			for _, a := range v.Args {
   412  				uses[a.ID]++
   413  			}
   414  		}
   415  		for _, c := range b.ControlValues() {
   416  			uses[c.ID]++
   417  		}
   418  	}
   419  	for _, b := range f.Blocks {
   420  		for _, v := range b.Values {
   421  			if v.Uses != uses[v.ID] {
   422  				f.Fatalf("%s has %d uses, but has Uses=%d", v, uses[v.ID], v.Uses)
   423  			}
   424  		}
   425  	}
   426  
   427  	memCheck(f)
   428  }
   429  
   430  func memCheck(f *Func) {
   431  	// Check that if a tuple has a memory type, it is second.
   432  	for _, b := range f.Blocks {
   433  		for _, v := range b.Values {
   434  			if v.Type.IsTuple() && v.Type.FieldType(0).IsMemory() {
   435  				f.Fatalf("memory is first in a tuple: %s\n", v.LongString())
   436  			}
   437  		}
   438  	}
   439  
   440  	// Single live memory checks.
   441  	// These checks only work if there are no memory copies.
   442  	// (Memory copies introduce ambiguity about which mem value is really live.
   443  	// probably fixable, but it's easier to avoid the problem.)
   444  	// For the same reason, disable this check if some memory ops are unused.
   445  	for _, b := range f.Blocks {
   446  		for _, v := range b.Values {
   447  			if (v.Op == OpCopy || v.Uses == 0) && v.Type.IsMemory() {
   448  				return
   449  			}
   450  		}
   451  		if b != f.Entry && len(b.Preds) == 0 {
   452  			return
   453  		}
   454  	}
   455  
   456  	// Compute live memory at the end of each block.
   457  	lastmem := make([]*Value, f.NumBlocks())
   458  	ss := newSparseSet(f.NumValues())
   459  	for _, b := range f.Blocks {
   460  		// Mark overwritten memory values. Those are args of other
   461  		// ops that generate memory values.
   462  		ss.clear()
   463  		for _, v := range b.Values {
   464  			if v.Op == OpPhi || !v.Type.IsMemory() {
   465  				continue
   466  			}
   467  			if m := v.MemoryArg(); m != nil {
   468  				ss.add(m.ID)
   469  			}
   470  		}
   471  		// There should be at most one remaining unoverwritten memory value.
   472  		for _, v := range b.Values {
   473  			if !v.Type.IsMemory() {
   474  				continue
   475  			}
   476  			if ss.contains(v.ID) {
   477  				continue
   478  			}
   479  			if lastmem[b.ID] != nil {
   480  				f.Fatalf("two live memory values in %s: %s and %s", b, lastmem[b.ID], v)
   481  			}
   482  			lastmem[b.ID] = v
   483  		}
   484  		// If there is no remaining memory value, that means there was no memory update.
   485  		// Take any memory arg.
   486  		if lastmem[b.ID] == nil {
   487  			for _, v := range b.Values {
   488  				if v.Op == OpPhi {
   489  					continue
   490  				}
   491  				m := v.MemoryArg()
   492  				if m == nil {
   493  					continue
   494  				}
   495  				if lastmem[b.ID] != nil && lastmem[b.ID] != m {
   496  					f.Fatalf("two live memory values in %s: %s and %s", b, lastmem[b.ID], m)
   497  				}
   498  				lastmem[b.ID] = m
   499  			}
   500  		}
   501  	}
   502  	// Propagate last live memory through storeless blocks.
   503  	for {
   504  		changed := false
   505  		for _, b := range f.Blocks {
   506  			if lastmem[b.ID] != nil {
   507  				continue
   508  			}
   509  			for _, e := range b.Preds {
   510  				p := e.b
   511  				if lastmem[p.ID] != nil {
   512  					lastmem[b.ID] = lastmem[p.ID]
   513  					changed = true
   514  					break
   515  				}
   516  			}
   517  		}
   518  		if !changed {
   519  			break
   520  		}
   521  	}
   522  	// Check merge points.
   523  	for _, b := range f.Blocks {
   524  		for _, v := range b.Values {
   525  			if v.Op == OpPhi && v.Type.IsMemory() {
   526  				for i, a := range v.Args {
   527  					if a != lastmem[b.Preds[i].b.ID] {
   528  						f.Fatalf("inconsistent memory phi %s %d %s %s", v.LongString(), i, a, lastmem[b.Preds[i].b.ID])
   529  					}
   530  				}
   531  			}
   532  		}
   533  	}
   534  
   535  	// Check that only one memory is live at any point.
   536  	if f.scheduled {
   537  		for _, b := range f.Blocks {
   538  			var mem *Value // the current live memory in the block
   539  			for _, v := range b.Values {
   540  				if v.Op == OpPhi {
   541  					if v.Type.IsMemory() {
   542  						mem = v
   543  					}
   544  					continue
   545  				}
   546  				if mem == nil && len(b.Preds) > 0 {
   547  					// If no mem phi, take mem of any predecessor.
   548  					mem = lastmem[b.Preds[0].b.ID]
   549  				}
   550  				for _, a := range v.Args {
   551  					if a.Type.IsMemory() && a != mem {
   552  						f.Fatalf("two live mems @ %s: %s and %s", v, mem, a)
   553  					}
   554  				}
   555  				if v.Type.IsMemory() {
   556  					mem = v
   557  				}
   558  			}
   559  		}
   560  	}
   561  
   562  	// Check that after scheduling, phis are always first in the block.
   563  	if f.scheduled {
   564  		for _, b := range f.Blocks {
   565  			seenNonPhi := false
   566  			for _, v := range b.Values {
   567  				switch v.Op {
   568  				case OpPhi:
   569  					if seenNonPhi {
   570  						f.Fatalf("phi after non-phi @ %s: %s", b, v)
   571  					}
   572  				default:
   573  					seenNonPhi = true
   574  				}
   575  			}
   576  		}
   577  	}
   578  }
   579  
   580  // domCheck reports whether x dominates y (including x==y).
   581  func domCheck(f *Func, sdom SparseTree, x, y *Block) bool {
   582  	if !sdom.IsAncestorEq(f.Entry, y) {
   583  		// unreachable - ignore
   584  		return true
   585  	}
   586  	return sdom.IsAncestorEq(x, y)
   587  }
   588  
   589  // isExactFloat32 reports whether x can be exactly represented as a float32.
   590  func isExactFloat32(x float64) bool {
   591  	// Check the mantissa is in range.
   592  	if bits.TrailingZeros64(math.Float64bits(x)) < 52-23 {
   593  		return false
   594  	}
   595  	// Check the exponent is in range. The mantissa check above is sufficient for NaN values.
   596  	return math.IsNaN(x) || x == float64(float32(x))
   597  }
   598  

View as plain text