feccee87a7
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@1674 6f19259b-4bc3-4df7-8a09-765794883524
550 lines
18 KiB
Java
550 lines
18 KiB
Java
/*
|
|
*
|
|
* Copyright 2002-2004 The Ant-Contrib project
|
|
*
|
|
* 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 net.sf.antcontrib.cpptasks;
|
|
import java.io.File;
|
|
import java.util.Enumeration;
|
|
import java.util.Vector;
|
|
|
|
import net.sf.antcontrib.cpptasks.compiler.CommandLineLinker;
|
|
import net.sf.antcontrib.cpptasks.compiler.LinkType;
|
|
import net.sf.antcontrib.cpptasks.compiler.Linker;
|
|
import net.sf.antcontrib.cpptasks.compiler.Processor;
|
|
import net.sf.antcontrib.cpptasks.compiler.ProcessorConfiguration;
|
|
import net.sf.antcontrib.cpptasks.gcc.GccLinker;
|
|
import net.sf.antcontrib.cpptasks.types.FlexLong;
|
|
import net.sf.antcontrib.cpptasks.types.LibrarySet;
|
|
import net.sf.antcontrib.cpptasks.types.LinkerArgument;
|
|
import net.sf.antcontrib.cpptasks.types.SystemLibrarySet;
|
|
|
|
import org.apache.tools.ant.BuildException;
|
|
import org.apache.tools.ant.Project;
|
|
import org.apache.tools.ant.types.FlexInteger;
|
|
/**
|
|
* A linker definition. linker elements may be placed either as children of a
|
|
* cc element or the project element. A linker element with an id attribute may
|
|
* be referenced by linker elements with refid or extends attributes.
|
|
*
|
|
* @author Adam Murdoch
|
|
* @author Curt Arnold
|
|
*/
|
|
public class LinkerDef extends ProcessorDef {
|
|
private long base;
|
|
private String entry;
|
|
private Boolean fixed;
|
|
private Boolean incremental;
|
|
private final Vector librarySets = new Vector();
|
|
private Boolean map;
|
|
private int stack;
|
|
private final Vector sysLibrarySets = new Vector();
|
|
private final Vector versionInfos = new Vector();
|
|
private Boolean defaultflag = new Boolean(true);
|
|
/**
|
|
* Default constructor
|
|
*
|
|
* @see java.lang.Object#Object()
|
|
*/
|
|
public LinkerDef() {
|
|
base = -1;
|
|
stack = -1;
|
|
}
|
|
private void addActiveLibrarySet(Project project, Vector libsets,
|
|
Vector srcSets) {
|
|
Enumeration srcenum = srcSets.elements();
|
|
while (srcenum.hasMoreElements()) {
|
|
LibrarySet set = (LibrarySet) srcenum.nextElement();
|
|
if (set.isActive(project)) {
|
|
libsets.addElement(set);
|
|
}
|
|
}
|
|
}
|
|
private void addActiveSystemLibrarySets(Project project, Vector libsets) {
|
|
addActiveLibrarySet(project, libsets, sysLibrarySets);
|
|
}
|
|
private void addActiveUserLibrarySets(Project project, Vector libsets) {
|
|
addActiveLibrarySet(project, libsets, librarySets);
|
|
}
|
|
/**
|
|
* Adds a linker command-line arg.
|
|
*/
|
|
public void addConfiguredLinkerArg(LinkerArgument arg) {
|
|
addConfiguredProcessorArg(arg);
|
|
}
|
|
/**
|
|
* Adds a compiler command-line arg.
|
|
*/
|
|
public void addConfiguredLinkerParam(LinkerParam param) {
|
|
if (isReference()) {
|
|
throw noChildrenAllowed();
|
|
}
|
|
addConfiguredProcessorParam(param);
|
|
}
|
|
/**
|
|
* Adds a system library set.
|
|
*/
|
|
public void addLibset(LibrarySet libset) {
|
|
if (isReference()) {
|
|
throw super.noChildrenAllowed();
|
|
}
|
|
if (libset == null) {
|
|
throw new NullPointerException("libset");
|
|
}
|
|
librarySets.addElement(libset);
|
|
}
|
|
/**
|
|
* Adds a system library set.
|
|
*/
|
|
public void addSyslibset(SystemLibrarySet libset) {
|
|
if (isReference()) {
|
|
throw super.noChildrenAllowed();
|
|
}
|
|
if (libset == null) {
|
|
throw new NullPointerException("libset");
|
|
}
|
|
sysLibrarySets.addElement(libset);
|
|
}
|
|
|
|
/**
|
|
* Adds desriptive version information to be included in the
|
|
* generated file. The first active version info block will
|
|
* be used.
|
|
*/
|
|
public void addConfiguredVersioninfo(VersionInfo newVersionInfo) {
|
|
if (isReference()) {
|
|
throw noChildrenAllowed();
|
|
}
|
|
newVersionInfo.setProject(this.getProject());
|
|
versionInfos.addElement(newVersionInfo);
|
|
}
|
|
|
|
public ProcessorConfiguration createConfiguration(CCTask task,
|
|
LinkType linkType, ProcessorDef baseDef, TargetDef targetPlatform) {
|
|
//
|
|
// must combine some local context (the linkType)
|
|
// with the referenced element
|
|
//
|
|
// get a pointer to the definition (either local or referenced)
|
|
ProcessorDef thisDef = this;
|
|
if (isReference()) {
|
|
thisDef = ((ProcessorDef) getCheckedRef(ProcessorDef.class,
|
|
"ProcessorDef"));
|
|
}
|
|
//
|
|
// find the appropriate processor (combines local linkType
|
|
// with possibly remote linker name)
|
|
Processor proc = getProcessor();
|
|
proc = proc.getLinker(linkType);
|
|
ProcessorDef[] defaultProviders = getDefaultProviders(baseDef);
|
|
return proc.createConfiguration(task, linkType, defaultProviders,
|
|
thisDef, targetPlatform);
|
|
}
|
|
public void execute() throws org.apache.tools.ant.BuildException {
|
|
throw new org.apache.tools.ant.BuildException(
|
|
"Not an actual task, but looks like one for documentation purposes");
|
|
}
|
|
/**
|
|
* Returns an array of active library sets for this linker definition.
|
|
*/
|
|
public LibrarySet[] getActiveLibrarySets(LinkerDef[] defaultProviders,
|
|
int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getActiveUserLibrarySets(defaultProviders, index);
|
|
}
|
|
Project p = getProject();
|
|
Vector libsets = new Vector();
|
|
for (int i = index; i < defaultProviders.length; i++) {
|
|
defaultProviders[i].addActiveUserLibrarySets(p, libsets);
|
|
defaultProviders[i].addActiveSystemLibrarySets(p, libsets);
|
|
}
|
|
addActiveUserLibrarySets(p, libsets);
|
|
addActiveSystemLibrarySets(p, libsets);
|
|
LibrarySet[] sets = new LibrarySet[libsets.size()];
|
|
libsets.copyInto(sets);
|
|
return sets;
|
|
}
|
|
/**
|
|
* Returns an array of active library sets for this linker definition.
|
|
*/
|
|
public LibrarySet[] getActiveSystemLibrarySets(
|
|
LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getActiveUserLibrarySets(defaultProviders, index);
|
|
}
|
|
Project p = getProject();
|
|
Vector libsets = new Vector();
|
|
for (int i = index; i < defaultProviders.length; i++) {
|
|
defaultProviders[i].addActiveSystemLibrarySets(p, libsets);
|
|
}
|
|
addActiveSystemLibrarySets(p, libsets);
|
|
LibrarySet[] sets = new LibrarySet[libsets.size()];
|
|
libsets.copyInto(sets);
|
|
return sets;
|
|
}
|
|
/**
|
|
* Returns an array of active library sets for this linker definition.
|
|
*/
|
|
public LibrarySet[] getActiveUserLibrarySets(LinkerDef[] defaultProviders,
|
|
int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getActiveUserLibrarySets(defaultProviders, index);
|
|
}
|
|
Project p = getProject();
|
|
Vector libsets = new Vector();
|
|
for (int i = index; i < defaultProviders.length; i++) {
|
|
defaultProviders[i].addActiveUserLibrarySets(p, libsets);
|
|
}
|
|
addActiveUserLibrarySets(p, libsets);
|
|
LibrarySet[] sets = new LibrarySet[libsets.size()];
|
|
libsets.copyInto(sets);
|
|
return sets;
|
|
}
|
|
public long getBase(LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getBase(defaultProviders, index);
|
|
}
|
|
if (base <= 0) {
|
|
if (defaultProviders != null && index < defaultProviders.length) {
|
|
return defaultProviders[index].getBase(defaultProviders,
|
|
index + 1);
|
|
}
|
|
}
|
|
return base;
|
|
}
|
|
public Boolean getFixed(LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getFixed(defaultProviders, index);
|
|
}
|
|
if (fixed == null) {
|
|
if (defaultProviders != null && index < defaultProviders.length) {
|
|
return defaultProviders[index].getFixed(defaultProviders,
|
|
index + 1);
|
|
}
|
|
}
|
|
return fixed;
|
|
}
|
|
public boolean getIncremental(LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getIncremental(defaultProviders, index);
|
|
}
|
|
if (incremental != null) {
|
|
return incremental.booleanValue();
|
|
}
|
|
if (defaultProviders != null && index < defaultProviders.length) {
|
|
return defaultProviders[index].getIncremental(defaultProviders, index + 1);
|
|
}
|
|
return false;
|
|
}
|
|
public boolean getMap(LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getMap(defaultProviders, index);
|
|
}
|
|
if (map != null) {
|
|
return map.booleanValue();
|
|
}
|
|
if (defaultProviders != null && index < defaultProviders.length) {
|
|
return defaultProviders[index].getMap(defaultProviders, index + 1);
|
|
}
|
|
return false;
|
|
}
|
|
public final Boolean getDefaultflag(LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class,
|
|
"LinkerDef")).getDefaultflag(defaultProviders, index);
|
|
}
|
|
return defaultflag;
|
|
}
|
|
public String getEntry(LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getEntry(defaultProviders, index);
|
|
}
|
|
if (entry != null) {
|
|
return entry;
|
|
}
|
|
if (defaultProviders != null && index < defaultProviders.length) {
|
|
return defaultProviders[index].getEntry(defaultProviders, index + 1);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public Processor getProcessor() {
|
|
Linker linker = (Linker) super.getProcessor();
|
|
if (linker == null) {
|
|
linker = GccLinker.getInstance();
|
|
}
|
|
if (getLibtool() && linker instanceof CommandLineLinker) {
|
|
CommandLineLinker cmdLineLinker = (CommandLineLinker) linker;
|
|
linker = cmdLineLinker.getLibtoolLinker();
|
|
}
|
|
return linker;
|
|
}
|
|
public int getStack(LinkerDef[] defaultProviders, int index) {
|
|
if (isReference()) {
|
|
return ((LinkerDef) getCheckedRef(LinkerDef.class, "LinkerDef"))
|
|
.getStack(defaultProviders, index);
|
|
}
|
|
if (stack < 0) {
|
|
if (defaultProviders != null && index < defaultProviders.length) {
|
|
return defaultProviders[index].getStack(defaultProviders,
|
|
index + 1);
|
|
}
|
|
}
|
|
return stack;
|
|
}
|
|
/**
|
|
* Sets the base address. May be specified in either decimal or hex.
|
|
*
|
|
* @param base
|
|
* base address
|
|
*
|
|
*/
|
|
public void setBase(FlexLong base) {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
this.base = base.longValue();
|
|
}
|
|
/**
|
|
* Sets the starting address.
|
|
*
|
|
* @param name
|
|
* function name
|
|
*/
|
|
public void setEntry(String entry) {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
this.entry = entry;
|
|
}
|
|
/**
|
|
* If true, marks the file to be loaded only at its preferred address.
|
|
*/
|
|
public void setFixed(boolean fixed) {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
this.fixed = booleanValueOf(fixed);
|
|
}
|
|
/**
|
|
* If true, allows incremental linking.
|
|
*
|
|
*/
|
|
public void setIncremental(boolean incremental) {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
this.incremental = booleanValueOf(incremental);
|
|
}
|
|
/**
|
|
* If set to true, a map file will be produced.
|
|
*/
|
|
public void setMap(boolean map) {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
this.map = booleanValueOf(map);
|
|
}
|
|
/**
|
|
* Sets linker type.
|
|
*
|
|
*
|
|
* <table width="100%" border="1"> <thead>Supported linkers </thead>
|
|
* <tr>
|
|
* <td>gcc</td>
|
|
* <td>Gcc Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>g++</td>
|
|
* <td>G++ Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>ld</td>
|
|
* <td>Ld Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>ar</td>
|
|
* <td>Gcc Librarian</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>msvc</td>
|
|
* <td>Microsoft Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>bcc</td>
|
|
* <td>Borland Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>df</td>
|
|
* <td>Compaq Visual Fortran Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>icl</td>
|
|
* <td>Intel Linker for Windows (IA-32)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>ecl</td>
|
|
* <td>Intel Linker for Windows (IA-64)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>icc</td>
|
|
* <td>Intel Linker for Linux (IA-32)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>ecc</td>
|
|
* <td>Intel Linker for Linux (IA-64)</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>CC</td>
|
|
* <td>Sun ONE Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>aCC</td>
|
|
* <td>HP aC++ Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>os390</td>
|
|
* <td>OS390 Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>os390batch</td>
|
|
* <td>OS390 Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>os400</td>
|
|
* <td>IccLinker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>sunc89</td>
|
|
* <td>C89 Linker</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>xlC</td>
|
|
* <td>VisualAge Linker</td>
|
|
* </tr>
|
|
* </table>
|
|
*
|
|
*/
|
|
public void setName(LinkerEnum name) throws BuildException {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
Linker linker = name.getLinker();
|
|
super.setProcessor(linker);
|
|
}
|
|
protected void setProcessor(Processor proc) throws BuildException {
|
|
Linker linker = null;
|
|
if (proc instanceof Linker) {
|
|
linker = (Linker) proc;
|
|
} else {
|
|
LinkType linkType = new LinkType();
|
|
linker = proc.getLinker(linkType);
|
|
}
|
|
super.setProcessor(linker);
|
|
}
|
|
/**
|
|
* Sets stack size in bytes.
|
|
*/
|
|
public void setStack(FlexInteger stack) {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
this.stack = stack.intValue();
|
|
}
|
|
public void visitSystemLibraries(Linker linker, FileVisitor libraryVisitor) {
|
|
Project p = getProject();
|
|
if (p == null) {
|
|
throw new java.lang.IllegalStateException("project must be set");
|
|
}
|
|
if (isReference()) {
|
|
LinkerDef master = ((LinkerDef) getCheckedRef(LinkerDef.class,
|
|
"Linker"));
|
|
master.visitSystemLibraries(linker, libraryVisitor);
|
|
} else {
|
|
//
|
|
// if this linker extends another,
|
|
// visit its libraries first
|
|
//
|
|
LinkerDef extendsDef = (LinkerDef) getExtends();
|
|
if (extendsDef != null) {
|
|
extendsDef.visitSystemLibraries(linker, libraryVisitor);
|
|
}
|
|
if (sysLibrarySets.size() > 0) {
|
|
File[] libpath = linker.getLibraryPath();
|
|
for (int i = 0; i < sysLibrarySets.size(); i++) {
|
|
LibrarySet set = (LibrarySet) sysLibrarySets.elementAt(i);
|
|
if (set.isActive(p)) {
|
|
set.visitLibraries(p, linker, libpath,
|
|
libraryVisitor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public void visitUserLibraries(Linker linker, FileVisitor libraryVisitor) {
|
|
Project p = getProject();
|
|
if (p == null) {
|
|
throw new java.lang.IllegalStateException("project must be set");
|
|
}
|
|
if (isReference()) {
|
|
LinkerDef master = ((LinkerDef) getCheckedRef(LinkerDef.class,
|
|
"Linker"));
|
|
master.visitUserLibraries(linker, libraryVisitor);
|
|
} else {
|
|
//
|
|
// if this linker extends another,
|
|
// visit its libraries first
|
|
//
|
|
LinkerDef extendsDef = (LinkerDef) getExtends();
|
|
if (extendsDef != null) {
|
|
extendsDef.visitUserLibraries(linker, libraryVisitor);
|
|
}
|
|
//
|
|
// visit the user libraries
|
|
//
|
|
if (librarySets.size() > 0) {
|
|
File[] libpath = linker.getLibraryPath();
|
|
for (int i = 0; i < librarySets.size(); i++) {
|
|
LibrarySet set = (LibrarySet) librarySets.elementAt(i);
|
|
if (set.isActive(p)) {
|
|
set.visitLibraries(p, linker, libpath,
|
|
libraryVisitor);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Enables or disables default flags.
|
|
*
|
|
* @param defaultflag
|
|
* if true, default flags will add to command line.
|
|
*
|
|
*/
|
|
public void setDefaultflag(boolean defaultflag) {
|
|
if (isReference()) {
|
|
throw tooManyAttributes();
|
|
}
|
|
this.defaultflag = booleanValueOf(defaultflag);
|
|
}
|
|
}
|