248 return abi0
249 case obj.ABIInternal:
250▶ // TODO(austin): Clean up the nomenclature here.
251 // It's not clear that "abi1" is ABIInternal.
252 return abi1
· · ·
258 a := abi0
259 if fn != nil {
260▶ if fn.Pragma&ir.RegisterParams != 0 { // TODO(register args) remove after register abi is working
261 a = abi1
262 }
· · ·
393 }
394 htmlWriter = ssahtml.NewHTMLWriter(ssaDF, s.f, ssaDumpCFG, compiler.Passes())
395▶ // TODO: generate and print a mapping from nodes to values and blocks
396 dumpSourcesColumn(htmlWriter, fn)
397 htmlWriter.WriteAST("AST", astBuf)
· · ·
413 // preceding the deferreturn/ret code that we don't track correctly.
414 //
415▶ // TODO this restriction can be removed given adjusted offset in computeDeferReturn in cmd/link/internal/ld/pcln.go
416 s.hasOpenDefers = false
417 }
· · ·
442 }
443
444▶ s.sp = s.entryNewValue0(ssaop.OpSP, types.Types[types.TUINTPTR]) // TODO: use generic pointer type (unsafe.Pointer?) instead
445 s.sb = s.entryNewValue0(ssaop.OpSB, types.Types[types.TUINTPTR])
446
+ 46 more matches in this file
108 rangeLitGen int
109
110▶ // TODO(mdempsky): The state below is all specific to reading
111 // function bodies. It probably makes sense to split it out
112 // separately so that it doesn't take up space in every reader
· · ·
554 // to "any".
555
556▶ // TODO(mdempsky): Restore consistency check to make sure folding to
557 // "any" is safe. This is unfortunately tricky, because a pure
558 // interface can reference impure interfaces too, including
· · ·
829 setType(name, shapeSig(name.Func, r.dict))
830 } else {
831▶ todoDicts = append(todoDicts, func() {
832 r.dict.shapedObj = pr.objIdx(idx, implicits, explicits, true).(*ir.Name)
833 })
· · ·
856
857 if r.hasTypeParams() && !r.dict.shaped {
858▶ todoDicts = append(todoDicts, func() {
859 r.dict.shapedObj = pr.objIdx(idx, implicits, explicits, true).(*ir.Name)
860 })
· · ·
990 // Otherwise, we simply use the type's underlying type as its shape.
991 //
992▶ // TODO(mdempsky): It should be possible to do much more aggressive
993 // shaping still; e.g., collapsing all pointer-shaped types into a
994 // common type, collapsing scalars of the same size/alignment into a
+ 46 more matches in this file
82// x is now a spilled value and a restore must appear before its first use.
83
84▶// TODO
85
86// Use an affinity graph to mark two values which should use the
· · ·
110// of x3 not dominated by the definition of x3, and the CX->BX copy
111// will have no use (so don't run deadcode after regalloc!).
112▶// TODO: maybe we should introduce these extra phis?
113
114package ssacompile
· · ·
297type endReg struct {
298 r ssaop.Register
299▶ v *ssa.Value // pre-regalloc value held in this register (TODO: can we use ID here?)
300 c *ssa.Value // cached version of the value
301}
· · ·
407 // Pick a value to spill. Spill the value with the
408 // farthest-in-the-future use.
409▶ // TODO: Prefer registers with already spilled Values?
410 // TODO: Modify preference using affinity graph.
411 // TODO: if a single value is in multiple registers, spill one of them
· · ·
410▶ // TODO: Modify preference using affinity graph.
411 // TODO: if a single value is in multiple registers, spill one of them
412 // before spilling a value in just a single register.
+ 17 more matches in this file
175
176 // For each slice s, a map from s to a len(s)/cap(s) value (if any)
177▶ // TODO: check if there are cases that matter where we have
178 // more than one len(s) for a slice. We could keep a list if necessary.
179 lens map[ssa.ID]*ssa.Value
· · ·
304 // the posets will not notice.
305 if ft.recurseCheck[v.ID] {
306▶ // This should only happen for unsatisfiable cases. TODO: check
307 return
308 }
· · ·
317 ft.limits[v.ID] = lim
318 if v.Block.Func.Pass.Debug > 2 {
319▶ // TODO: pos is probably wrong. This is the position where v is defined,
320 // not the position where we learned the fact about it (which was
321 // probably some subsequent compare+branch).
· · ·
430 r ^= lt | gt | eq
431 }
432▶ // TODO: v.Block is wrong?
433 addRestrictions(v.Block, ft, d, v.Args[0], v.Args[1], r)
434 }
· · ·
466 }
467 ft.update(v.Block, v.Args[0], v.Args[1], unsigned, r)
468▶ // TODO: v.Block is wrong here
469 }
470 }
+ 12 more matches in this file
56// function body reading code.
57
58▶// TODO(mdempsky): Add an importer for Unified IR to the x/tools repo,
59// and better document the file format boundary between public and
60// private data.
· · ·
182 sig *types2.Signature
183
184▶ // TODO(mdempsky): We should be able to prune localsIdx whenever a
185 // scope closes, and then maybe we can just use the same map for
186 // storing the TypeParams too (as their TypeName instead).
· · ·
390 pos := p.Pos()
391
392▶ // TODO(mdempsky): Track down the remaining cases here and fix them.
393 if !w.Bool(pos.IsKnown()) {
394 return
· · ·
395 }
396
397▶ // TODO(mdempsky): Delta encoding.
398 w.posBase(pos.Base())
399 w.Uint(pos.Line())
· · ·
459 w.String("unsafe")
460 default:
461▶ // TODO(mdempsky): Write out pkg.Path() for curpkg too.
462 var path string
463 if pkg != w.p.curpkg {
+ 19 more matches in this file
63var (
64 // List of all hot callee nodes.
65▶ // TODO(prattmic): Make this non-global.
66 candHotCalleeMap = make(map[*pgoir.IRNode]struct{})
67
· · ·
70
71 // List of all hot call sites. CallSiteInfo.Callee is always nil.
72▶ // TODO(prattmic): Make this non-global.
73 candHotEdgeMap = make(map[pgoir.CallSiteInfo]struct{})
74
· · ·
382 // alive information is lost during inlining.
383 //
384▶ // TODO(prattmic): This is handled on calls during escape analysis,
385 // which is after inlining. Move prior to inlining so the keep-alive is
386 // maintained after inlining.
· · ·
647 // will miss those.
648 //
649▶ // TODO: in the case of a single-call closure, the inlining budget here is potentially much, much larger.
650 //
651 v.budget -= callee.Inl.Cost
· · ·
683
684 case ir.ORECOVER:
685▶ // TODO: maybe we could allow inlining of recover() now?
686 v.reason = "call to recover"
687 return true
+ 5 more matches in this file
294 }
295 } else {
296▶ // TODO(mdempsky): We should be able to share these too (except
297 // maybe when dynamic linking).
298 sname = fmt.Sprintf("%s%s.%d", sname, types.LocalPkg.Prefix, dnameCount)
· · ·
718 }
719
720▶ // TODO(mdempsky): Investigate whether this still happens.
721 // If we know we don't need to emit code for a type,
722 // we should have a link-symbol index for it.
· · ·
723▶ // See also TODO in NeedEmit.
724 return lsym
725 }
· · ·
775 case types.TPTR:
776 rt = rttype.PtrType
777▶ // TODO: use rttype.Type for Elem() is ANY?
778 case types.TSTRUCT:
779 rt = rttype.StructType
· · ·
1014// create a dummy itab with zeroed-out method entries.
1015func writeITab(lsym *obj.LSym, typ, iface *types.Type, allowNonImplement bool) {
1016▶ // TODO(mdempsky): Fix methodWrapper, geneq, and genhash (and maybe
1017 // others) to stop clobbering these.
1018 oldpos, oldfn := base.Pos, ir.CurFunc
+ 6 more matches in this file
68 // Queue of locations to walk. Has enough room for b.allLocs
69 // plus b.heapLoc, b.mutatorLoc, b.calleeLoc.
70▶ todo := newQueue(len(b.allLocs) + 3)
71
72 enqueue := func(loc *location) {
· · ·
77 // which in some cases allows attrEscape to
78 // propagate faster.
79▶ todo.pushFront(loc)
80 } else {
81 todo.pushBack(loc)
· · ·
81▶ todo.pushBack(loc)
82 }
83 }
· · ·
85
86 for _, loc := range b.allLocs {
87▶ todo.pushFront(loc)
88 // TODO(thepudds): clean up setting queuedWalkAll.
89 loc.queuedWalkAll = true
· · ·
88▶ // TODO(thepudds): clean up setting queuedWalkAll.
89 loc.queuedWalkAll = true
90 }
+ 21 more matches in this file
160 }
161
162▶ // TODO inlining produces expressions with ninits. we can't print these yet.
163
164 if OpPrec[n.Op()] < 0 {
· · ·
408 case OFOR:
409 n := n.(*ForStmt)
410▶ if !exportFormat { // TODO maybe only if FmtShort, same below
411 fmt.Fprintf(s, "for loop")
412 break
· · ·
761 case OINLCALL:
762 n := n.(*InlinedCallExpr)
763▶ // TODO(mdempsky): Print Init and/or Body?
764 if len(n.ReturnVars) == 1 {
765 fmt.Fprintf(s, "%v", n.ReturnVars[0])
· · ·
1007 mt := m.Type()
1008 if mt.NumIn() == 0 && mt.NumOut() == 1 && mt.Out(0).Kind() == reflect.Bool {
1009▶ // TODO(rsc): Remove the func/defer/recover wrapping,
1010 // which is guarding against panics in miniExpr,
1011 // once we get down to the simpler state in which
· · ·
1050 fmt.Fprint(w, sep)
1051 sep = " "
1052▶ // TODO(mdempsky): Print line pragma details too.
1053 file := filepath.Base(pos.Filename())
1054 // Note: this output will be parsed by ssa/html.go:(*HTMLWriter).WriteAST. Keep in sync.
127 canHaveAux := false
128 canHaveAuxInt := false
129▶ // TODO: enforce types of Aux in this switch (like auxString does below)
130 switch ssaop.OpcodeTable[v.Op].AuxType {
131 case ssaop.AuxTypeNone:
· · ·
288
289 // Check types.
290▶ // TODO: more type checks?
291 switch c := f.Config; v.Op {
292 case ssaop.OpSP, ssaop.OpSB:
· · ·
396 }
397
398▶ // TODO: check for cycles in values
399 }
400 }
· · ·
450 if f.RegAlloc == nil {
451 // Note: regalloc introduces non-dominating args.
452▶ // See TODO in regalloc.go.
453 sdom := f.Sdom()
454 for _, b := range f.Blocks {
40// referenced by the local package and thus haven't been read yet.
41//
42▶// TODO(prattmic): Does not handle instantiation of generic types. Currently
43// profiles don't contain the original type arguments, so we won't be able to
44// create the runtime dictionaries.
· · ·
45//
46▶// TODO(prattmic): Hit rate of this function is usually fairly low, and errors
47// are only used when debug logging is enabled. Consider constructing cheaper
48// errors by default.
· · ·
78// PostLookupCleanup performs cleanup operations needed
79// after a series of calls to LookupFunc, specifically invoking
80▶// readBodies to post-process any funcs on the "todoBodies" list
81// that were added as a result of the lookup operations.
82func PostLookupCleanup() {
· · ·
87 sym := pkg.Lookup(symName)
88
89▶ // TODO(prattmic): Enclosed functions (e.g., foo.Bar.func1) are not
90 // present in objReader, only as OCLOSURE nodes in the enclosing
91 // function.
· · ·
243 var inlDecls []*ir.Func
244
245▶ // Don't use range--bodyIdx can add closures to todoBodies.
246 for {
247 // The order we expand dictionaries and bodies doesn't matter, so
+ 10 more matches in this file
125func Funcs(all []*ir.Func) {
126 // Make a cache of ir.ReassignOracles. The cache is lazily populated.
127▶ // TODO(thepudds): consider adding a field on ir.Func instead. We might also be able
128 // to use that field elsewhere, like in walk. See discussion in https://go.dev/cl/688075.
129 reassignOracles := make(map[*ir.Func]*ir.ReassignOracle)
· · ·
311 // Omit escape diagnostics for go/defer wrappers, at least for now.
312 // Historically, we haven't printed them, and test cases don't expect them.
313▶ // TODO(mdempsky): Update tests to expect this.
314 goDeferWrapper := n.Op() == ir.OCLOSURE && n.(*ir.ClosureExpr).Func.Wrapper()
315
· · ·
331 }
332 if logopt.Enabled() {
333▶ var e_curfn *ir.Func // TODO(mdempsky): Fix.
334 logopt.LogOpt(n.Pos(), "escape", "escape", ir.FuncName(e_curfn))
335 }
· · ·
428 // Only report diagnostics for user code;
429 // not for wrappers generated around them.
430▶ // TODO(mdempsky): Generalize this.
431 diagnose := base.Flag.LowerM != 0 && !(fn.Wrapper() || fn.Dupok())
432
· · ·
515 base.WarnfAt(pos, "leaking param: %v", name)
516 } else {
517▶ // TODO(mdempsky): Mention level=x like below?
518 base.WarnfAt(pos, "leaking param content: %v", name)
519 }
+ 1 more matches in this file
23
24// A miniExpr is a miniNode with extra fields common to expressions.
25▶// TODO(rsc): Once we are sure about the contents, compact the bools
26// into a bit field and leave extra bits available for implementations
27// embedding miniExpr. Right now there are ~24 unused bits sitting here.
· · ·
30 flags bitset8
31 typ *types.Type
32▶ init Nodes // TODO(rsc): Don't require every Node to have an init
33}
34
· · ·
288 // unsafe.Pointer to *Elem or *[Len]Elem.
289 //
290▶ // TODO(mdempsky): We only ever need one of these, but currently we
291 // don't decide which one until walk. Longer term, it probably makes
292 // sense to have a dedicated IR op for `(*[Len]Elem)(ptr)[:n:m]`
· · ·
585 fn.Class = PFUNC
586 if n.Selection.Nname != nil {
587▶ // TODO(austin): Nname is nil for interface method
588 // expressions (I.M), so we can't attach a Func to
589 // those here.
· · ·
876// NOTE: StaticValue can return a result with a different type than
877// n's type because it can traverse through OCONVNOP operations.
878▶// TODO: consider reapplying OCONVNOP operations to the result. See https://go.dev/cl/676517.
879func StaticValue(n Node) Node {
880 for {
+ 3 more matches in this file
130 // Statistics about every single call. Handy for external data analysis.
131 //
132▶ // TODO(prattmic): Log via logopt?
133 stat = constructCallStat(p, fn, name, call)
134 if stat != nil {
· · ·
232 }
233
234▶ // TODO(go.dev/issue/61577): Closures need the closure context passed
235 // via the context register. That requires extra plumbing that we
236 // haven't done yet.
· · ·
251 return nil, nil, 0
252 }
253▶ // TODO(prattmic): We don't properly handle methods as callees in two
254 // different dimensions:
255 //
· · ·
322 }
323
324▶ // TODO(prattmic): checking only InlineImpossible is very conservative,
325 // primarily excluding only functions with pragmas. We probably want to
326 // move in either direction. Either:
· · ·
520 // makes handling reassignment of return values easier.
521 //
522▶ // TODO(prattmic): This increases the size of the AST in the caller,
523 // making it less like to inline. We may want to compensate for this
524 // somehow.
+ 5 more matches in this file
131 for idx := range 2 {
132 // Check that the control if it either ind </<= limit or limit </<= ind.
133▶ // TODO: Handle unsigned comparisons?
134 inclusive := false
135 switch c.Op {
· · ·
246 return false
247 }
248▶ // TODO(1.27): investigate passing a smaller-magnitude overflow limit to addU
249 // for addWillOverflow.
250 v = addU(init.AuxInt, diff(v, init.AuxInt)/uint64(step)*uint64(step))
· · ·
279 return step <= k+1 && k != maxSignedValue(limit.Type)
280
281▶ // TODO: other unrolling idioms
282 // for i := 0; i < KNN - KNN % k ; i += k
283 // for i := 0; i < KNN&^(k-1) ; i += k // k a power of 2
· · ·
298 return false
299 }
300▶ // TODO(1.27): investigate passing a smaller-magnitude underflow limit to subU
301 // for subWillUnderflow.
302 v = subU(init.AuxInt, diff(init.AuxInt, v)/uint64(-step)*uint64(-step))
· · ·
398 y -= 1 << 63
399 }
400▶ // TODO(1.27): investigate passing a smaller-magnitude overflow limit in here.
401 if addWillOverflow(x, int64(y), maxSignedValue(types.Types[types.TINT64])) {
402 base.Fatalf("addU overflowed %d + %d", x, y)
+ 1 more matches in this file
1059 // _cgoCheckPointer returns the untyped nil the type assertion we
1060 // are going to insert will fail. Easier to just skip nil arguments.
1061▶ // TODO: Note that this fails if nil is shadowed.
1062 if id, ok := arg.(*ast.Ident); ok && id.Name == "nil" {
1063 return false
· · ·
1098 return true
1099 case *ast.Ident:
1100▶ // TODO: Handle types defined within function.
1101 for _, d := range p.Decl {
1102 gd, ok := d.(*ast.GenDecl)
· · ·
1397 return false
1398 case *ast.Ident:
1399▶ // TODO: This ignores shadowing.
1400 switch t.Name {
1401 case "unsafe.Pointer", "bool", "byte",
· · ·
2239// gccErrors is called concurrently with different C programs.
2240func (p *Package) gccErrors(stdin []byte, extraArgs ...string) string {
2241▶ // TODO(rsc): require failure
2242 args := p.gccCmd(gccTmp())
2243
· · ·
2738 t.C.Set("__typeof__(unsigned char[%d])", t.Size)
2739 }
2740▶ t.Align = 1 // TODO: should probably base this on field alignment.
2741 typedef[name.Name] = t
2742 case "struct":
+ 3 more matches in this file
112 ))
113 sym.Def = fn.Nname
114▶ fn.Pragma |= ir.Noinline // TODO(mdempsky): We need to emit this during the unified frontend instead, to allow inlining.
115 typecheck.DeclFunc(fn)
116 np := fn.Dcl[0]
· · ·
347 ))
348 sym.Def = fn.Nname
349▶ fn.Pragma |= ir.Noinline // TODO(mdempsky): We need to emit this during the unified frontend instead, to allow inlining.
350 typecheck.DeclFunc(fn)
351 np := fn.Dcl[0]
· · ·
423 var n int64
424 n, sig = parseNum(sig)
425▶ if n > 64 { // TODO: why 64?
426 // For big regions, call memequal.
427 c := ir.NewBasicLit(pos, types.Types[types.TUINTPTR], constant.MakeInt64(off))
· · ·
492 // Flush any pending test.
493 flushStrings()
494▶ // TODO: if the element comparison can't panic (no E or I), then
495 // maybe we don't need to do this flushStrings?
496 // On the other hand, maybe the unflushed string is not equal, but
· · ·
525 off += n * elemSize
526
527▶ // TODO: if the element comparison can't panic, but has strings
528 // in it, maybe we do a loop first without string contents and a
529 // second loop with string contents. There is no way to accomplish
+ 2 more matches in this file
40 ssaop.OpARM64MOVWUload: {4, ssaop.OpARM64LDPW},
41 ssaop.OpARM64MOVWload: {4, ssaop.OpARM64LDPSW},
42▶ // TODO: conceivably we could pair a signed and unsigned load
43 // if we knew the upper bits of one of them weren't being used.
44 ssaop.OpARM64FMOVDload: {8, ssaop.OpARM64FLDPD},
· · ·
65// This function is best-effort. The compiled function must
66// still work if offsetOk always returns true.
67▶// TODO: this is currently arm64-specific.
68func offsetOk(aux ssa.Aux, off, width int64) bool {
69 if true {
· · ·
89 // be a little bit longer. But it should never be more
90 // instructions.
91▶ // TODO: see if that longer critical path causes any
92 // regressions.
93 return true
· · ·
108 off += 128 // This should be multiple of 4, 8 and 16 for later off%width check
109 }
110▶ // TODO: figure out how often this helps vs. hurts.
111 }
112 switch width {
· · ·
225 for _, b := range f.Blocks {
226 if memoryBarrierTest(b) {
227▶ // TODO: Do we really need to skip write barrier test blocks?
228 // type T struct {
229 // a *byte
+ 1 more matches in this file
3// license that can be found in the LICENSE file.
4
5▶// TODO: live at start of block instead?
6
7package ssa
· · ·
321 forceLiveout = true
322 if spill := val.spill; spill != nil {
323▶ //TODO: remove? Subsumed by SpillUse?
324 s.values[spill.ID].addUseBlock(useBlock, true)
325 }
· · ·
341 }
342 }
343▶ // TODO: If we can help along the interference graph by calculating livein sets,
344 // we can do so trivially by turning this sparse set into an array of arrays
345 // and checking the top for the current value instead of inclusion in the sparse set.
· · ·
445 // the input value before we have a chance to load it.
446
447▶ // TODO(register args) this is apparently not wrong for register args -- is it necessary?
448 live.Add(v.ID)
449 }
40// Phi values are inserted, and all FwdRefs are changed to a Copy
41// of the appropriate phi or definition.
42▶// TODO: make this part of cmd/compile/internal/ssa somehow?
43func (s *state) insertPhis() {
44 if len(s.f.Blocks) <= smallBlocks {
· · ·
123 defs := make([][]*ssa.Block, len(vartypes))
124 for _, b := range s.f.Blocks {
125▶ for var_ := range s.defvars[b.ID] { // TODO: encode defvars some other way (explicit ops)? make defvars[n] a slice instead of a map.
126 if n, ok := s.varnum[var_]; ok {
127 defs[n] = append(defs[n], b)
· · ·
245 for _, e := range b.Succs {
246 c := e.Block()
247▶ // TODO: if the variable is dead at c, skip it.
248 if s.level[c.ID] > currentRootLevel {
249 // a D-edge, or an edge whose target is in currentRoot's subtree.
· · ·
413}
414
415▶// TODO: stop walking the iterated domininance frontier when
416// the variable is dead. Maybe detect that by checking if the
417// node we're on is reverse dominated by all the reads?
· · ·
419
420// copy of ../ssa/sparseset.go
421▶// TODO: move this file to ../ssa, then use sparseSet there.
422type sparseSet struct {
423 dense []ssa.ID
421 opregreg(s, x86.AXORL, x86.REG_DX, x86.REG_DX)
422
423▶ // TODO(khr): issue only the -1 fixup code we need.
424 // For instance, if only the quotient is used, no point in zeroing the remainder.
425
· · ·
660 // CMOV*PC TMP,DST
661 //
662▶ // TODO(rasky): we could generate:
663 // CMOV*NE DST,SRC
664 // CMOV*PC SRC,DST
· · ·
1105 if n != 0 {
1106 // use partially overlapped write.
1107▶ // TODO: n <= 8, use smaller write?
1108 zero16(off + n - 16)
1109 }
· · ·
1174 if n != 0 {
1175 // Use partially-overlapping write.
1176▶ // TODO: n <= 8, use smaller write?
1177 zero16(off + n - 16)
1178 }
· · ·
1203 if n != 0 {
1204 // use partially overlapped read/write.
1205▶ // TODO: use smaller operations when we can?
1206 move16(off + n - 16)
1207 }
+ 4 more matches in this file
142}
143
144▶// TODO: Delete when we switch to bisect-only.
145func toHashAndMask(s, varname string) hashAndMask {
146 l := len(s)
· · ·
176 }
177
178▶ // TODO: Delete remainder of function when we switch to bisect-only.
179 ss := strings.Split(s, "/")
180 // first remove any leading exclusions; these are preceded with "-"
· · ·
211}
212
213▶// TODO: Delete when we switch to bisect-only.
214func (d *HashDebug) excluded(hash uint64) bool {
215 for _, m := range d.excludes {
· · ·
221}
222
223▶// TODO: Delete when we switch to bisect-only.
224func hashString(hash uint64) string {
225 hstr := ""
· · ·
237}
238
239▶// TODO: Delete when we switch to bisect-only.
240func (d *HashDebug) match(hash uint64) *hashAndMask {
241 for i, m := range d.matches {
+ 3 more matches in this file
132 realName, realSize := hdr.Name, hdr.Size
133
134▶ // TODO(dsnet): Re-enable this when adding sparse support.
135 // See https://golang.org/issue/22735
136 /*
· · ·
214 }
215
216▶ // TODO(dsnet): Re-enable this when adding sparse support.
217 // See https://golang.org/issue/22735
218 /*
· · ·
256 f.formatNumeric(blk.toGNU().changeTime(), hdr.ChangeTime.Unix())
257 }
258▶ // TODO(dsnet): Re-enable this when adding sparse support.
259 // See https://golang.org/issue/22735
260 /*
· · ·
497// This always reads the last byte to ensure r is the right size.
498//
499▶// TODO(dsnet): Re-export this when adding sparse file support.
500// See https://golang.org/issue/22735
501func (tw *Writer) readFrom(r io.Reader) (int64, error) {
36 for _, b := range f.Blocks {
37 if len(b.Preds) != 2 || len(b.Values) == 0 {
38▶ // TODO: handle more than 2 predecessors, e.g. a || b || c.
39 continue
40 }
· · ·
201 for _, b := range f.Blocks {
202 if len(b.Preds) != 2 || len(b.Values) == 0 {
203▶ // TODO: handle more than 2 predecessors, e.g. a || b || c.
204 continue
205 }
· · ·
207 for _, v := range b.Values {
208 // find a phi value v = OpPhi (ConstBool [true]) (ConstBool [false]).
209▶ // TODO: v = OpPhi (ConstBool [true]) (Arg <bool> {value})
210 if v.Op != ssaop.OpPhi {
211 continue
126 TraceProfile string "help:\"write an execution trace to `file`\""
127 TrimPath string "help:\"remove `prefix` from recorded source file paths\""
128▶ WB bool "help:\"enable write barrier\"" // TODO: remove
129 PgoProfile string "help:\"read profile or pre-process profile from `file`\""
130 ErrorURL bool "help:\"print explanatory URL with error message if applicable\""
· · ·
476// are compatible with concurrent compilation.
477func concurrentFlagOk() bool {
478▶ // TODO(rsc): Many of these are fine. Remove them.
479 return Flag.Percent == 0 &&
480 Flag.E == 0 &&
· · ·
498 return false
499 }
500▶ // TODO: Test and delete this condition.
501 if buildcfg.Experiment.FieldTrack {
502 return false
· · ·
503 }
504▶ // TODO: fix races and enable the following flags
505 if Ctxt.Flag_dynlink || Flag.Race {
506 return false