tree 4144adb7968d13a720bc078764657312be93b423
parent c38cf58d38e6b9572582fe96c9e725faf6d357a2
author David Ng <dave@codeaurora.org> 1556345314 -0700
committer David Ng <dave@codeaurora.org> 1556347442 -0700

makefile: kona: remove make export <all variables> instances

Replace all kernel make export <all variables> instances with
export of specific variables.  Depending on existing build
environment, exporting all as environment variables and
interaction with existing environment variable expansions
can lead to undefined behavior.

TODO:  This change is restricted to kona flow to narrow impact.
All remaining export <all variables> need to be evaluated and
fixed similarly via subsequent changes.

Change-Id: I9114b88f7511d1b3f9b496b76fb6da9db97772b8
Signed-off-by: David Ng <dave@codeaurora.org>
