blob: dd128c3d669ef8378121b76eb8a23bc34acb9a5d [file] [log] [blame]
#!/usr/bin/python3
# Copyright (c) 2012 The Native Client Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# Global environment and expression parsing for the PNaCl driver
# This dictionary initializes a shell-like environment.
# Shell escaping and ${} substitution are provided.
# See "class Environment" defined later for the implementation.
from __future__ import print_function
from driver_log import Log, DriverExit
from shelltools import shell
import types
# TODO(crbug.com/1205898): Remove this once python3 is enabled.
try:
unicode
except NameError:
unicode = str
INITIAL_ENV = {
# Set by DriverMain
'DRIVER_PATH' : '', # Absolute path to this driver invocation
'DRIVER_BIN' : '', # PNaCl driver bin/ directory
'DRIVER_REV_FILE' : '${BASE}/REV',
'BASE_NACL' : '${@FindBaseNaCl}', # Absolute path of native_client/
'BASE_TOOLCHAIN' : '${@FindBaseToolchain}', # Absolute path to toolchain/OS_ARCH/
'BASE' : '${@FindBasePNaCl}', # Absolute path to PNaCl
'BUILD_OS' : '${@GetBuildOS}', # "linux", "nacl", "darwin"
# or "windows"
'BUILD_ARCH' : '${@GetBuildArch}', # "x86_64" or "i686" or "i386"
# Directories
'CLANG_VER' : '3.7.0', # Included in path to compiler-owned libs/headers
'BPREFIXES' : '', # Prefixes specified using the -B flag.
'BASE_LLVM' : '${@FindBaseHost:clang}',
'BASE_BINUTILS' : '${@FindBaseHost:arm-nacl-ar}',
'BASE_LIB_NATIVE' : '${BASE}/translator/',
'BASE_USR' : '${BASE}/le32-nacl',
'BASE_SDK' : '${BASE}/sdk',
'BASE_LIB' : '${BASE}/lib/clang/${CLANG_VER}/lib/le32-nacl',
'BASE_USR_ARCH' : '${BASE_USR_%BCLIB_ARCH%}',
'BASE_USR_X8632' : '${BASE}/i686_bc-nacl',
'BASE_USR_X8664' : '${BASE}/x86_64_bc-nacl',
'BASE_USR_ARM' : '${BASE}/arm_bc-nacl',
'BASE_LIB_ARCH' : '${BASE_LIB_%BCLIB_ARCH%}',
'BASE_LIB_X8632' : '${BASE}/lib/clang/${CLANG_VER}/lib/i686_bc-nacl',
'BASE_LIB_X8664' : '${BASE}/lib/clang/${CLANG_VER}/lib/x86_64_bc-nacl',
'BASE_LIB_ARM' : '${BASE}/lib/clang/${CLANG_VER}/lib/arm_bc-nacl',
'LIBS_NATIVE_ARCH' : '${LIBS_NATIVE_%ARCH%}',
'LIBS_NATIVE_ARM' : '${BASE_LIB_NATIVE}arm/lib',
'LIBS_NATIVE_ARM_NONSFI' : '${BASE_LIB_NATIVE}arm-nonsfi/lib',
'LIBS_NATIVE_X8632' : '${BASE_LIB_NATIVE}x86-32/lib',
'LIBS_NATIVE_X8632_NONSFI' : '${BASE_LIB_NATIVE}x86-32-nonsfi/lib',
'LIBS_NATIVE_X8664' : '${BASE_LIB_NATIVE}x86-64/lib',
'LIBS_NATIVE_MIPS32' : '${BASE_LIB_NATIVE}mips32/lib',
'BASE_LLVM_BIN' : '${BASE_LLVM}/bin',
'TRANSLATOR_BIN' :
'${BASE_TOOLCHAIN}/pnacl_translator/translator/${TRANSLATOR_ARCH}/bin',
# TODO(dschuff): Switch these directories to be triple-style arches,
# to match the main toolchain?
'TRANSLATOR_ARCH' : '${TRANSLATOR_ARCH_%ARCH%}',
'TRANSLATOR_ARCH_X8632' : 'x86-32',
'TRANSLATOR_ARCH_X8664' : 'x86-64',
'TRANSLATOR_ARCH_ARM' : 'arm',
'TRANSLATOR_ARCH_MIPS32': 'mips32',
'SCONS_OUT' : '${BASE_NACL}/scons-out',
# Driver settings
'ARCH' : '', # Target architecture, including optional
# suffixes such as '_NONSFI' or '_LINUX'.
'BASE_ARCH' : '', # Target architecture without any '_NONSFI' suffix.
# Derived from ARCH field.
'NONSFI_NACL' : '0', # Whether targeting Non-SFI Mode. Derived from
# ARCH field.
'BIAS' : 'NONE', # This can be 'NONE', 'ARM', 'MIPS32', 'X8632' or
# 'X8664'.
# When not set to none, this causes the front-end to
# act like a target-specific compiler. This bias is
# currently needed while compiling newlib,
# and some scons tests.
'DRY_RUN' : '0',
'SAVE_TEMPS' : '0', # Do not clean up temporary files
'SANDBOXED' : '0', # Use sandboxed toolchain for this arch. (main switch)
'HAS_FRONTEND': '', # Set by ReadConfig(). '1' if the driver install
# has support for front-end bitcode tools, or '0'
# if it only has the backend translator.
'USE_EMULATOR' : '0',
# Args passed from one driver invocation to another
'INHERITED_DRIVER_ARGS' : '',
'BCLIB_ARCH' : '',
# Logging settings
'LOG_VERBOSE' : '0', # Log to stdout (--pnacl-driver-verbose)
# Conventions
'SO_EXT' : '${SO_EXT_%BUILD_OS%}',
'SO_EXT_darwin' : '.dylib',
'SO_EXT_linux' : '.so',
'SO_EXT_nacl' : '.so',
'SO_EXT_windows' : '.dll',
'SO_DIR' : '${SO_DIR_%BUILD_OS%}',
'SO_DIR_darwin' : 'lib',
'SO_DIR_linux' : 'lib',
'SO_DIR_nacl' : 'lib',
'SO_DIR_windows' : 'bin', # On Windows, DLLs are placed in bin/
# because the dynamic loader searches %PATH%
'EXEC_EXT' : '${EXEC_EXT_%BUILD_OS%}',
'EXEC_EXT_darwin' : '',
'EXEC_EXT_linux' : '',
'EXEC_EXT_nacl' : '',
'EXEC_EXT_windows': '.exe',
'SCONS_OS' : '${SCONS_OS_%BUILD_OS%}',
'SCONS_OS_linux' : 'linux',
'SCONS_OS_nacl' : 'nacl',
'SCONS_OS_darwin' : 'mac',
'SCONS_OS_windows' : 'win',
# llvm goldplugin
'GOLD_PLUGIN_SO' : '${BASE_LLVM}/${SO_DIR}/LLVMgold${SO_EXT}',
'SCONS_STAGING' : '${SCONS_STAGING_%ARCH%}',
'SCONS_STAGING_X8632' : '${SCONS_OUT}/opt-${SCONS_OS}-x86-32/staging',
'SCONS_STAGING_X8664' : '${SCONS_OUT}/opt-${SCONS_OS}-x86-64/staging',
'SCONS_STAGING_ARM' : '${SCONS_OUT}/opt-${SCONS_OS}-arm/staging',
'SCONS_STAGING_MIPS32': '${SCONS_OUT}/opt-${SCONS_OS}-mips32/staging',
'SEL_LDR_PREFIX' : '${USE_EMULATOR ? ${EMULATOR}}',
# NOTE: -Q skips sel_ldr qualification tests, -c -c skips validation
'SEL_LDR_FLAGS' : '-B ${IRT_BLOB} ' +
'${USE_EMULATOR ? -Q -c -c}',
'IRT_STAGING' : '${IRT_STAGING_%ARCH%}',
'IRT_STAGING_X8632' : '${SCONS_OUT}/nacl_irt-x86-32/staging',
'IRT_STAGING_X8664' : '${SCONS_OUT}/nacl_irt-x86-64/staging',
'IRT_STAGING_ARM' : '${SCONS_OUT}/nacl_irt-arm/staging',
'IRT_STAGING_MIPS32' : '${SCONS_OUT}/nacl_irt-mips32/staging',
'IRT_BLOB' : '${IRT_STAGING}/irt_core.nexe',
'EMULATOR' : '${EMULATOR_%ARCH%}',
'EMULATOR_X8632' : '',
'EMULATOR_X8664' : '',
# NOTE: this is currently the only dependency on the arm trusted TC
'EMULATOR_ARM' :
'${BASE_NACL}/toolchain/linux_x86/arm_trusted/run_under_qemu_arm',
'EMULATOR_MIPS32' :
'${BASE_NACL}/toolchain/linux_x86/mips_trusted/run_under_qemu_mips32',
'SEL_LDR' : '${SCONS_STAGING}/sel_ldr${EXEC_EXT}',
'BOOTSTRAP_LDR' : '${SCONS_STAGING}/nacl_helper_bootstrap${EXEC_EXT}',
# sandboxed LLVM backend
'LLC_SB' : '${TRANSLATOR_BIN}/pnacl-llc.nexe',
# sandboxed linker (gold based)
'LD_SB' : '${TRANSLATOR_BIN}/ld.nexe',
# sandboxed Subzero backend
'PNACL_SZ_SB' : '${TRANSLATOR_BIN}/pnacl-sz.nexe',
# Bitcode LLVM tools
'CLANG' : '${BASE_LLVM_BIN}/clang${EXEC_EXT}',
# 'clang++' doesn't work on Windows (outside of Cygwin),
# because it is a symlink.
'CLANGXX' : '${BASE_LLVM_BIN}/clang${EXEC_EXT} --driver-mode=g++',
'LLVM_OPT' : '${BASE_LLVM_BIN}/opt${EXEC_EXT}',
'LLVM_DIS' : '${BASE_LLVM_BIN}/llvm-dis${EXEC_EXT}',
'LLVM_NM' : '${BASE_LLVM_BIN}/llvm-nm${EXEC_EXT}',
# llvm-as compiles llvm assembly (.ll) to bitcode (.bc/.po)
'LLVM_AS' : '${BASE_LLVM_BIN}/llvm-as${EXEC_EXT}',
'PNACL_ABICHECK': '${BASE_LLVM_BIN}/pnacl-abicheck${EXEC_EXT}',
'PNACL_COMPRESS': '${BASE_LLVM_BIN}/pnacl-bccompress${EXEC_EXT}',
# Native LLVM tools
'LLVM_PNACL_LLC': '${BASE_LLVM_BIN}/pnacl-llc${EXEC_EXT}',
'LLVM_PNACL_SZ': '${BASE_LLVM_BIN}/pnacl-sz${EXEC_EXT}',
# llvm-mc is llvm's native assembler
'LLVM_MC' : '${BASE_LLVM_BIN}/llvm-mc${EXEC_EXT}',
# Binutils
'BINUTILS_BASE' : '${BASE_BINUTILS}/bin/arm-nacl-',
'OBJDUMP' : '${BINUTILS_BASE}objdump${EXEC_EXT}',
'NM' : '${BINUTILS_BASE}nm${EXEC_EXT}',
'AR' : '${BINUTILS_BASE}ar${EXEC_EXT}',
'RANLIB' : '${BINUTILS_BASE}ranlib${EXEC_EXT}',
'READELF' : '${BINUTILS_BASE}readelf${EXEC_EXT}',
'STRIP' : '${BINUTILS_BASE}strip${EXEC_EXT}',
# linker (used for both bitcode and ELF linking)
'LD' : '${BINUTILS_BASE}ld.gold${EXEC_EXT}',
}
######################################################################
#
# Environment
#
######################################################################
def ParseError(s, leftpos, rightpos, msg):
Log.Error("Parse Error: %s", msg)
Log.Error(' ' + s)
Log.Error(' ' + (' '*leftpos) + ('^'*(rightpos - leftpos + 1)))
DriverExit(1)
# Find the leftmost position in "s" which begins a substring
# in "strset", starting at "pos".
# For example:
# FindFirst('hello world', 0, ['h','o']) = ('h', 0)
# FindFirst('hello world', 1, ['h','o']) = ('o', 4)
# FindFirst('hello world', 0, ['x']) = (None,11)
def FindFirst(s, pos, strset):
m = {}
for ss in strset:
m[s.find(ss, pos)] = ss
if -1 in m:
del m[-1]
if len(m) == 0:
return (None, len(s))
pos = min(m)
return (m[pos], pos)
class Environment(object):
functions = {}
@classmethod
def register(cls, func):
""" Register a function for use in the evaluator """
cls.functions[func.__name__] = func
return func
def __init__(self):
self.stack = []
self.reset()
def reset(self):
self.data = dict(INITIAL_ENV)
def update(self, extra):
self.data.update(extra)
def dump(self):
for (k,v) in self.data.items():
print('%s == %s' % (k, v))
def push(self):
self.stack.append(self.data)
self.data = dict(self.data) # Make a copy
def pop(self):
self.data = self.stack.pop()
def has(self, varname):
return varname in self.data
def getraw(self, varname):
return self.eval(self.data[varname])
# Evaluate a variable from the environment.
# Returns a list of terms.
def get(self, varname):
return shell.split(self.getraw(varname))
# Retrieve a variable from the environment which
# is a single term. Returns a string.
def getone(self, varname):
return shell.unescape(self.getraw(varname))
def getbool(self, varname):
return bool(int(self.getone(varname)))
def setbool(self, varname, val):
if val:
self.set(varname, '1')
else:
self.set(varname, '0')
# Set a variable in the environment without shell-escape
def setraw(self, varname, val):
self.data[varname] = val
# Set one or more variables using named arguments
def setmany(self, **kwargs):
for k,v in kwargs.items():
# TODO(crbug.com/1205898): Remove the unicode check once python3 is
# enabled.
if isinstance(v, str) or isinstance(v, unicode):
self.set(k, v)
elif isinstance(v, list):
self.set(k, *v)
else:
Log.Fatal('env.setmany given a non-string and non-list value')
def clear(self, varname):
self.data[varname] = ''
# Set a variable to one or more terms, applying shell-escape.
def set(self, varname, *vals):
self.clear(varname)
self.append(varname, *vals)
# Append one or more terms to a variable in the
# environment, applying shell-escape.
def append(self, varname, *vals):
escaped = [ shell.escape(v) for v in vals ]
if len(self.data[varname]) > 0:
self.data[varname] += ' '
self.data[varname] += ' '.join(escaped)
# Evaluate an expression s
def eval(self, s):
(result, i) = self.eval_expr(s, 0, [])
assert(i == len(s))
return result
######################################################################
# EXPRESSION EVALUATION CODE
# Context Free Grammar:
#
# str = empty | string literal
# expr = str | expr '$' '{' bracket_expr '}' expr
# bracket_expr = varname | boolexpr ? expr | boolexpr ? expr : expr | @call
# boolexpr = boolval | boolval '&&' boolexpr | boolval '||' boolexpr
# boolval = varname | !varname | #varname | !#varname | varname '==' str
# varname = str | varname '%' bracket_expr '%' varname
# call = func | func ':' arglist
# func = str
# arglist = empty | arg ':' arglist
#
# Do not call these functions outside of this class.
# The env.eval method is the external interface to the evaluator.
######################################################################
# Evaluate a string literal
def eval_str(self, s, pos, terminators):
(_,i) = FindFirst(s, pos, terminators)
return (s[pos:i], i)
# Evaluate %var% substitutions inside a variable name.
# Returns (the_actual_variable_name, endpos)
# Terminated by } character
def eval_varname(self, s, pos, terminators):
(_,i) = FindFirst(s, pos, ['%'] + terminators)
leftpart = s[pos:i].strip(' ')
if i == len(s) or s[i] in terminators:
return (leftpart, i)
(middlepart, j) = self.eval_bracket_expr(s, i+1, ['%'])
if j == len(s) or s[j] != '%':
ParseError(s, i, j, "Unterminated %")
(rightpart, k) = self.eval_varname(s, j+1, terminators)
fullname = leftpart + middlepart + rightpart
fullname = fullname.strip()
return (fullname, k)
# Absorb whitespace
def eval_whitespace(self, s, pos):
i = pos
while i < len(s) and s[i] == ' ':
i += 1
return (None, i)
def eval_bool_val(self, s, pos, terminators):
(_,i) = self.eval_whitespace(s, pos)
if s[i] == '!':
negated = True
i += 1
else:
negated = False
(_,i) = self.eval_whitespace(s, i)
if s[i] == '#':
uselen = True
i += 1
else:
uselen = False
(varname, j) = self.eval_varname(s, i, ['=']+terminators)
if j == len(s):
# This is an error condition one level up. Don't evaluate anything.
return (False, j)
if varname not in self.data:
ParseError(s, i, j, "Undefined variable '%s'" % varname)
vardata = self.data[varname]
contents = self.eval(vardata)
if s[j] == '=':
# String equality test
if j+1 == len(s) or s[j+1] != '=':
ParseError(s, j, j, "Unexpected token")
if uselen:
ParseError(s, j, j, "Cannot combine == and #")
(_,j) = self.eval_whitespace(s, j+2)
(literal_str,j) = self.eval_str(s, j, [' ']+terminators)
(_,j) = self.eval_whitespace(s, j)
if j == len(s):
return (False, j) # Error one level up
else:
literal_str = None
if uselen:
val = (len(contents) != 0)
elif literal_str is not None:
val = (contents == literal_str)
else:
if contents not in ('0','1'):
ParseError(s, j, j,
"%s evaluated to %s, which is not a boolean!" % (varname, contents))
val = bool(int(contents))
return (negated ^ val, j)
# Evaluate a boolexpr
def eval_bool_expr(self, s, pos, terminators):
(boolval1, i) = self.eval_bool_val(s, pos, ['&','|']+terminators)
if i == len(s):
# This is an error condition one level up. Don't evaluate anything.
return (False, i)
if s[i] in ('&','|'):
# and/or expression
if i+1 == len(s) or s[i+1] != s[i]:
ParseError(s, i, i, "Unexpected token")
is_and = (s[i] == '&')
(boolval2, j) = self.eval_bool_expr(s, i+2, terminators)
if j == len(s):
# This is an error condition one level up.
return (False, j)
if is_and:
return (boolval1 and boolval2, j)
else:
return (boolval1 or boolval2, j)
return (boolval1, i)
# Evaluate the inside of a ${} or %%.
# Returns the (the_evaluated_string, endpos)
def eval_bracket_expr(self, s, pos, terminators):
(_,pos) = self.eval_whitespace(s, pos)
if s[pos] == '@':
# Function call: ${@func}
# or possibly : ${@func:arg1:arg2...}
(_,i) = FindFirst(s, pos, [':']+terminators)
if i == len(s):
return ('', i) # Error one level up
funcname = s[pos+1:i]
if s[i] != ':':
j = i
args = []
else:
(_,j) = FindFirst(s, i+1, terminators)
if j == len(s):
return ('', j) # Error one level up
args = s[i+1:j].split(':')
val = self.functions[funcname](*args)
contents = self.eval(val)
return (contents, j)
(m,_) = FindFirst(s, pos, ['?']+terminators)
if m != '?':
# Regular variable substitution
(varname,i) = self.eval_varname(s, pos, terminators)
if len(s) == i:
return ('', i) # Error one level up
if varname not in self.data:
ParseError(s, pos, i, "Undefined variable '%s'" % varname)
vardata = self.data[varname]
contents = self.eval(vardata)
return (contents, i)
else:
# Ternary Mode
(is_cond_true,i) = self.eval_bool_expr(s, pos, ['?']+terminators)
assert(i < len(s) and s[i] == '?')
(if_true_expr, j) = self.eval_expr(s, i+1, [' : ']+terminators)
if j == len(s):
return ('', j) # Error one level up
if s[j:j+3] == ' : ':
(if_false_expr,j) = self.eval_expr(s, j+3, terminators)
if j == len(s):
# This is an error condition one level up.
return ('', j)
else:
if_false_expr = ''
if is_cond_true:
contents = if_true_expr.strip()
else:
contents = if_false_expr.strip()
return (contents, j)
# Evaluate an expression with ${} in string s, starting at pos.
# Returns (the_evaluated_expression, endpos)
def eval_expr(self, s, pos, terminators):
(m,i) = FindFirst(s, pos, ['${'] + terminators)
leftpart = s[pos:i]
if i == len(s) or m in terminators:
return (leftpart, i)
(middlepart, j) = self.eval_bracket_expr(s, i+2, ['}'])
if j == len(s) or s[j] != '}':
ParseError(s, i, j, 'Unterminated ${')
(rightpart, k) = self.eval_expr(s, j+1, terminators)
return (leftpart + middlepart + rightpart, k)
env = Environment()
def override_env(meth_name, func):
"""Override a method in the global |env|, given the method name
and the new function.
"""
global env
setattr(env, meth_name, types.MethodType(func, env))