forked from ~ljy/RK356X_SDK_RELEASE

hc
2023-02-17 557c24d082b6ecb9bfe5407b77ae43fa7650a5dc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
From 9ba507e076c744f4d394418e4a849e68cd426a4a Mon Sep 17 00:00:00 2001
From: Alex Kube <alexander.j.kube@gmail.com>
Date: Wed, 23 Oct 2019 21:18:56 +0430
Subject: [PATCH 7/9] cmd/go: make GOROOT precious by default
 
Upstream-Status: Inappropriate [OE specific]
 
The go build tool normally rebuilds whatever it detects is
stale.  This can be a problem when GOROOT is intended to
be read-only and the go runtime has been built as a shared
library, since we don't want every application to be rebuilding
the shared runtime - particularly in cross-build/packaging
setups, since that would lead to 'abi mismatch' runtime errors.
 
This patch prevents the install and linkshared actions from
installing to GOROOT unless overridden with the GOROOT_OVERRIDE
environment variable.
 
Adapted to Go 1.13 from patches originally submitted to
the meta/recipes-devtools/go tree by
Matt Madison <matt@madison.systems>.
 
Signed-off-by: Alexander J Kube <alexander.j.kube@gmail.com>
---
 src/cmd/go/internal/work/action.go |  3 +++
 src/cmd/go/internal/work/build.go  |  6 ++++++
 src/cmd/go/internal/work/exec.go   | 25 +++++++++++++++++++++++++
 3 files changed, 34 insertions(+)
 
--- a/src/cmd/go/internal/work/action.go
+++ b/src/cmd/go/internal/work/action.go
@@ -670,6 +670,9 @@ func (b *Builder) addTransitiveLinkDeps(
             if p1 == nil || p1.Shlib == "" || haveShlib[filepath.Base(p1.Shlib)] {
                 continue
             }
+            if goRootPrecious && (p1.Standard || p1.Goroot) {
+                continue
+            }
             haveShlib[filepath.Base(p1.Shlib)] = true
             // TODO(rsc): The use of ModeInstall here is suspect, but if we only do ModeBuild,
             // we'll end up building an overall library or executable that depends at runtime
--- a/src/cmd/go/internal/work/build.go
+++ b/src/cmd/go/internal/work/build.go
@@ -167,6 +167,8 @@ See also: go install, go get, go clean.
 
 const concurrentGCBackendCompilationEnabledByDefault = true
 
+var goRootPrecious bool = true
+
 func init() {
     // break init cycle
     CmdBuild.Run = runBuild
@@ -179,6 +181,10 @@ func init() {
 
     AddBuildFlags(CmdBuild, DefaultBuildFlags)
     AddBuildFlags(CmdInstall, DefaultBuildFlags)
+
+    if x := os.Getenv("GOROOT_OVERRIDE"); x != "" {
+        goRootPrecious = false
+    }
 }
 
 // Note that flags consulted by other parts of the code
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -468,6 +468,23 @@ func (b *Builder) build(a *Action) (err
         return errors.New("binary-only packages are no longer supported")
     }
 
+    if goRootPrecious && (a.Package.Standard || a.Package.Goroot) {
+        _, err := os.Stat(a.Package.Target)
+        if err == nil {
+            a.built = a.Package.Target
+            a.Target = a.Package.Target
+            a.buildID = b.fileHash(a.Package.Target)
+            a.Package.Stale = false
+            a.Package.StaleReason = "GOROOT-resident package"
+            return nil
+        }
+        a.Package.Stale = true
+        a.Package.StaleReason = "missing or invalid GOROOT-resident package"
+        if b.IsCmdList {
+            return nil
+        }
+    }
+
     if err := b.Mkdir(a.Objdir); err != nil {
         return err
     }
@@ -1520,6 +1537,14 @@ func BuildInstallFunc(b *Builder, a *Act
         return err
     }
 
+    if goRootPrecious && a.Package != nil {
+        p := a.Package
+        if p.Standard || p.Goroot {
+            err := fmt.Errorf("attempting to install package %s into read-only GOROOT", p.ImportPath)
+            return err
+        }
+    }
+
     if err := b.Mkdir(a.Objdir); err != nil {
         return err
     }