1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

# Copyright (C) 2017: Paul Beltyukov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

    27

    28

import os

    29

import re

    30

import operator

    31

import hashlib

    32

import subprocess

    33

import shlex

    34

from functools import reduce

    35

from util.ProcessLogger import ProcessLogger

    36

    37

    38

includes_re = re.compile(r'\s*#include\s*["<]([^">]*)[">].*')

    39

    40

    41

class toolchain_gcc(object):

    42

    """

    43

    This abstract class contains GCC specific code.

    44

    It cannot be used as this and should be inherited in a target specific

    45

    class such as target_linux or target_win32

    46

    """

    47

    def __init__(self, CTRInstance):

    48

        self.CTRInstance = CTRInstance

    49

        self.buildpath = None

    50

        self.SetBuildPath(self.CTRInstance._getBuildPath())

    51

    52

    def getBuilderCFLAGS(self):

    53

        """

    54

        Returns list of builder specific CFLAGS

    55

        """

    56

        cflags = [self.CTRInstance.GetTarget().getcontent().getCFLAGS()]

    57

        if "CFLAGS" in os.environ:

    58

            cflags.append(os.environ["CFLAGS"])

    59

        if "SYSROOT" in os.environ:

    60

            cflags.append("--sysroot="+os.environ["SYSROOT"])

    61

        return cflags

    62

    63

    def getBuilderLDFLAGS(self):

    64

        """

    65

        Returns list of builder specific LDFLAGS

    66

        """

    67

        ldflags = self.CTRInstance.LDFLAGS + \

    68

            [self.CTRInstance.GetTarget().getcontent().getLDFLAGS()]

    69

        if "LDLAGS" in os.environ:

    70

            ldflags.append(os.environ["LDLAGS"])

    71

        if "SYSROOT" in os.environ:

    72

            ldflags.append("--sysroot="+os.environ["SYSROOT"])

    73

        return ldflags

    74

    75

    def getCompiler(self):

    76

        """

    77

        Returns compiler

    78

        """

    79

        return self.CTRInstance.GetTarget().getcontent().getCompiler()

    80

    81

    def getLinker(self):

    82

        """

    83

        Returns linker

    84

        """

    85

        return self.CTRInstance.GetTarget().getcontent().getLinker()

    86

    87

    def GetBinaryPath(self):

    88

        return self.bin_path

    89

    90

    def _GetMD5FileName(self):

    91

        return os.path.join(self.buildpath, "lastbuildPLC.md5")

    92

    93

    def ResetBinaryMD5(self):

    94

        self.md5key = None

    95

        try:

    96

            os.remove(self._GetMD5FileName())

    97

        except Exception:

    98

            pass

    99

   100

    def GetBinaryMD5(self):

   101

        if self.md5key is not None:

   102

            return self.md5key

   103

        else:

   104

            try:

   105

                return open(self._GetMD5FileName(), "r").read()

   106

            except Exception:

   107

                return None

   108

   109

    def SetBuildPath(self, buildpath):

   110

        if self.buildpath != buildpath:

   111

            self.buildpath = buildpath

   112

            self.bin = self.CTRInstance.GetProjectName() + self.extension

   113

            self.bin_path = os.path.join(self.buildpath, self.bin)

   114

            self.md5key = None

   115

            self.srcmd5 = {}

   116

   117

    def append_cfile_deps(self, src, deps):

   118

        for l in src.splitlines():

   119

            res = includes_re.match(l)

   120

            if res is not None:

   121

                depfn = res.groups()[0]

   122

                if os.path.exists(os.path.join(self.buildpath, depfn)):

   123

                    deps.append(depfn)

   124

   125

    def concat_deps(self, bn):

   126

        # read source

   127

        src = open(os.path.join(self.buildpath, bn), "r").read()

   128

        # update direct dependencies

   129

        deps = []

   130

        self.append_cfile_deps(src, deps)

   131

        # recurse through deps

   132

        # TODO detect cicular deps.

   133

        return reduce(operator.concat, list(map(self.concat_deps, deps)), src)

   134

   135

    def check_and_update_hash_and_deps(self, bn):

   136

        # Get latest computed hash and deps

   137

        oldhash, deps = self.srcmd5.get(bn, (None, []))

   138

        # read source

   139

        src = open(os.path.join(self.buildpath, bn)).read()

   140

        # compute new hash

   141

        newhash = hashlib.md5(src.encode()).hexdigest()

   142

        # compare

   143

        match = (oldhash == newhash)

   144

        if not match:

   145

            # file have changed

   146

            # update direct dependencies

   147

            deps = []

   148

            self.append_cfile_deps(src, deps)

   149

            # store that hashand deps

   150

            self.srcmd5[bn] = (newhash, deps)

   151

        # recurse through deps

   152

        # TODO detect cicular deps.

   153

        return reduce(operator.and_, list(map(self.check_and_update_hash_and_deps, deps)), match)

   154

   155

    def calc_source_md5(self):

   156

        wholesrcdata = ""

   157

        for _Location, CFilesAndCFLAGS, _DoCalls in self.CTRInstance.LocationCFilesAndCFLAGS:

   158

            # Get CFiles list to give it to makefile

   159

            for CFile, _CFLAGS in CFilesAndCFLAGS:

   160

                CFileName = os.path.basename(CFile)

   161

                wholesrcdata += self.concat_deps(CFileName)

   162

        return hashlib.md5(wholesrcdata).hexdigest()

   163

   164

    def build(self):

   165

        # Retrieve compiler and linker

   166

        self.compiler = self.getCompiler()

   167

        self.linker = self.getLinker()

   168

   169

        Builder_CFLAGS_str = ' '.join(self.getBuilderCFLAGS())

   170

        Builder_LDFLAGS_str = ' '.join(self.getBuilderLDFLAGS())

   171

   172

        Builder_CFLAGS = shlex.split(Builder_CFLAGS_str)

   173

        Builder_LDFLAGS = shlex.split(Builder_LDFLAGS_str)

   174

   175

        pattern = "{SYSROOT}"

   176

        if pattern in Builder_CFLAGS_str or pattern in Builder_LDFLAGS_str:

   177

            try:

   178

                sysrootb = subprocess.check_output(["arm-unknown-linux-gnueabihf-gcc","-print-sysroot"])

   179

            except subprocess.CalledProcessError:

   180

                self.CTRInstance.logger.write("GCC failed with -print-sysroot\n")

   181

                return False

   182

            except FileNotFoundError:

   183

                self.CTRInstance.logger.write("GCC not found\n")

   184

                return False

   185

   186

            sysroot = sysrootb.decode().strip()

   187

   188

            replace_sysroot = lambda l:list(map(lambda s:s.replace(pattern, sysroot), l))

   189

            Builder_CFLAGS = replace_sysroot(Builder_CFLAGS)

   190

            Builder_LDFLAGS = replace_sysroot(Builder_LDFLAGS)

   191

   192

        # ----------------- GENERATE OBJECT FILES ------------------------

   193

        obns = []

   194

        objs = []

   195

        relink = not os.path.exists(self.bin_path)

   196

        for Location, CFilesAndCFLAGS, _DoCalls in self.CTRInstance.LocationCFilesAndCFLAGS:

   197

            if CFilesAndCFLAGS:

   198

                if Location:

   199

                    self.CTRInstance.logger.write(".".join(map(str, Location))+" :\n")

   200

                else:

   201

                    self.CTRInstance.logger.write(_("PLC :\n"))

   202

   203

            for CFile, CFLAGS in CFilesAndCFLAGS:

   204

                if CFile.endswith(".c"):

   205

                    bn = os.path.basename(CFile)

   206

                    obn = os.path.splitext(bn)[0]+".o"

   207

                    objectfilename = os.path.splitext(CFile)[0]+".o"

   208

   209

                    match = self.check_and_update_hash_and_deps(bn)

   210

   211

                    if match:

   212

                        self.CTRInstance.logger.write("   [pass]  "+bn+" -> "+obn+"\n")

   213

                    else:

   214

                        relink = True

   215

   216

                        self.CTRInstance.logger.write("   [CC]  "+bn+" -> "+obn+"\n")

   217

   218

                        status, _result, _err_result = ProcessLogger(

   219

                            self.CTRInstance.logger,

   220

                            [self.compiler,

   221

                             "-c", CFile,

   222

                             "-o", objectfilename,

   223

                             "-O2"]

   224

                            + Builder_CFLAGS

   225

                            + shlex.split(CFLAGS)

   226

                        ).spin()

   227

   228

                        if status:

   229

                            self.srcmd5.pop(bn)

   230

                            self.CTRInstance.logger.write_error(_("C compilation of %s failed.\n") % bn)

   231

                            return False

   232

                    obns.append(obn)

   233

                    objs.append(objectfilename)

   234

                elif CFile.endswith(".o"):

   235

                    obns.append(os.path.basename(CFile))

   236

                    objs.append(CFile)

   237

   238

        # ---------------- GENERATE OUTPUT FILE --------------------------

   239

        # Link all the object files into one binary file

   240

        self.CTRInstance.logger.write(_("Linking :\n"))

   241

        if relink:

   242

   243

            self.CTRInstance.logger.write("   [CC]  " + ' '.join(obns)+" -> " + self.bin + "\n")

   244

   245

            status, _result, _err_result = ProcessLogger(

   246

                self.CTRInstance.logger,

   247

                [self.linker] + objs

   248

                + ["-o", self.bin_path]

   249

                + Builder_LDFLAGS

   250

            ).spin()

   251

   252

            if status:

   253

                return False

   254

   255

        else:

   256

            self.CTRInstance.logger.write("   [pass]  " + ' '.join(obns)+" -> " + self.bin + "\n")

   257

   258

        # Calculate md5 key and get data for the new created PLC

   259

        self.md5key = hashlib.md5(open(self.bin_path, "rb").read()).hexdigest()

   260

   261

        # Store new PLC filename based on md5 key

   262

        f = open(self._GetMD5FileName(), "w")

   263

        f.write(self.md5key)

   264

        f.close()

   265

   266

        return True