pgenutil.pas:
* parse_generic_specialization_types_internal: ignore the parasymtable of procvars (as before the addition of generic routines) and instead use the type's hierarchy name
* generate_specialization_phase2: specialize types of procvars into the parameter symtable as they don't have a local one
+ added test
git-svn-id: trunk@33544 -
whether a multiplication needs to be signed or unsigned (can be different
in case of a 32x32->64 multiplication) (mantis #30035)
git-svn-id: trunk@33539 -
--- Reverse-merging r33524 into '.':
U compiler\i386\popt386.pas
U compiler\x86\cgx86.pas
--- Recording mergeinfo for reverse merge of r33524 into '.':
U .
git-svn-id: trunk@33527 -
optimizer which cannot do this properly due to missing information about flags. By doing
so the size of the compiler executable gets reduced by ~1 %
git-svn-id: trunk@33524 -
pkgutil.pas, createimportlibfromexternals:
* findpackagewithsym: ignore other (weak) external symbols
........
pkgutil.pas, createimportlibfromexternals:
* import_proc_symbol: at least import the mangled name if there is no alias available
........
pkgutil.pas:
* exportabstractrecordsymproc & insert_export: don't try to export a typedef if it doesn't belong to the current symtable, happens for cross unit type aliases
........
psub.pas:
* read_proc: extract the code that creates an import library entry into its own function import_external_proc so that the same code can be used from other locations as well
........
Correctly handle external functions that are used from other units.
pkgutil.pas, createimportlibfromexternals:
* processasmsyms: also check the import name when checking for duplicates (just for safety, the cache check should have caught these already)
* processimportedsyms: if we have a routine imported from a library of whihc the symbol resides in a unit loaded from a package we need to import the routine ourselves instead of trying to import it from the package; also add an entry in the cache to speed up finding it again in processasmsyms()
........
git-svn-id: trunk@33519 -
Report a warning if a unit is used from an indirectly used package. We are doing this only for the units used in contained units though as in the "contains" section there can't be such units anyway (and just checking all loaded units would lead to false positives).
pkgutil.pas:
+ new procedure check_for_indirect_package_usages() which walks a TLinkedList of used units and warns on every unit that is from an indirectly imported package
pmodules.pas, proc_package:
* when checking all loaded units whether they are from a package or not also check for indirect package usages using the new procedure
........
pkgutil.pas, exportprocsym:
* use a temporary variable for the procdef
* restructure the if-expression a bit to make it better readable
........
pmodules.pas, finish_unit:
* also release the generated proc symbol if the init function isn't needed
........
pkgutil.pas, add_package_libs:
* fix exit condition (on Linux it probably worked by accident :/ )
........
git-svn-id: trunk@33518 -
Keep track whether a package was added directly through a requires section (or the command line) or indirectly.
fpkg.pas, tpackageentry:
+ new field "direct"
pkgutil.pas:
+ add_package: new parameter "direct" which sets the "direct" field of the new package entry
options.pas:
* TOption.interpret_option & read_arguments: adjust call to add_package()
pmodules.pas:
* proc_package: adjust call to add_package()
........
Also load all packages that are required by packages, but that are not part of the directly used packages.
pkgutil.pas, load_packages:
* check the list of required packages for packages that are not yet part of the package list and add these as indirect packages
* establish the links to loaded packages in the required packages once all packages were loaded
........
fpcp.pas, tpcppackage:
+ new method add_required_package() to add a required package while ignoring duplicates
........
pmodules.pas, proc_package:
* add all packages of loaded units as required packages
........
git-svn-id: trunk@33517 -
cclasses.pas, TCmdStrList:
* if doubles are not allowed then do case sensitive checks instead of insensitive ones
........
Correctly handle export/import generation depending on whether we're compiling for a system that needs indirect imports or not.
systems.pas:
* replace systems_package_need_exports with systems_indirect_var_imports
pmodules.pas, proc_package:
- remove check for systems_package_need_exports
pkgutil.pas:
* insert_export, export_unit: export the direct or the indirect variable symbol depending on systems_indirect_var_imports
........
ncgrtti.pas, TRTTIWriter.write_extra_rttisyms:
* enumdef_rtti_string2ordindex & enumdef_rtti_ord2stringindex: put the indirect suffix at the end of the symbol
........
pkgutil.pas, add_package_libs:
* check for systems_indirect_var_imports instead of systems_package_needs_exports
........
expunix.pas, texportlibunix:
* generatelib: check all procdefs whether they have the alias and not only the first one
........
pkgutil.pas:
* insert_export: directly report the symbol type instead of its ordinal to ease finding of problems
........
pkgutil.pas, export_procsym:
* restructure if for better readability
+ also check the procdef for po_has_public_name
........
Ensure that all implicitely imported units are indeed part of the package.
pmodules.pas, proc_package:
* instead of checking the units loaded by the current module we need to check *all* units that are loaded for the package
........
Fix inclusion of PPUs that don't have a corresponding object file.
pkgutil.pas, RewritePPU:
* don't abort if a unit does have the flag uf_no_link set
* only abort if both uf_static_link and uf_no_link are not set
........
Generate an error if a unit listed as in "contains" is part of a directly or indirectly required package.
pmodules.pas, proc_package:
* walk all units and check whether it had been loaded from a package, but is also part of the units of the current module; if so then generate an error
........
git-svn-id: trunk@33516 -
scanner.pas, tscannerfile:
+ new method readoptionalstate which reads a state like readstate, but if it encounters the closing } then it returns the provided fallback state
scandir.pas:
+ do_moduleflagswitch: new parameter optional that triggers the use of readoptionalstate instead of readstate
* dir_weakpackageunit & dir_denypackageunit: the ON/OFF is optional
git-svn-id: trunk@33515 -
Correctly parse the directives DenyPackageUnit and WeakPackageUnit
ppu.pas:
+ add flags uf_packagedeny and uf_packageweak
scandir.pas:
+ new procedure do_moduleflagswitch() which parses a ON/OFF/+/- argument and sets or clears a flag in the current module
+ new procedure dir_denypackageunit which handles DenyPackageUnit
* implement dir_weakpackageunit (and move to the correct location ;) )
* InitScannerDirectives: add dir_denypackageunit handler
........
Respect DenyPackageUnit flag.
pmodules.pas, proc_package:
* check all contained units that are not already part of a package for their uf_package_deny flag and report an error for each that has it set
........
Do not check whether all units are used as by definition all units of a package are considered as used.
pmodules.pas, proc_package:
- remove call to current_module.allunitsused
........
Check whether a unit has been implicitely imported in a package. A unit is considered as implicitely imported if it is not part of a required package nor part of the units listed in the contains section. This note is useful (Delphi even provides a dialog in that case) as a package with implicitely imported units /might/ become incompatible with other packages (e.g. if another package includes that unit uses that package and includes that unit explicitely; of course that is the same as if both package included it explicitely, but with the hint one knows where to look).
pmodules.pas, proc_package:
* while walking the loaded units also check whether any of them not contained in a package was part of the contained units which are the same as the current module's used units
........
Generate CRC for package files
pcp.pas, tpcpfile:
+ new field do_crc which controls CRC generation
+ override putdata() method to generate CRC when data is written
* resetfile: enable do_crc by default
........fppu.pas, tppumodule:
* loadfrompackage: mention if a unit is loaded from a package
........
fpkg.pas, tcontainedunit:
+ new fields offset and size for the PPU data stored inside the PCP
fpcp.pas, tpcppackage:
* readcontainedunits & addunit: correctly initialize offset and size to 0
........
Store the modified PPU files directly inside the PCP and thus get finally rid of the .ppl.ppu files.
entfile.pas:
+ new entry type ibpputable
pkgutil.pas:
* adjust RewritePPU to work on a stream as output instead of a filename
fpcp.pas, tpcppackage:
+ new method writepputable() which writes the offsets and sizes of all contained units (not part of CRC!)
+ new method writeppudata() which rewrites all contained PPUs directly into the PCP after the ibend entry (Note: the data is written 16 Byte aligned to ease viewing of the PCP and its contained PPUs in a hex editor)
+ new method readpputable() which reads the offsets and sizes of all contained units
+ new method getmodulestream() which returns a substream for a contained module
* loadpcp: also call readpputable()
* writepcp: first write an empty pputable, then finish writing all data that requires the put*/write* methods of the pcpfile, then use writeppudata() to write all PPUs and finally write the correct pputable at the original location
fppu.pas, tppumodule:
* loadfrompackage: don't read the PPU from a file if it is contained in a package, but using the new tpcppackage.getmodulestream() and tppumodule.openppustream() methods
pmodules.pas, proc_package:
* don't rewrite the PPUs here
pcp.pas:
* increase CurrentPCPVersion
........
Fix cycling
........
git-svn-id: trunk@33514 -
pmodules.pas, proc_package:
* generate the dummy entry symbol only on Windows systems (ToDo for other systems that might need it)
........
options.pas:
* TOption.interpret_option & read_arguments: use add_package() from pkgutils instead of addpackage() from fpkg
fpkg.pas:
- remove no longer needed addpackage()
........
pkgutil.pas:
+ new procedure add_package_libs() to add all packages as libraries that are also linked against
pmodules.pas:
* proc_package & proc_program: add all package libraries to the linker before creating the final binary
........
pkgutil.pas, add_package:
* package names are case insensitive so add them in uppercase to correctly detect duplicates
........
Keep track of how many units are used from each required/requested package and only link those from which any units are used.
fpkg.pas, tpackageentry:
+ new field usedunits to count how many units of the package are used
pkgutil.pas:
+ new procedure add_package_unit_ref() to increase the amount of used units for the given package
pmodules.pas:
* proc_package & proc_program: check which units of all loaded ones are provided by other packages
........
git-svn-id: trunk@33510 -
ngenutil.pas, tnodeutils:
* InsertInitFinalTable: the init and finalize functions are in the *local* symboltable not the global one
* InsertInitFinalTable.add_initfinal_import: reenable the internal error
git-svn-id: trunk@33508 -
ngenutil.pas, tnodeutils.InsertInitFinalTable:
* add_initfinal_import: disable the internal error until I've found out why the INIT$ function isn't there
git-svn-id: trunk@33504 -
pkgutil.pas:
+ new routine exportabstractrecorddef which does not export generics and also exports the VMT variable
* exportabstractrecordsymproc & insert_export: use exportabstractrecorddef to export a structured type
git-svn-id: trunk@33503 -
Don't try to export generic symbols.
pkgutil.pas:
* exportabstractrecordsymproc: do not export generic type symbols or their nested symbols
........
Ensure that the correct name is used for the PCP file.
proc_package:
* use current_module.modulename instead of module_name for the base filename of the PCP file
........
Add a possibility to track if a unit was loaded from a package.
fmodule.pas, tmodule:
+ new field "package" which is Nil if the unit is not (yet) part of a package or a reference to the package this unit was loaded from
fppu.pas, tppumodule:
* loadfrompackage: set the "package" field of the module to the package it's loaded from.
........
Ensure that units loaded from a package are not recompiled if the source files should happen to be available.
fppu.pas, tppumodule:
loadppu: set the state to ms_compiled instead of ms_load if the unit was loaded from a package (additionally close the PPU file as it's no longer needed)
........
Add support for reading/writing required packages from/to the PCP file
fpcp.pas, tpcppackage:
+ new methods writerequiredpackages and readrequiredpackages
* loadpcp: use readrequiredpackages
* savepcp: use writerequiredpackages
pcp.pas:
* increase PCP version
........
When compiling a package, handle only those units that are not yet part of a package.
pmodules.pas, proc_package:
* only export units that are part of the package
* only add units to the package if they are really part of the package
* don't rewrite the PPU if the unit is not part of the package
* don't link the unit's files if it is not part of the package
........
Add support for parsing required packages.
pkgutil.pas:
+ new function add_package to add a package to the list of available packages with the possibility to check for duplicates
* load_packages: also load all required packages
pmodules.pas, proc_package:
* create the tpcppackage instance earlier (and use the module name as read from the source file as package name)
* clear the list of packages in case the user passed any using -FPxxx
* parse the "requires" section like a list of units and add each full identifier as a package to load
* before parsing the "contains" section load all packages, so that all units can be correctly resolved
........
Correctly create import libraries for packages as well.
pkgutil.pas, createimportlibfromexternals:
* instead of processing units without the uf_in_library flag, only process those that don't have a package reference set (thus becoming part of the program/library or the package)
- remove unneeded "pkg" parameter
pmodules.pas:
+ proc_package: create the import library if the package requires other packages
* proc_program: adjust call to createimportlibfromexternals
........
Ensure that the reference to the System unit is correctly set up for packages. Among other things this is needed to compile a package with the -gl option (though debug information doesn't work yet).
pmodules.pas:
* convert AddUnit to a function and let it return the newly loaded module
* proc_package: when parsing the contained units ensure that we correctly set up the System unit reference if we are to contain the System unit
* proc_package: also set up the System unit reference once all units are loaded and this hasn't happened yet (because all contained units are already compiled)
........
git-svn-id: trunk@33502 -
Also add the initialization/finalization sections and the class constructors/destructors to the imported symbols of the current program/library.
ngenutil.pas, tnodeutils.InsertInitFinalTable:
+ new function add_initfinal_import to find the procsym for the initialization/finalization code and to add it to the imported unit symbols
* write_struct_inits: import the found class constructor/destructor symbols if they are not in the program/library unit
* use add_initfinal_import for the initialization and finalization sections of all used units beside the program/library unit
........
git-svn-id: trunk@33501 -
utils/ppuutils/ppudump.pp:
+ new procedure ReadUnitImportSyms which simply outputs all imported symbols
* readimplementation: handle ibunitimportsyms with ReadUnitImportSyms
git-svn-id: trunk@33500 -
Generate the import library for each used package.
pkgutil.pas:
- remove function createimportlibfromexports
+ new function createimportlibfromexternals which uses the imported unit symbols of a unit to generate the correct import library for each used package used in a program or library
pmodules.pas, proc_program:
* move the generation of the import library further down until all tables were generated of which entries might reside in a package
* use createimportlibfromexternals to generate the import library for the program/library
-- Diese und die folgenden Zeilen werden ignoriert --
M pmodules.pas
M pkgutil.pas
git-svn-id: trunk@33493 -
To correctly generate the import library for a package we need to resolve the dangling external symbols of all units. For this each unit now stores which symbols it exported from another unit and it also stores all global and external assembler symbols it has (maybe this can be streamlined later on, but for now this works).
entfile.pas:
+ new entry for the imported unit symbols
fmodule.pas, tmodule:
+ new field unitimportsyms which holds all symbols imported by a unit from another unit
+ new method to add an imported symbol
* create, destroy & reset: correctly instantiate/free the two new lists
fppu.pas, tppumodule:
+ new field unitimportsymsderefs to hold the derefs during loading from/storing to PPU
+ new method buildderefunitimportsyms to generate the derefs for each imported symbol
+ new method derefunitimportsyms to resolve each imported symbol deref
+ new method readunitimportsyms to read the imported symbols from the PPU
+ new method writeunitimportsyms to write all imported symbols to the PPU
* load_implementation: read the imported symbols if their entry is encountered
* writeppu: generate the derefs for the imported symbols and write them to the PPU
* load_usedunits: resolve the imported symbols once all derefs are known
symtable.pas:
* addsymref: if the symbol is not from the current unit than mark it as imported
ppu.pas:
* increase PPU version
-- Diese und die folgenden Zeilen werden ignoriert --
M entfile.pas
M fmodule.pas
M fppu.pas
M ppu.pas
M symtable.pas
git-svn-id: trunk@33492 -
Merged revision(s) 28796, 28837-28845, 28847-28850, 28852, 32135 from branches/svenbarth/packages:
Provide possibility to pass packages and search paths for packages as parameters.
fpkg.pas:
+ new unit which contains the base types related to package files (most importantly "tpackage")
globals.pas:
+ new variable "packagesearchpath" which contains all paths in which package files should be looked for
+ new variable "packagelist" which contains a list of all packages that should be used in a program or library
* InitGlobals & DoneGlobals: initialize/finalize "packagesearchpath" accordingly ("packagelist" is handled in unit fpkg using a init/done-callback)
options.pas:
+ TOption: new fields "parapackagepath" and "parapackages" to keep track of package search paths and package files passed as parameters
* TOption.interpret_option: use '-Fp' for package search paths and '-FP' for package files
* read_arguments: apply the passed package search paths and packages to their respective containers
........
+ add a new unit which will contain basic functions related to handling packages
........
Move package related functions from pmodules to pkgutil.
pmodules.pas => pkgutil.pas:
* createimportlibfromexports
* varexport
* procexport
* insert_export
* RewritePPU
........
* adjust indentation
........
Extract the code to export the symbols of a unit to its own function in pkgutil so that less functions need to be exported.
pmodules.pas, proc_package:
* move code to export the symbols of a unit to new function export_unit
pkgutil.pas:
+ new function export_unit
- remove exports of procexport, varexport and insert_export
........
Some small fixes for package parsing.
pmodules.pas, proc_package:
* use orgpattern instead of pattern to build the module name (like is done in uses sections)
* ignore duplicates when generating exports
- no need to generate an import library for the package; that is done by the program/library that uses the package
........
+ new unit fpcp of which the class tpcppackage handles the reading and writing of package metadata from/to pcp files (equivalant to tppumodule).
........
+ add unit which contains representation of a PCP file (tpcpfile) like tppufile is for units.
........
Improve export generation.
pkgutil.pas:
+ new function exportprocsym to correctly export a procedure with all its aliases
+ new function exportabstractrecordsymproc to export the members of structured types
* insert_export: handle also namespacesym and propertsym (by ignoring them)
* insert_export: correctly export classes, record and objects
* insert_export: use new exportprocsym function to export a procsym
* insert_export: only export public variables of a static symtable
........
+ add entry constants for the name of the package and the package file names, both used by a PCP file
........
* use messages to get rid of most writelns related to package loading
........
Add additional entry types for PCP files
entfile.pas:
+ new entries ibstartrequireds and ibendrequireds to store the list of required packages
+ new entries ibstartcontained and ibendcontained to store the list of contained units
+ new entries ibstartppus and ibendppus to store the list of contained PPU files
........
Generate the PCP file once the package file and the used units were compiled correctly.
pmodules.pas:
* proc_package: generate the PCP file upon successful compilation
........
Add the possibility to load all packages supplied as parameters.
pkgutil.pas:
+ new function load_packages to load all packages supplied as parameters
pmodules.pas, proc_program:
* use load_packages to load all packages before any unit is loaded
........
Add code which tries to load a unit from a package first and only then as usual.
fppu.pas, tppumodule:
+ new method loadfrompackage which searches all available packages for the unit and loads it from there if found
* loadppu: first try to load the unit from a package if any are available
........
Don't link objects files of a unit that is provided by a package.
pmodules.pas, proc_program:
* if a unit has uf_in_library set we must not include it in the units we link against
........
git-svn-id: trunk@33452 -
Merged revision(s) 29015, 29036, 31989, 32132-32133, 32306, 32478, 32513 from branches/svenbarth/packages:
Start to use package related messages
........
+ add a error message for specifying a package multiple times
........
msg/errore.msg:
+ add additional messages for implicitely imported units and units that must not be part of a package
........
* fix name of section for package related messages
+ add missing EndOfTex tag
........
+ add more package loading related messages
........
errore.msg:
+ new message that a PPU is loaded from a package
........
+ new message for when a unit is listed in the contains section that is already part of another package
........
msg/errore.msg:
+ new message when a unit from an indirectly referenced package is used
........
git-svn-id: trunk@33450 -
Note: the merged code has been adjusted to a) use the typed constant builder and b) to not use the indirect symbol when its not necessary (non-Windows or same unit)
Merged revision(s) 28340, 28350 from branches/svenbarth/packages:
Generate an indirect VMT symbol for each generated VMT.
ncgvmt.pas, TVMTWriter:
* writevmt: write a symbol with the indirect VMT name that references the direct VMT symbol
........
Load the VMT using the indirect symbol if the target supports packages.
ncgmem.pas, tcgloadvmtaddrnode:
* pass_generate_code: if tf_supports_packages is set in target_info.flags we load the VMT using the indirect symbol, otherwise we load it using the direct symbol
........
git-svn-id: trunk@33448 -
ncgrtti.pas, TRTTIWriter:
* write_rtti & write_rtti_extrasyms: generate an indirect symbol for each of the RTTI symbols (they are not used yet, but soon will be)
* write_rtti: reorder operations a bit: first free the tcb (we don't need it anymore), then write the indirect symbol and only then write any extra symbols that might be needed (this way the RTTI data and the indirect symbol will be next to each other)
git-svn-id: trunk@33447 -
the reference has been used for the last time, as the destination
register could be the base or index register of the reference
git-svn-id: trunk@33393 -
In comparison with the original patch, support for a i386 has been added as well as a test program.
Further, a small issue with xbegin has been fixed
git-svn-id: trunk@33375 -
instead of using the optimized instructions for 386+, which assume also a
32-bit address and operand size, so they didn't work even on a 386+ in real
mode
git-svn-id: trunk@33371 -
The added test shows such a bogus warning (sadly the test suite can handle the occurence or absense of certain messages yet :/ )
git-svn-id: trunk@33324 -
supposed to handle in the i8086 internal asm instruction level check, because
these two flags are no longer part of the IF_PLEVEL mask, after r33316
git-svn-id: trunk@33318 -
* WriteTree: implement the ait_realconst case by calling WriteRealConstAsBytes
* WriteTree: remove commented code handling the old constants
git-svn-id: trunk@33288 -
ogmacho.pas:
+ TMachoObjectOutput: new method current_cpu_type to retrieve the cpu_type_t matching the compiler's target platform
* TMachoObjectOutput.writedata: initialize cputarget using current_cpu_type and use cputarget instead of CPU_TYPE_I386 in the call to AllocMachoWriter
* surround the RegisterAssembler call with ifdefs for i386
git-svn-id: trunk@33286 -
systems.pas:
+ add new constant systems_indirect_var_imports to denote all targets that /require/ indirect references for cross-unit variables accesses
git-svn-id: trunk@33284 -
ncgld.pas, tcgloadnode:
+ new method use_indirect_symbol to determine whether using an indirect reference is necessary at all
* generate_threadvar_access & pass_generate_code: pass result of use_indirect_code() to RefAsmSymbol() for using an indirect access if needed
git-svn-id: trunk@33282 -
globtype.pas:
+ tlocalswitch: extend by cs_imported_data
globals.pas:
* default_settings: cs_imported_data is set by default (Delphi compatible)
switches.pas:
* turboSwitchTable: G is used for cs_imported_data
scandir.pas:
+ new directive handler dir_importeddata
* InitScannerDirectives: handle IMPORTEDDATA with dir_importeddata
git-svn-id: trunk@33281 -
x86/cgx86.pas, tcgx86:
+ new method make_direct_ref() which is used to convert an indirect reference into a direct one (uses the boolean field in_make_direct_ref to avoid recursive calls)
* make_simple_ref: call make_direct_ref() before anything else
* a_loadaddr_ref_ref: call make_direct_ref() (the loading could probably be folded into the loadaddr method, but for now that is sufficent)
i386/cgcpu.pas, tcg386:
* a_loadaddr_ref_cgpara: call make_direct_ref(); the same remark as for a_loadaddr_ref_ref() applies here
git-svn-id: trunk@33280 -
Note: It needs to be checked what adjustments will need to be done for JVM and LLVM
Note 2: The indirect symbols will always be generated even if the target won't use them so that assembler code can be consistent among the targets (e.g. i386-win32 needs them while i386-linux does not)
ptconst.pas, read_typed_const:
* generate the indirect symbol in a read only data section
ngenutil.pas, tnodeutils:
* insertbsssym: generate the indirect symbol in a read only data section
git-svn-id: trunk@33279 -
