Pass the three checksum arrays from ppufile to module owner,
to be able to check that the checksums computed at the time pf ppu writing
are compatible with the ones computed at interface level.
git-svn-id: trunk@47626 -
that expects an open array of byte, and use it for all sets
o since all sets need to be typecasted to an array type of the appropriate
size, we'll get a compilation error in case this needs to be done and
that also tells us at the same time that the ppu version will need to
be increased
* enabled {$packset 1} for the compiler, as this is now safe with the above
changes
git-svn-id: trunk@43407 -
non-LLVM-base compiler and vice versa (caused internal errors, because
the LLVM compiler uses different nodes, and these are saved in the PPUs
for inline routines)
git-svn-id: branches/debug_eh@42196 -
pass them to the linker so it does not reorder them
o fixes resource strings on Darwin when using LTO (this used to reorder the
resource string symbols, so they no longer all appeared between the START
and END symbols for their compilation module)
git-svn-id: trunk@41907 -
if looking for a unit's PPU or source failed (and no explicit name was specified)
then all namespaces are walked in the order they were given in and then first the
PPU is looked for and then the source
git-svn-id: trunk@38915 -
* ppu version update
* -Sf might be used only during system unit compilation
* loadsystemunit factored out so the system unit can be loaded earlier than other units to get features set
git-svn-id: trunk@37708 -
Use new cs_checkpointer_called moduleswitches set element.
Use new uf_checkpointer_called PPU flag (reusing obsolete uf_local_browser flag value)
Emit warning if compiled library/program has any code using checkpointer.
* ppu.pas: New constant: uf_checkpointer_called
* globtype.pas: New constant: cs_checkpointer_called
* fppu.pas: Set uf_checkpointer_called flag if cs_checkpointer_called is set in current_settings.module_switches
* i8086/n8086mem.pas: Include cs_checkpointer_called in current_settings.moduleswitches
* ncgmem.pas: Likewise.
* msg/errore.msg: Add new message saying that -gc and -Ur options are incompatible
Add description to -gc option, saying it is experimental.
Add warning at link time for program/library if checkpointer is used in any unit or main code.
* options.pas: if -gc and -Ur options are used, never enable checkpointer code,
instead output a warning that release is incompatible with -gc option.
* pmodules.pas: proc_program: Check all modules for uf_checkpointer_called flag,
emit a warning if checkpointer is used.
* utils/ppuutils/ppudump.pp: Add code for uf_codepointer_called option.
git-svn-id: trunk@34567 -
This basically revives the globalasmsym entry of the PPU though it feeds to different lists, one for the public (exported) symbols and one for the external (imported) symbols. Also the list of symbols is much smaller as it would be if all symbols would be dumped in there.
git-svn-id: trunk@34174 -
SS=DS. This is currently redundant (whether SS=DS can be derived by the other
i8086 memory model unit flags), but in the future will allow adding extra
memory models, where the SS=DS assumption differs from the current ones.
git-svn-id: trunk@34139 -
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 -
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 -
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 -
+ new stream class TCRangeStream that represents a substream of another stream while being also extendable
........
Extend tentryfile so that it can be opened from a stream in addition to a file
entfile.pas, tentryfile:
+ new method openstream() to open a readable tentryfile based on a stream
+ new method createstream() to open a writeable tentryfile based on a stream
* adjust openfile() to use openstream()
* adjust createfile() to use createstream()
........
A few extensions for tentryfile needed for package files
entfile.pas, tentryfile:
+ new property position to retrieve/control the position of the underlying stream (works also with tempclose()/tempopen())
+ new method substream() to retrieve a stream that goes from the specified offset with the specified length (-1 create a stream that is extendable, aka for writing)
+ new property stream to get the underlying stream directly; be careful when using this!
........
Extend tppumodule so that it can be opened from a stream as well.
fppu.pas, tppumodule:
* rename openppu() to openppufile()
+ new method openppustream() to open a module based on a stream
+ put the common part of openppufile() and openppustream() into a new method openppu()
........
Fix compilation.
fppu.pas, tppumodule:
* openppu: add parameter ppufiletime for printing the time of the file (only if filetime is not -1)
* openppufile: pass the retrieve time of the PPU to openppu()
* openppustream: pass -1 to openppu()
........
git-svn-id: trunk@33109 -
Extract reading of the PPU/PCP version into tentryfile.
entfile.pas:
+ add new getversion method which uses the pointer returned by getheaderaddr to read the PPU/PCP version
ppu.pas:
- remove GetPPUVersion method
fppu.pas, pmodules.pas, utils/ppufiles.pp, utils/ppumove.pp, utils/ppuutils/ppudump.pp
* replace call to GetPPUVersion by call to getversion
........
git-svn-id: trunk@32980 -
Extract functionality that is shared between the metadata files for units (PPU) and for packages (PCP) into a parent class called tentryfile
+ add new unit entfile which contains the new tentryfile class and related types and constants
* ppu.pas:
- remove methods, fields, types and constants which were moved to entfile.pas
* replace the parts of tppuheader shared with tentryheader by a field of type tentryheader
fppu.pas, pmodules.pas, utils/ppumove.pp, utils/ppuutils/ppudump.pp:
+ add entfile to uses
* adjust access to common header fields
node.pas, symdef.pas, symsym.pas, symtable.pas, wpoinfo.pas, utils/ppufiles.pp:
+ add entfile to uses
........
git-svn-id: trunk@32976 -
the defs and syms (recursively) referred by inline routines and by the WPO
info
o defs and syms are no longer added immediately to the module's deflist/
symlist, even if they are created as "registered". Instead,
"doregister=true" simply means "add it to the symbol table at the
top of the symtable stack"
o normally only when a sym/def is deref'ed, it gets added to the module
symlist/deflist and defid/symid gets a (unique) value
o in cases where we use(d) the defid to construct unique names within the
current module, you now have to call call the tdef.new unique_id_str()
method. If the def was not yet registered, we will reserve room for it
in the deflist (to get a unique id), but the defid gets set to a
negative value computed from its position in the deflist. Should it
have to be written to the ppu file later on, the defid will be
modified to the actual position in the deflist. For both values,
new unique_id_str() will return the same result so that references
to this def before and after actual registrations are the same (needed
for the JVM backend, but also a good principle in general)
Overall: don't directly use symid/defid anymore to get unique identifiers,
but use tdef.new unique_id_str() instead (if necessary, a similar routine
for tsym can be added)
The result is the ppu file size gets reduced significantly after its big
increase as a result of the high level typed constant builder (which creates
a lot of defs). The result is even more efficient than before, as other
unneeded defs/syms from the localsymtables don't get saved/restored anymore
either.
git-svn-id: trunk@32153 -
o the maintenance effort will be less - previously we had to test 4
combinations:
tiny program with tiny rtl
tiny program with small rtl
small program with tiny rtl
small program with small rtl
I only tested both tiny and small programs with the small rtl, so I missed
a bug, which caused small programs built with the tiny rtl to always give
a "Nil pointer assignment" error. Now we only need to test two cases:
tiny program with tiny rtl
small program with small rtl
o I'm planning a bug fix for interrupt procedures in the tiny model, which
will make their prolog differ between small and tiny. Currently, they're
not used in the rtl, but that may change. And even if it doesn't,
interrupt procedures may also be used by user units.
git-svn-id: trunk@27516 -
