Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 1 | package main |
| 2 | |
| 3 | import ( |
| 4 | "bytes" |
| 5 | "fmt" |
| 6 | "os" |
Shinichiro Hamaji | 11c4584 | 2015-05-27 19:02:07 +0900 | [diff] [blame] | 7 | "path/filepath" |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 8 | "regexp" |
| 9 | "runtime" |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 10 | "strings" |
| 11 | ) |
| 12 | |
| 13 | type NinjaGenerator struct { |
Shinichiro Hamaji | 30a02ad | 2015-05-29 14:56:43 +0900 | [diff] [blame] | 14 | f *os.File |
| 15 | nodes []*DepNode |
| 16 | vars Vars |
| 17 | exports map[string]bool |
| 18 | ex *Executor |
| 19 | ruleId int |
| 20 | done map[string]bool |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 21 | ccRe *regexp.Regexp |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 22 | } |
| 23 | |
| 24 | func NewNinjaGenerator(g *DepGraph) *NinjaGenerator { |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 25 | ccRe, err := regexp.Compile(`^prebuilts/(gcc|clang)/.*(gcc|g\+\+|clang|clang\+\+) .* -c `) |
| 26 | if err != nil { |
| 27 | panic(err) |
| 28 | } |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 29 | return &NinjaGenerator{ |
Shinichiro Hamaji | 30a02ad | 2015-05-29 14:56:43 +0900 | [diff] [blame] | 30 | nodes: g.nodes, |
| 31 | vars: g.vars, |
| 32 | exports: g.exports, |
| 33 | done: make(map[string]bool), |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 34 | ccRe: ccRe, |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 35 | } |
| 36 | } |
| 37 | |
Shinichiro Hamaji | 74ab4b6 | 2015-05-28 22:56:24 +0900 | [diff] [blame] | 38 | func getDepfileImpl(ss string) (string, error) { |
Shinichiro Hamaji | 6dca220 | 2015-05-27 18:00:34 +0900 | [diff] [blame] | 39 | tss := ss + " " |
| 40 | if !strings.Contains(tss, " -MD ") && !strings.Contains(tss, " -MMD ") { |
| 41 | return "", nil |
| 42 | } |
| 43 | |
| 44 | mfIndex := strings.Index(ss, " -MF ") |
| 45 | if mfIndex >= 0 { |
| 46 | mf := trimLeftSpace(ss[mfIndex+4:]) |
| 47 | if strings.Index(mf, " -MF ") >= 0 { |
| 48 | return "", fmt.Errorf("Multiple output file candidates in %s", ss) |
| 49 | } |
| 50 | mfEndIndex := strings.IndexAny(mf, " \t\n") |
| 51 | if mfEndIndex >= 0 { |
| 52 | mf = mf[:mfEndIndex] |
| 53 | } |
| 54 | |
Shinichiro Hamaji | 6dca220 | 2015-05-27 18:00:34 +0900 | [diff] [blame] | 55 | return mf, nil |
| 56 | } |
| 57 | |
| 58 | outIndex := strings.Index(ss, " -o ") |
| 59 | if outIndex < 0 { |
| 60 | return "", fmt.Errorf("Cannot find the depfile in %s", ss) |
| 61 | } |
| 62 | out := trimLeftSpace(ss[outIndex+4:]) |
| 63 | if strings.Index(out, " -o ") >= 0 { |
| 64 | return "", fmt.Errorf("Multiple output file candidates in %s", ss) |
| 65 | } |
| 66 | outEndIndex := strings.IndexAny(out, " \t\n") |
| 67 | if outEndIndex >= 0 { |
| 68 | out = out[:outEndIndex] |
| 69 | } |
| 70 | return stripExt(out) + ".d", nil |
| 71 | } |
| 72 | |
Shinichiro Hamaji | 74ab4b6 | 2015-05-28 22:56:24 +0900 | [diff] [blame] | 73 | func getDepfile(ss string) (string, error) { |
| 74 | // A hack for Android - llvm-rs-cc seems not to emit a dep file. |
| 75 | if strings.Contains(ss, "bin/llvm-rs-cc ") { |
| 76 | return "", nil |
| 77 | } |
| 78 | |
| 79 | r, err := getDepfileImpl(ss) |
Shinichiro Hamaji | b8224f3 | 2015-05-28 23:07:59 +0900 | [diff] [blame] | 80 | if r == "" || err != nil { |
Shinichiro Hamaji | 74ab4b6 | 2015-05-28 22:56:24 +0900 | [diff] [blame] | 81 | return r, err |
| 82 | } |
| 83 | |
| 84 | // A hack for Android to get .P files instead of .d. |
| 85 | p := stripExt(r) + ".P" |
| 86 | if strings.Contains(ss, p) { |
| 87 | return p, nil |
| 88 | } |
| 89 | |
| 90 | // A hack for Android. For .s files, GCC does not use |
| 91 | // C preprocessor, so it ignores -MF flag. |
| 92 | as := "/" + stripExt(filepath.Base(r)) + ".s" |
| 93 | if strings.Contains(ss, as) { |
| 94 | return "", nil |
| 95 | } |
| 96 | |
| 97 | return r, nil |
| 98 | } |
| 99 | |
Shinichiro Hamaji | 246cd23 | 2015-05-27 17:08:23 +0900 | [diff] [blame] | 100 | func stripShellComment(s string) string { |
| 101 | if strings.IndexByte(s, '#') < 0 { |
| 102 | // Fast path. |
| 103 | return s |
| 104 | } |
| 105 | var escape bool |
| 106 | var quote rune |
| 107 | for i, c := range s { |
| 108 | if quote > 0 { |
| 109 | if quote == c && (quote == '\'' || !escape) { |
| 110 | quote = 0 |
| 111 | } |
| 112 | } else if !escape { |
| 113 | if c == '#' { |
| 114 | return s[:i] |
| 115 | } else if c == '\'' || c == '"' || c == '`' { |
| 116 | quote = c |
| 117 | } |
| 118 | } |
| 119 | if escape { |
| 120 | escape = false |
| 121 | } else if c == '\\' { |
| 122 | escape = true |
| 123 | } else { |
| 124 | escape = false |
| 125 | } |
| 126 | } |
| 127 | return s |
| 128 | } |
| 129 | |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 130 | func (n *NinjaGenerator) genShellScript(runners []runner) (string, bool) { |
| 131 | useGomacc := false |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 132 | var buf bytes.Buffer |
Shinichiro Hamaji | a546779 | 2015-05-27 16:28:40 +0900 | [diff] [blame] | 133 | for i, r := range runners { |
| 134 | if i > 0 { |
| 135 | if runners[i-1].ignoreError { |
| 136 | buf.WriteString(" ; ") |
| 137 | } else { |
| 138 | buf.WriteString(" && ") |
| 139 | } |
| 140 | } |
Shinichiro Hamaji | 246cd23 | 2015-05-27 17:08:23 +0900 | [diff] [blame] | 141 | cmd := stripShellComment(r.cmd) |
| 142 | cmd = trimLeftSpace(cmd) |
Shinichiro Hamaji | a546779 | 2015-05-27 16:28:40 +0900 | [diff] [blame] | 143 | cmd = strings.Replace(cmd, "\\\n", " ", -1) |
| 144 | cmd = strings.TrimRight(cmd, " \t\n;") |
| 145 | cmd = strings.Replace(cmd, "$", "$$", -1) |
| 146 | cmd = strings.Replace(cmd, "\t", " ", -1) |
Shinichiro Hamaji | 501f68e | 2015-05-27 17:33:41 +0900 | [diff] [blame] | 147 | if cmd == "" { |
| 148 | cmd = "true" |
| 149 | } |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 150 | if gomaDir != "" && n.ccRe.MatchString(cmd) { |
| 151 | cmd = fmt.Sprintf("%s/gomacc %s", gomaDir, cmd) |
| 152 | useGomacc = true |
| 153 | } |
Shinichiro Hamaji | 13653b2 | 2015-05-28 22:45:12 +0900 | [diff] [blame] | 154 | |
| 155 | needsSubShell := i > 0 || len(runners) > 1 |
| 156 | if cmd[0] == '(' { |
| 157 | needsSubShell = false |
| 158 | } |
| 159 | |
| 160 | if needsSubShell { |
| 161 | buf.WriteByte('(') |
| 162 | } |
Shinichiro Hamaji | a546779 | 2015-05-27 16:28:40 +0900 | [diff] [blame] | 163 | buf.WriteString(cmd) |
| 164 | if i == len(runners)-1 && r.ignoreError { |
| 165 | buf.WriteString(" ; true") |
| 166 | } |
Shinichiro Hamaji | 13653b2 | 2015-05-28 22:45:12 +0900 | [diff] [blame] | 167 | if needsSubShell { |
| 168 | buf.WriteByte(')') |
| 169 | } |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 170 | } |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 171 | return buf.String(), gomaDir != "" && !useGomacc |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 172 | } |
| 173 | |
Shinichiro Hamaji | fd87216 | 2015-05-26 18:06:48 +0900 | [diff] [blame] | 174 | func (n *NinjaGenerator) genRuleName() string { |
| 175 | ruleName := fmt.Sprintf("rule%d", n.ruleId) |
| 176 | n.ruleId++ |
| 177 | return ruleName |
| 178 | } |
| 179 | |
| 180 | func (n *NinjaGenerator) emitBuild(output, rule, dep string) { |
Shinichiro Hamaji | ea2e0de | 2015-05-28 15:22:16 +0900 | [diff] [blame] | 181 | fmt.Fprintf(n.f, "build %s: %s%s\n", output, rule, dep) |
Shinichiro Hamaji | fd87216 | 2015-05-26 18:06:48 +0900 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | func getDepString(node *DepNode) string { |
| 185 | var deps []string |
| 186 | var orderOnlys []string |
| 187 | for _, d := range node.Deps { |
| 188 | if d.IsOrderOnly { |
| 189 | orderOnlys = append(orderOnlys, d.Output) |
| 190 | } else { |
| 191 | deps = append(deps, d.Output) |
| 192 | } |
| 193 | } |
| 194 | dep := "" |
| 195 | if len(deps) > 0 { |
| 196 | dep += fmt.Sprintf(" %s", strings.Join(deps, " ")) |
| 197 | } |
| 198 | if len(orderOnlys) > 0 { |
| 199 | dep += fmt.Sprintf(" || %s", strings.Join(orderOnlys, " ")) |
| 200 | } |
| 201 | return dep |
| 202 | } |
| 203 | |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 204 | func (n *NinjaGenerator) emitNode(node *DepNode) { |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 205 | if n.done[node.Output] { |
| 206 | return |
| 207 | } |
| 208 | n.done[node.Output] = true |
| 209 | |
Shinichiro Hamaji | fd4aaa0 | 2015-05-26 15:40:53 +0900 | [diff] [blame] | 210 | if len(node.Cmds) == 0 && len(node.Deps) == 0 && !node.IsPhony { |
| 211 | return |
| 212 | } |
| 213 | |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 214 | runners, _ := n.ex.createRunners(node, true) |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 215 | ruleName := "phony" |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 216 | useLocalPool := false |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 217 | if len(runners) > 0 { |
| 218 | ruleName = n.genRuleName() |
| 219 | fmt.Fprintf(n.f, "rule %s\n", ruleName) |
| 220 | fmt.Fprintf(n.f, " description = build $out\n") |
| 221 | |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 222 | ss, ulp := n.genShellScript(runners) |
| 223 | if ulp { |
| 224 | useLocalPool = true |
| 225 | } |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 226 | depfile, err := getDepfile(ss) |
Shinichiro Hamaji | 0ab9a2f | 2015-05-27 18:32:46 +0900 | [diff] [blame] | 227 | if err != nil { |
| 228 | panic(err) |
| 229 | } |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 230 | if depfile != "" { |
| 231 | fmt.Fprintf(n.f, " depfile = %s\n", depfile) |
| 232 | } |
Shinichiro Hamaji | a546779 | 2015-05-27 16:28:40 +0900 | [diff] [blame] | 233 | // It seems Linux is OK with ~130kB. |
| 234 | // TODO: Find this number automatically. |
| 235 | ArgLenLimit := 100 * 1000 |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 236 | if len(ss) > ArgLenLimit { |
Shinichiro Hamaji | a546779 | 2015-05-27 16:28:40 +0900 | [diff] [blame] | 237 | fmt.Fprintf(n.f, " rspfile = $out.rsp\n") |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 238 | fmt.Fprintf(n.f, " rspfile_content = %s\n", ss) |
| 239 | ss = "sh $out.rsp" |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 240 | } |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 241 | fmt.Fprintf(n.f, " command = %s\n", ss) |
| 242 | |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 243 | } |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 244 | n.emitBuild(node.Output, ruleName, getDepString(node)) |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 245 | if useLocalPool { |
| 246 | fmt.Fprintf(n.f, " pool = local_pool\n") |
| 247 | } |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 248 | |
| 249 | for _, d := range node.Deps { |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 250 | n.emitNode(d) |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 251 | } |
| 252 | } |
| 253 | |
Shinichiro Hamaji | 30a02ad | 2015-05-29 14:56:43 +0900 | [diff] [blame] | 254 | func (n *NinjaGenerator) generateShell() { |
| 255 | f, err := os.Create("ninja.sh") |
| 256 | if err != nil { |
| 257 | panic(err) |
| 258 | } |
| 259 | defer f.Close() |
| 260 | |
| 261 | ev := newEvaluator(n.vars) |
| 262 | shell := ev.EvaluateVar("SHELL") |
| 263 | if shell == "" { |
| 264 | shell = "/bin/sh" |
| 265 | } |
| 266 | fmt.Fprintf(f, "#!%s\n", shell) |
| 267 | for name, export := range n.exports { |
| 268 | if export { |
| 269 | fmt.Fprintf(f, "export %s=%s\n", name, ev.EvaluateVar(name)) |
| 270 | } else { |
| 271 | fmt.Fprintf(f, "unset %s\n", name) |
| 272 | } |
| 273 | } |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 274 | if gomaDir == "" { |
| 275 | fmt.Fprintf(f, "exec ninja\n") |
| 276 | } else { |
| 277 | fmt.Fprintf(f, "exec ninja -j300\n") |
| 278 | } |
Shinichiro Hamaji | 30a02ad | 2015-05-29 14:56:43 +0900 | [diff] [blame] | 279 | |
| 280 | err = f.Chmod(0755) |
| 281 | if err != nil { |
| 282 | panic(err) |
| 283 | } |
| 284 | } |
| 285 | |
| 286 | func (n *NinjaGenerator) generateNinja() { |
| 287 | f, err := os.Create("build.ninja") |
| 288 | if err != nil { |
| 289 | panic(err) |
| 290 | } |
| 291 | defer f.Close() |
| 292 | |
| 293 | n.f = f |
Shinichiro Hamaji | ea2e0de | 2015-05-28 15:22:16 +0900 | [diff] [blame] | 294 | fmt.Fprintf(n.f, "# Generated by kati\n") |
| 295 | fmt.Fprintf(n.f, "\n") |
| 296 | |
Shinichiro Hamaji | bcecb50 | 2015-06-04 16:20:25 +0900 | [diff] [blame^] | 297 | if gomaDir != "" { |
| 298 | fmt.Fprintf(n.f, "pool local_pool\n") |
| 299 | fmt.Fprintf(n.f, " depth = %d\n", runtime.NumCPU()) |
| 300 | } |
| 301 | |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 302 | n.ex = NewExecutor(n.vars) |
| 303 | for _, node := range n.nodes { |
Shinichiro Hamaji | bd59ebb | 2015-05-28 17:07:17 +0900 | [diff] [blame] | 304 | n.emitNode(node) |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 305 | } |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 306 | } |
| 307 | |
| 308 | func GenerateNinja(g *DepGraph) { |
Shinichiro Hamaji | 30a02ad | 2015-05-29 14:56:43 +0900 | [diff] [blame] | 309 | n := NewNinjaGenerator(g) |
| 310 | n.generateShell() |
| 311 | n.generateNinja() |
Shinichiro Hamaji | 6aa86ac | 2015-05-26 15:21:11 +0900 | [diff] [blame] | 312 | } |