cli/compiler.go - mynewt-newtmgr - Git at Google

 /*
  Copyright 2015 Runtime Inc.
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 */

 package cli

 import (
 	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
 	"strings"
 )

 type Compiler struct {
 	ConfigPath   string
 	TargetName   string
 	BaseIncludes []string
 	ObjPathList  map[string]bool
 	LinkerScript string

 	Cflags string
 	Aflags string
 	Lflags string

 	ccPath                string
 	asPath                string
 	arPath                string
 	odPath                string
 	osPath                string
 	ocPath                string
 	ldFlags               string
 	ldResolveCircularDeps bool
 	ldMapFile             bool
 }

 func NewCompiler(ccPath string, cDef string, tName string, includes []string) (
 	*Compiler, error) {
 	c := &Compiler{
 		ConfigPath:   ccPath,
 		TargetName:   tName,
 		BaseIncludes: includes,
 	}

 	log.Printf("[INFO] Loading compiler %s, target %s, def %s", ccPath, tName, cDef)

 	err := c.ReadSettings(cDef)
 	if err != nil {
 		return nil, err
 	}

 	c.ObjPathList = make(map[string]bool)

 	return c, nil
 }

 func (c *Compiler) ReadSettings(cDef string) error {
 	v, err := ReadConfig(c.ConfigPath, "compiler")
 	if err != nil {
 		return err
 	}

 	c.ccPath = v.GetString("compiler.path.cc")
 	c.asPath = v.GetString("compiler.path.as")
 	c.arPath = v.GetString("compiler.path.archive")
 	c.odPath = v.GetString("compiler.path.objdump")
 	c.osPath = v.GetString("compiler.path.objsize")
 	c.ocPath = v.GetString("compiler.path.objcopy")

 	cflags := v.GetStringSlice("compiler.flags." + cDef)
 	for _, flag := range cflags {
 		if strings.HasPrefix(flag, "compiler.flags") {
 			c.Cflags += " " + strings.Trim(v.GetString(flag), "\n")
 		} else {
 			c.Cflags += " " + strings.Trim(flag, "\n")
 		}
 	}

 	c.ldFlags = v.GetString("compiler.ld.flags")
 	c.ldResolveCircularDeps = v.GetBool("compiler.ld.resolve_circular_deps")
 	c.ldMapFile = v.GetBool("compiler.ld.mapfile")

 	log.Printf("[INFO] ccPath = %s, arPath = %s, flags = %s", c.ccPath,
 		c.arPath, c.Cflags)

 	return nil
 }

 // file type 0 = cc, file type 1 = as
 func (c *Compiler) CompileFile(file string, compilerType int) error {
 	wd, _ := os.Getwd()
 	objDir := wd + "/obj/" + c.TargetName + "/"

 	if NodeNotExist(objDir) {
 		os.MkdirAll(objDir, 0755)
 	}

 	objFile := strings.TrimSuffix(file, filepath.Ext(file)) + ".o"

 	objPath := objDir + objFile
 	c.ObjPathList[objPath] = true

 	var cmd string

 	switch compilerType {
 	case 0:
 		cmd = c.ccPath
 	case 1:
 		cmd = c.asPath
 	default:
 		return NewNewtError("Unknown compiler type")
 	}

 	cmd += " -c " + "-o " + objPath + " " + file +
 		" " + c.Cflags + " -I" + strings.Join(c.BaseIncludes, " -I")

 	_, err := ShellCommand(cmd)
 	return err
 }

 func (c *Compiler) Compile(match string) error {
 	files, _ := filepath.Glob(match)

 	wd, err := os.Getwd()
 	if err != nil {
 		return err
 	}

 	log.Printf("[INFO] Compiling C (%s/%s) %s", wd, match, strings.Join(files, " "))

 	for _, file := range files {
 		err := c.CompileFile(file, 0)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }

 func (c *Compiler) CompileAs(match string) error {
 	files, _ := filepath.Glob(match)

 	wd, err := os.Getwd()
 	if err != nil {
 		return err
 	}

 	log.Printf("[INFO] Compiling assembly (%s/%s) %s", wd, match, strings.Join(files, " "))

 	for _, file := range files {
 		err := c.CompileFile(file, 1)
 		if err != nil {
 			return err
 		}
 	}

 	return nil
 }

 func (c *Compiler) RecursiveClean(path string, tName string) error {
 	// Find all the subdirectories of path that contain an "obj/" directory, and
 	// remove that directory either altogether, or just the arch specific directory.
 	dirList, err := ioutil.ReadDir(path)
 	if err != nil {
 		return NewNewtError(err.Error())
 	}

 	for _, node := range dirList {
 		if node.IsDir() {
 			if node.Name() == "obj" || node.Name() == "bin" {
 				if tName == "" {
 					os.RemoveAll(path + "/" + node.Name() + "/")
 				} else {
 					os.RemoveAll(path + "/" + node.Name() + "/" + tName + "/")
 				}
 			} else {
 				// recurse into the directory.
 				err = c.RecursiveClean(path+"/"+node.Name(), tName)
 				if err != nil {
 					return err
 				}
 			}
 		}
 	}

 	return nil
 }

 func (c *Compiler) processEntry(wd string, node os.FileInfo, match string, cType int,
 	ignDirs []string) error {
 	// check to see if we ignore this element
 	for _, entry := range ignDirs {
 		if entry == node.Name() {
 			return nil
 		}
 	}

 	// if not, recurse into the directory
 	os.Chdir(wd + "/" + node.Name())
 	return c.RecursiveCompile(match, cType, ignDirs)
 }

 func (c *Compiler) RecursiveCompile(match string, cType int, ignDirs []string) error {
 	// Get a list of files in the current directory, and if they are a directory,
 	// and that directory is not in the ignDirs variable, then recurse into that
 	// directory and compile the files in there
 	wd, err := os.Getwd()
 	if err != nil {
 		return NewNewtError(err.Error())
 	}

 	dirList, err := ioutil.ReadDir(wd)
 	if err != nil {
 		return NewNewtError(err.Error())
 	}

 	for _, node := range dirList {
 		if node.IsDir() {
 			err = c.processEntry(wd, node, match, cType, ignDirs)
 			if err != nil {
 				return err
 			}
 		}
 	}

 	os.Chdir(wd)

 	switch cType {
 	case 0:
 		return c.Compile(match)
 	case 1:
 		return c.CompileAs(match)
 	default:
 		return NewNewtError("Wrong compiler type specified to RecursiveCompile")
 	}
 }

 func (c *Compiler) getObjFiles(baseObjFiles string) string {
 	objList := baseObjFiles
 	for objName, _ := range c.ObjPathList {
 		objList += " " + objName
 	}
 	return objList
 }

 func (c *Compiler) CompileBinary(dstFile string, options map[string]bool,
 	objFiles string) error {
 	objList := c.getObjFiles(objFiles)

 	log.Printf("[INFO] Compiling Binary %s with object files %s", dstFile,
 		objList)

 	cmd := c.ccPath + " -o " + dstFile + " " + c.ldFlags + " " + c.Cflags
 	if c.ldResolveCircularDeps {
 		cmd += " -Wl,--start-group -lc " + objList + " -Wl,--end-group "
 	} else {
 		cmd += " " + objList
 	}

 	if c.LinkerScript != "" {
 		cmd += " -T " + c.LinkerScript
 	}
 	if checkBoolMap(options, "mapFile") {
 		cmd += " -Wl,-Map=" + dstFile + ".map"
 	}

 	_, err := ShellCommand(cmd)
 	if err != nil {
 		return err
 	}

 	if checkBoolMap(options, "listFile") {
 		listFile := dstFile + ".lst"
 		// if list file exists, remove it
 		if NodeExist(listFile) {
 			if err := os.RemoveAll(listFile); err != nil {
 				return err
 			}
 		}

 		cmd = c.odPath + " -wxdS " + dstFile + " >> " + listFile
 		_, err := ShellCommand(cmd)
 		if err != nil {
 			// XXX: gobjdump appears to always crash.  Until we get that sorted
 			// out, don't fail the link process if lst generation fails.
 			return nil
 		}

 		sects := []string{".text", ".rodata", ".data"}
 		for _, sect := range sects {
 			cmd = c.odPath + " -s -j " + sect + " " + dstFile + " >> " + listFile
 			ShellCommand(cmd)
 		}

 		cmd = c.osPath + " " + dstFile + " >> " + listFile
 	}

 	if checkBoolMap(options, "binFile") {
 		binFile := dstFile + ".bin"
 		cmd = c.ocPath + " -R .bss -R .bss.core -R .bss.core.nz -O binary " +
 			dstFile + " " + binFile
 		_, err := ShellCommand(cmd)
 		if err != nil {
 			return err
 		}
 	}

 	return nil
 }

 func (c *Compiler) CompileElf(binFile string, options map[string]bool,
 	objFiles string) error {
 	binFile += ".elf"
 	return c.CompileBinary(binFile, options, objFiles)
 }

 func (c *Compiler) CompileArchive(archiveFile string, objFiles string) error {
 	objList := c.getObjFiles(objFiles)

 	log.Printf("[INFO] Compiling archive %s with object files %s",
 		archiveFile, objList)

 	cmd := c.arPath + " rcs " + archiveFile + " " + objList

 	_, err := ShellCommand(cmd)
 	return err
 }
	/*
	Copyright 2015 Runtime Inc.
	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
	*/

	package cli

	import (
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strings"
	)

	type Compiler struct {
	ConfigPath string
	TargetName string
	BaseIncludes []string
	ObjPathList map[string]bool
	LinkerScript string

	Cflags string
	Aflags string
	Lflags string

	ccPath string
	asPath string
	arPath string
	odPath string
	osPath string
	ocPath string
	ldFlags string
	ldResolveCircularDeps bool
	ldMapFile bool
	}

	func NewCompiler(ccPath string, cDef string, tName string, includes []string) (
	*Compiler, error) {
	c := &Compiler{
	ConfigPath: ccPath,
	TargetName: tName,
	BaseIncludes: includes,
	}

	log.Printf("[INFO] Loading compiler %s, target %s, def %s", ccPath, tName, cDef)

	err := c.ReadSettings(cDef)
	if err != nil {
	return nil, err
	}

	c.ObjPathList = make(map[string]bool)

	return c, nil
	}

	func (c *Compiler) ReadSettings(cDef string) error {
	v, err := ReadConfig(c.ConfigPath, "compiler")
	if err != nil {
	return err
	}

	c.ccPath = v.GetString("compiler.path.cc")
	c.asPath = v.GetString("compiler.path.as")
	c.arPath = v.GetString("compiler.path.archive")
	c.odPath = v.GetString("compiler.path.objdump")
	c.osPath = v.GetString("compiler.path.objsize")
	c.ocPath = v.GetString("compiler.path.objcopy")

	cflags := v.GetStringSlice("compiler.flags." + cDef)
	for _, flag := range cflags {
	if strings.HasPrefix(flag, "compiler.flags") {
	c.Cflags += " " + strings.Trim(v.GetString(flag), "\n")
	} else {
	c.Cflags += " " + strings.Trim(flag, "\n")
	}
	}

	c.ldFlags = v.GetString("compiler.ld.flags")
	c.ldResolveCircularDeps = v.GetBool("compiler.ld.resolve_circular_deps")
	c.ldMapFile = v.GetBool("compiler.ld.mapfile")

	log.Printf("[INFO] ccPath = %s, arPath = %s, flags = %s", c.ccPath,
	c.arPath, c.Cflags)

	return nil
	}

	// file type 0 = cc, file type 1 = as
	func (c *Compiler) CompileFile(file string, compilerType int) error {
	wd, _ := os.Getwd()
	objDir := wd + "/obj/" + c.TargetName + "/"

	if NodeNotExist(objDir) {
	os.MkdirAll(objDir, 0755)
	}

	objFile := strings.TrimSuffix(file, filepath.Ext(file)) + ".o"

	objPath := objDir + objFile
	c.ObjPathList[objPath] = true

	var cmd string

	switch compilerType {
	case 0:
	cmd = c.ccPath
	case 1:
	cmd = c.asPath
	default:
	return NewNewtError("Unknown compiler type")
	}

	cmd += " -c " + "-o " + objPath + " " + file +
	" " + c.Cflags + " -I" + strings.Join(c.BaseIncludes, " -I")

	_, err := ShellCommand(cmd)
	return err
	}

	func (c *Compiler) Compile(match string) error {
	files, _ := filepath.Glob(match)

	wd, err := os.Getwd()
	if err != nil {
	return err
	}

	log.Printf("[INFO] Compiling C (%s/%s) %s", wd, match, strings.Join(files, " "))

	for _, file := range files {
	err := c.CompileFile(file, 0)
	if err != nil {
	return err
	}
	}
	return nil
	}

	func (c *Compiler) CompileAs(match string) error {
	files, _ := filepath.Glob(match)

	wd, err := os.Getwd()
	if err != nil {
	return err
	}

	log.Printf("[INFO] Compiling assembly (%s/%s) %s", wd, match, strings.Join(files, " "))

	for _, file := range files {
	err := c.CompileFile(file, 1)
	if err != nil {
	return err
	}
	}

	return nil
	}

	func (c *Compiler) RecursiveClean(path string, tName string) error {
	// Find all the subdirectories of path that contain an "obj/" directory, and
	// remove that directory either altogether, or just the arch specific directory.
	dirList, err := ioutil.ReadDir(path)
	if err != nil {
	return NewNewtError(err.Error())
	}

	for _, node := range dirList {
	if node.IsDir() {
	if node.Name() == "obj" \|\| node.Name() == "bin" {
	if tName == "" {
	os.RemoveAll(path + "/" + node.Name() + "/")
	} else {
	os.RemoveAll(path + "/" + node.Name() + "/" + tName + "/")
	}
	} else {
	// recurse into the directory.
	err = c.RecursiveClean(path+"/"+node.Name(), tName)
	if err != nil {
	return err
	}
	}
	}
	}

	return nil
	}

	func (c *Compiler) processEntry(wd string, node os.FileInfo, match string, cType int,
	ignDirs []string) error {
	// check to see if we ignore this element
	for _, entry := range ignDirs {
	if entry == node.Name() {
	return nil
	}
	}

	// if not, recurse into the directory
	os.Chdir(wd + "/" + node.Name())
	return c.RecursiveCompile(match, cType, ignDirs)
	}

	func (c *Compiler) RecursiveCompile(match string, cType int, ignDirs []string) error {
	// Get a list of files in the current directory, and if they are a directory,
	// and that directory is not in the ignDirs variable, then recurse into that
	// directory and compile the files in there
	wd, err := os.Getwd()
	if err != nil {
	return NewNewtError(err.Error())
	}

	dirList, err := ioutil.ReadDir(wd)
	if err != nil {
	return NewNewtError(err.Error())
	}

	for _, node := range dirList {
	if node.IsDir() {
	err = c.processEntry(wd, node, match, cType, ignDirs)
	if err != nil {
	return err
	}
	}
	}

	os.Chdir(wd)

	switch cType {
	case 0:
	return c.Compile(match)
	case 1:
	return c.CompileAs(match)
	default:
	return NewNewtError("Wrong compiler type specified to RecursiveCompile")
	}
	}

	func (c *Compiler) getObjFiles(baseObjFiles string) string {
	objList := baseObjFiles
	for objName, _ := range c.ObjPathList {
	objList += " " + objName
	}
	return objList
	}

	func (c *Compiler) CompileBinary(dstFile string, options map[string]bool,
	objFiles string) error {
	objList := c.getObjFiles(objFiles)

	log.Printf("[INFO] Compiling Binary %s with object files %s", dstFile,
	objList)

	cmd := c.ccPath + " -o " + dstFile + " " + c.ldFlags + " " + c.Cflags
	if c.ldResolveCircularDeps {
	cmd += " -Wl,--start-group -lc " + objList + " -Wl,--end-group "
	} else {
	cmd += " " + objList
	}

	if c.LinkerScript != "" {
	cmd += " -T " + c.LinkerScript
	}
	if checkBoolMap(options, "mapFile") {
	cmd += " -Wl,-Map=" + dstFile + ".map"
	}

	_, err := ShellCommand(cmd)
	if err != nil {
	return err
	}

	if checkBoolMap(options, "listFile") {
	listFile := dstFile + ".lst"
	// if list file exists, remove it
	if NodeExist(listFile) {
	if err := os.RemoveAll(listFile); err != nil {
	return err
	}
	}

	cmd = c.odPath + " -wxdS " + dstFile + " >> " + listFile
	_, err := ShellCommand(cmd)
	if err != nil {
	// XXX: gobjdump appears to always crash. Until we get that sorted
	// out, don't fail the link process if lst generation fails.
	return nil
	}

	sects := []string{".text", ".rodata", ".data"}
	for _, sect := range sects {
	cmd = c.odPath + " -s -j " + sect + " " + dstFile + " >> " + listFile
	ShellCommand(cmd)
	}

	cmd = c.osPath + " " + dstFile + " >> " + listFile
	}

	if checkBoolMap(options, "binFile") {
	binFile := dstFile + ".bin"
	cmd = c.ocPath + " -R .bss -R .bss.core -R .bss.core.nz -O binary " +
	dstFile + " " + binFile
	_, err := ShellCommand(cmd)
	if err != nil {
	return err
	}
	}

	return nil
	}

	func (c *Compiler) CompileElf(binFile string, options map[string]bool,
	objFiles string) error {
	binFile += ".elf"
	return c.CompileBinary(binFile, options, objFiles)
	}

	func (c *Compiler) CompileArchive(archiveFile string, objFiles string) error {
	objList := c.getObjFiles(objFiles)

	log.Printf("[INFO] Compiling archive %s with object files %s",
	archiveFile, objList)

	cmd := c.arPath + " rcs " + archiveFile + " " + objList

	_, err := ShellCommand(cmd)
	return err
	}