Copy disabled (too large)
Download .txt
Showing preview only (24,013K chars total). Download the full file to get everything.
Repository: ccurtsinger/stabilizer
Branch: master
Commit: f1aefc1a3799
Files: 1352
Total size: 105.8 MB
Directory structure:
gitextract_zpfbl9ua/
├── .gitignore
├── .hgignore
├── LICENSE
├── Makefile
├── README.md
├── common.mk
├── pass/
│ ├── IntrinsicLibcalls.h
│ ├── LowerIntrinsics.cpp
│ ├── Makefile
│ └── Stabilizer.cpp
├── platforms/
│ ├── Darwin.i386.mk
│ ├── Darwin.x86_64.mk
│ ├── Linux.i386.mk
│ ├── Linux.i686.mk
│ ├── Linux.ppc.mk
│ └── Linux.x86_64.mk
├── process.py
├── run.py
├── runtime/
│ ├── Arch.h
│ ├── Context.h
│ ├── Debug.cpp
│ ├── Debug.h
│ ├── Function.cpp
│ ├── Function.h
│ ├── FunctionLocation.h
│ ├── Heap.cpp
│ ├── Heap.h
│ ├── Intrinsics.cpp
│ ├── Jump.h
│ ├── MMapSource.h
│ ├── Makefile
│ ├── MemRange.h
│ ├── Trap.h
│ ├── Util.h
│ └── libstabilizer.cpp
├── szc
├── szchi.cfg
├── szclo.cfg
└── tests/
├── Context/
│ ├── Makefile
│ ├── hello.cpp
│ └── stub.asm
├── HelloWorld/
│ ├── Makefile
│ └── hello.cpp
├── LICENSE
├── Makefile
├── bzip2/
│ ├── Makefile
│ ├── blocksort.c
│ ├── bzip2.c
│ ├── bzlib.c
│ ├── bzlib.h
│ ├── bzlib_private.h
│ ├── compress.c
│ ├── crctable.c
│ ├── decompress.c
│ ├── huffman.c
│ ├── input.combined
│ ├── randtable.c
│ ├── spec.c
│ └── spec.h
├── libquantum/
│ ├── Makefile
│ ├── classic.c
│ ├── classic.h
│ ├── complex.c
│ ├── config.h
│ ├── decoherence.c
│ ├── decoherence.h
│ ├── defs.h
│ ├── expn.c
│ ├── gates.c
│ ├── gates.h
│ ├── lq_complex.h
│ ├── matrix.c
│ ├── matrix.h
│ ├── measure.c
│ ├── measure.h
│ ├── oaddn.c
│ ├── oaddn.h
│ ├── objcode.c
│ ├── objcode.h
│ ├── omuln.c
│ ├── omuln.h
│ ├── qec.c
│ ├── qec.h
│ ├── qft.c
│ ├── quantum.h
│ ├── qureg.c
│ ├── qureg.h
│ ├── shor.c
│ ├── specrand.c
│ ├── specrand.h
│ └── version.c
└── perlbench/
├── Base64.c
├── Cwd.c
├── Dumper.c
├── DynaLoader.c
├── EXTERN.h
├── HiRes.c
├── Hostname.c
├── INTERN.h
├── IO.c
├── MD5.c
├── Makefile
├── Opcode.c
├── Parser.c
├── Peek.c
├── Storable.c
├── WORDS
├── XSUB.h
├── attrs.c
├── av.c
├── av.h
├── config.h
├── const-c.inc
├── cop.h
├── cpu2006_mhonarc.rc
├── cv.h
├── deb.c
├── dictionary
├── doio.c
├── doop.c
├── dump.c
├── embed.h
├── embedvar.h
├── fakesdio.h
├── fakethr.h
├── form.h
├── globals.c
├── gv.c
├── gv.h
├── handy.h
├── hctype.h
├── hparser.c
├── hparser.h
├── hv.c
├── hv.h
├── input/
│ ├── checkspam.pl
│ ├── diffmail.in
│ ├── diffmail.pl
│ ├── perfect.in
│ ├── perfect.pl
│ ├── scrabbl.in
│ ├── scrabbl.pl
│ ├── splitmail.in
│ ├── splitmail.pl
│ └── suns.pl
├── intrpvar.h
├── iperlsys.h
├── keywords.h
├── lib/
│ ├── AutoLoader.pm
│ ├── Carp/
│ │ └── Heavy.pm
│ ├── Carp.pm
│ ├── Config.pm
│ ├── Cwd.pm
│ ├── DB_File.pm
│ ├── Date/
│ │ ├── Format.pm
│ │ ├── Language/
│ │ │ ├── Afar.pm
│ │ │ ├── Amharic.pm
│ │ │ ├── Austrian.pm
│ │ │ ├── Brazilian.pm
│ │ │ ├── Chinese_GB.pm
│ │ │ ├── Czech.pm
│ │ │ ├── Danish.pm
│ │ │ ├── Dutch.pm
│ │ │ ├── English.pm
│ │ │ ├── Finnish.pm
│ │ │ ├── French.pm
│ │ │ ├── Gedeo.pm
│ │ │ ├── German.pm
│ │ │ ├── Greek.pm
│ │ │ ├── Italian.pm
│ │ │ ├── Norwegian.pm
│ │ │ ├── Oromo.pm
│ │ │ ├── Sidama.pm
│ │ │ ├── Somali.pm
│ │ │ ├── Swedish.pm
│ │ │ ├── Tigrinya.pm
│ │ │ ├── TigrinyaEritrean.pm
│ │ │ └── TigrinyaEthiopian.pm
│ │ ├── Language.pm
│ │ └── Parse.pm
│ ├── Digest/
│ │ └── MD5.pm
│ ├── DynaLoader.pm
│ ├── Exporter/
│ │ └── Heavy.pm
│ ├── Exporter.pm
│ ├── Fcntl.pm
│ ├── File/
│ │ ├── Basename.pm
│ │ ├── CheckTree.pm
│ │ ├── Compare.pm
│ │ ├── Copy.pm
│ │ ├── DosGlob.pm
│ │ ├── Find.pm
│ │ ├── Path.pm
│ │ ├── Spec/
│ │ │ ├── Epoc.pm
│ │ │ ├── Functions.pm
│ │ │ ├── Mac.pm
│ │ │ ├── OS2.pm
│ │ │ ├── Unix.pm
│ │ │ ├── VMS.pm
│ │ │ └── Win32.pm
│ │ ├── Spec.pm
│ │ ├── Temp.pm
│ │ └── stat.pm
│ ├── FileCache.pm
│ ├── FileHandle.pm
│ ├── Getopt/
│ │ ├── Long.pm
│ │ └── Std.pm
│ ├── HTML/
│ │ ├── Entities.pm
│ │ ├── Filter.pm
│ │ ├── HeadParser.pm
│ │ ├── LinkExtor.pm
│ │ ├── Parser.pm
│ │ ├── PullParser.pm
│ │ └── TokeParser.pm
│ ├── IO/
│ │ ├── File.pm
│ │ ├── Scalar.pm
│ │ └── Socket/
│ │ ├── INET.pm
│ │ └── UNIX.pm
│ ├── MHonArc/
│ │ ├── Char/
│ │ │ ├── JP.pm
│ │ │ └── KR.pm
│ │ ├── Char.pm
│ │ ├── CharEnt/
│ │ │ ├── AppleArabic.pm
│ │ │ ├── AppleCenteuro.pm
│ │ │ ├── AppleCroatian.pm
│ │ │ ├── AppleCyrillic.pm
│ │ │ ├── AppleGreek.pm
│ │ │ ├── AppleHebrew.pm
│ │ │ ├── AppleIceland.pm
│ │ │ ├── AppleRoman.pm
│ │ │ ├── AppleRomanian.pm
│ │ │ ├── AppleThai.pm
│ │ │ ├── AppleTurkish.pm
│ │ │ ├── BIG5_ETEN.pm
│ │ │ ├── BIG5_HKSCS.pm
│ │ │ ├── CP1250.pm
│ │ │ ├── CP1251.pm
│ │ │ ├── CP1252.pm
│ │ │ ├── CP1253.pm
│ │ │ ├── CP1254.pm
│ │ │ ├── CP1255.pm
│ │ │ ├── CP1256.pm
│ │ │ ├── CP1257.pm
│ │ │ ├── CP1258.pm
│ │ │ ├── CP866.pm
│ │ │ ├── CP932.pm
│ │ │ ├── CP936.pm
│ │ │ ├── CP949.pm
│ │ │ ├── CP950.pm
│ │ │ ├── EUC_JP.pm
│ │ │ ├── GB2312.pm
│ │ │ ├── GOST19768_87.pm
│ │ │ ├── HP_ROMAN8.pm
│ │ │ ├── ISO8859_1.pm
│ │ │ ├── ISO8859_10.pm
│ │ │ ├── ISO8859_11.pm
│ │ │ ├── ISO8859_13.pm
│ │ │ ├── ISO8859_14.pm
│ │ │ ├── ISO8859_15.pm
│ │ │ ├── ISO8859_16.pm
│ │ │ ├── ISO8859_2.pm
│ │ │ ├── ISO8859_3.pm
│ │ │ ├── ISO8859_4.pm
│ │ │ ├── ISO8859_5.pm
│ │ │ ├── ISO8859_6.pm
│ │ │ ├── ISO8859_7.pm
│ │ │ ├── ISO8859_8.pm
│ │ │ ├── ISO8859_9.pm
│ │ │ ├── KOI8_A.pm
│ │ │ ├── KOI8_B.pm
│ │ │ ├── KOI8_E.pm
│ │ │ ├── KOI8_F.pm
│ │ │ ├── KOI8_R.pm
│ │ │ ├── KOI8_U.pm
│ │ │ ├── KOI_0.pm
│ │ │ ├── KOI_7.pm
│ │ │ └── VISCII.pm
│ │ ├── CharEnt.pm
│ │ ├── CharMaps.pm
│ │ ├── Encode.pm
│ │ ├── RFC822.pm
│ │ ├── UTF8/
│ │ │ ├── AppleArabic.pm
│ │ │ ├── AppleCenteuro.pm
│ │ │ ├── AppleCroatian.pm
│ │ │ ├── AppleCyrillic.pm
│ │ │ ├── AppleGreek.pm
│ │ │ ├── AppleHebrew.pm
│ │ │ ├── AppleIceland.pm
│ │ │ ├── AppleRoman.pm
│ │ │ ├── AppleRomanian.pm
│ │ │ ├── AppleThai.pm
│ │ │ ├── AppleTurkish.pm
│ │ │ ├── BIG5_ETEN.pm
│ │ │ ├── BIG5_HKSCS.pm
│ │ │ ├── CP1250.pm
│ │ │ ├── CP1251.pm
│ │ │ ├── CP1252.pm
│ │ │ ├── CP1253.pm
│ │ │ ├── CP1254.pm
│ │ │ ├── CP1255.pm
│ │ │ ├── CP1256.pm
│ │ │ ├── CP1257.pm
│ │ │ ├── CP1258.pm
│ │ │ ├── CP866.pm
│ │ │ ├── CP932.pm
│ │ │ ├── CP936.pm
│ │ │ ├── CP949.pm
│ │ │ ├── CP950.pm
│ │ │ ├── EUC_JP.pm
│ │ │ ├── Encode.pm
│ │ │ ├── GB2312.pm
│ │ │ ├── GOST19768_87.pm
│ │ │ ├── HP_ROMAN8.pm
│ │ │ ├── ISO8859_1.pm
│ │ │ ├── ISO8859_10.pm
│ │ │ ├── ISO8859_11.pm
│ │ │ ├── ISO8859_13.pm
│ │ │ ├── ISO8859_14.pm
│ │ │ ├── ISO8859_15.pm
│ │ │ ├── ISO8859_16.pm
│ │ │ ├── ISO8859_2.pm
│ │ │ ├── ISO8859_3.pm
│ │ │ ├── ISO8859_4.pm
│ │ │ ├── ISO8859_5.pm
│ │ │ ├── ISO8859_6.pm
│ │ │ ├── ISO8859_7.pm
│ │ │ ├── ISO8859_8.pm
│ │ │ ├── ISO8859_9.pm
│ │ │ ├── KOI8_A.pm
│ │ │ ├── KOI8_B.pm
│ │ │ ├── KOI8_E.pm
│ │ │ ├── KOI8_F.pm
│ │ │ ├── KOI8_R.pm
│ │ │ ├── KOI8_U.pm
│ │ │ ├── KOI_0.pm
│ │ │ ├── KOI_7.pm
│ │ │ ├── MapUTF8.pm
│ │ │ ├── MhaEncode.pm
│ │ │ └── VISCII.pm
│ │ └── UTF8.pm
│ ├── MIME/
│ │ ├── Base64.pm
│ │ └── QuotedPrint.pm
│ ├── Mail/
│ │ ├── Header.pm
│ │ ├── SpamAssassin/
│ │ │ ├── ArchiveIterator.pm
│ │ │ ├── AuditMessage.pm
│ │ │ ├── AutoWhitelist.pm
│ │ │ ├── Bayes.pm
│ │ │ ├── BayesStore.pm
│ │ │ ├── CmdLearn.pm
│ │ │ ├── Conf.pm
│ │ │ ├── DBBasedAddrList.pm
│ │ │ ├── Dns.pm
│ │ │ ├── EncappedMIME.pm
│ │ │ ├── EncappedMessage.pm
│ │ │ ├── EvalTests.pm
│ │ │ ├── HTML.pm
│ │ │ ├── Locales.pm
│ │ │ ├── Locker.pm
│ │ │ ├── MailingList.pm
│ │ │ ├── Message.pm
│ │ │ ├── NetSet.pm
│ │ │ ├── NoLocker.pm
│ │ │ ├── NoMailAudit.pm
│ │ │ ├── PerMsgLearner.pm
│ │ │ ├── PerMsgStatus.pm
│ │ │ ├── PersistentAddrList.pm
│ │ │ ├── PhraseFreqs.pm
│ │ │ ├── Received.pm
│ │ │ ├── Replier.pm
│ │ │ ├── Reporter.pm
│ │ │ ├── SHA1.pm
│ │ │ ├── TextCat.pm
│ │ │ └── Util.pm
│ │ ├── SpamAssassin.pm
│ │ └── Util.pm
│ ├── Math/
│ │ ├── BigFloat/
│ │ │ └── Trace.pm
│ │ ├── BigFloat.pm
│ │ ├── BigInt/
│ │ │ ├── Calc.pm
│ │ │ ├── CalcEmu.pm
│ │ │ ├── Scalar.pm
│ │ │ └── Trace.pm
│ │ ├── BigInt.pm
│ │ ├── BigRat.pm
│ │ ├── Complex.pm
│ │ └── Trig.pm
│ ├── Search/
│ │ ├── Dict.pm
│ │ └── Dict.t
│ ├── Storable.pm
│ ├── Symbol.pm
│ ├── Text/
│ │ ├── Tabs.pm
│ │ └── Wrap.pm
│ ├── Time/
│ │ ├── Local.pm
│ │ ├── Zone.pm
│ │ ├── gmtime.pm
│ │ ├── localtime.pm
│ │ └── tm.pm
│ ├── Unicode/
│ │ ├── Collate/
│ │ │ ├── Changes
│ │ │ ├── README
│ │ │ └── keys.txt
│ │ ├── Collate.pm
│ │ ├── Normalize.pm
│ │ ├── README
│ │ ├── UCD.pm
│ │ └── UCD.t
│ ├── abbrev.pl
│ ├── assert.pl
│ ├── attributes.pm
│ ├── auto/
│ │ └── Storable/
│ │ └── autosplit.ix
│ ├── autouse.pm
│ ├── base.pm
│ ├── base64.pl
│ ├── bigfloat.pl
│ ├── bigint.pl
│ ├── bigrat.pl
│ ├── blib.pm
│ ├── bytes.pm
│ ├── bytes_heavy.pl
│ ├── cacheout.pl
│ ├── charnames.pm
│ ├── chat2.pl
│ ├── compare.pm
│ ├── complete.pl
│ ├── constant.pm
│ ├── ctime.pl
│ ├── diagnostics.pm
│ ├── dotsh.pl
│ ├── dumpvar.pl
│ ├── ewhutil.pl
│ ├── exceptions.pl
│ ├── fastcwd.pl
│ ├── fields.pm
│ ├── filetest.pm
│ ├── find.pl
│ ├── finddepth.pl
│ ├── flush.pl
│ ├── ftp.pl
│ ├── getcwd.pl
│ ├── getopt.pl
│ ├── getopts.pl
│ ├── ham.pl
│ ├── hostname.pl
│ ├── importenv.pl
│ ├── integer.pm
│ ├── iso2022jp.pl
│ ├── iso8859.pl
│ ├── less.pm
│ ├── lib.pm
│ ├── locale.pm
│ ├── look.pl
│ ├── mailcomp.pm
│ ├── mhamain.pl
│ ├── mhdb.pl
│ ├── mhdysub.pl
│ ├── mhexternal.pl
│ ├── mhfile.pl
│ ├── mhidxrc.pl
│ ├── mhindex.pl
│ ├── mhinit.pl
│ ├── mhlock.pl
│ ├── mhmimetypes.pl
│ ├── mhmsgextbody.pl
│ ├── mhmsgfile.pl
│ ├── mhnote.pl
│ ├── mhnull.pl
│ ├── mhopt.pl
│ ├── mhrcfile.pl
│ ├── mhrcvars.pl
│ ├── mhrmm.pl
│ ├── mhscan.pl
│ ├── mhsingle.pl
│ ├── mhthread.pl
│ ├── mhtime.pl
│ ├── mhtxtenrich.pl
│ ├── mhtxthtml.pl
│ ├── mhtxtplain.pl
│ ├── mhtxttsv.pl
│ ├── mhusage.pl
│ ├── mhutil.pl
│ ├── mungewords
│ ├── newgetopt.pl
│ ├── open.pm
│ ├── open2.pl
│ ├── open3.pl
│ ├── osinit.pl
│ ├── overload.pm
│ ├── perl5db.pl
│ ├── pwd.pl
│ ├── qprint.pl
│ ├── re.pm
│ ├── readmail.pl
│ ├── shellwords.pl
│ ├── sigtrap.pm
│ ├── spam.pl
│ ├── specdiff.pm
│ ├── stat.pl
│ ├── strict.pm
│ ├── subs.pm
│ ├── syslog.pl
│ ├── tainted.pl
│ ├── termcap.pl
│ ├── timelocal.pl
│ ├── unicore/
│ │ ├── ArabLink.pl
│ │ ├── ArabLnkGrp.pl
│ │ ├── ArabicShaping.txt
│ │ ├── BidiMirroring.txt
│ │ ├── Bidirectional.pl
│ │ ├── Blocks.pl
│ │ ├── Blocks.txt
│ │ ├── Canonical.pl
│ │ ├── CaseFolding.txt
│ │ ├── Category.pl
│ │ ├── CombiningClass.pl
│ │ ├── CompositionExclusions.txt
│ │ ├── Decomposition.pl
│ │ ├── EastAsianWidth.txt
│ │ ├── Exact.pl
│ │ ├── HangulSyllableType.txt
│ │ ├── Index.txt
│ │ ├── Jamo.txt
│ │ ├── JamoShort.pl
│ │ ├── Lbrk.pl
│ │ ├── LineBreak.txt
│ │ ├── Makefile
│ │ ├── Name.pl
│ │ ├── NamesList.txt
│ │ ├── NormalizationCorrections.txt
│ │ ├── Number.pl
│ │ ├── PVA.pl
│ │ ├── PropList.txt
│ │ ├── PropValueAliases.txt
│ │ ├── Properties
│ │ ├── PropertyAliases.txt
│ │ ├── README.perl
│ │ ├── ReadMe.txt
│ │ ├── Scripts.pl
│ │ ├── Scripts.txt
│ │ ├── SpecialCasing.txt
│ │ ├── StandardizedVariants.txt
│ │ ├── To/
│ │ │ ├── Digit.pl
│ │ │ ├── Fold.pl
│ │ │ ├── Lower.pl
│ │ │ ├── Title.pl
│ │ │ └── Upper.pl
│ │ ├── UnicodeData.txt
│ │ ├── lib/
│ │ │ ├── ASCII.pl
│ │ │ ├── Alnum.pl
│ │ │ ├── Alpha.pl
│ │ │ ├── Alphabet.pl
│ │ │ ├── Any.pl
│ │ │ ├── Arabic.pl
│ │ │ ├── Armenian.pl
│ │ │ ├── AsciiHex.pl
│ │ │ ├── Assigned.pl
│ │ │ ├── Bengali.pl
│ │ │ ├── BidiAL.pl
│ │ │ ├── BidiAN.pl
│ │ │ ├── BidiB.pl
│ │ │ ├── BidiBN.pl
│ │ │ ├── BidiCS.pl
│ │ │ ├── BidiCont.pl
│ │ │ ├── BidiEN.pl
│ │ │ ├── BidiES.pl
│ │ │ ├── BidiET.pl
│ │ │ ├── BidiL.pl
│ │ │ ├── BidiLRE.pl
│ │ │ ├── BidiLRO.pl
│ │ │ ├── BidiNSM.pl
│ │ │ ├── BidiON.pl
│ │ │ ├── BidiPDF.pl
│ │ │ ├── BidiR.pl
│ │ │ ├── BidiRLE.pl
│ │ │ ├── BidiRLO.pl
│ │ │ ├── BidiS.pl
│ │ │ ├── BidiWS.pl
│ │ │ ├── Blank.pl
│ │ │ ├── Bopomofo.pl
│ │ │ ├── Braille.pl
│ │ │ ├── Buhid.pl
│ │ │ ├── C.pl
│ │ │ ├── Canadian.pl
│ │ │ ├── Canon.pl
│ │ │ ├── Cc.pl
│ │ │ ├── Cf.pl
│ │ │ ├── Cherokee.pl
│ │ │ ├── Cn.pl
│ │ │ ├── Cntrl.pl
│ │ │ ├── Co.pl
│ │ │ ├── Common.pl
│ │ │ ├── Compat.pl
│ │ │ ├── Cs.pl
│ │ │ ├── Cypriot.pl
│ │ │ ├── Cyrillic.pl
│ │ │ ├── DCcircle.pl
│ │ │ ├── DCcompat.pl
│ │ │ ├── DCfinal.pl
│ │ │ ├── DCfont.pl
│ │ │ ├── DCfracti.pl
│ │ │ ├── DCinitia.pl
│ │ │ ├── DCisolat.pl
│ │ │ ├── DCmedial.pl
│ │ │ ├── DCnarrow.pl
│ │ │ ├── DCnoBrea.pl
│ │ │ ├── DCsmall.pl
│ │ │ ├── DCsquare.pl
│ │ │ ├── DCsub.pl
│ │ │ ├── DCsuper.pl
│ │ │ ├── DCvertic.pl
│ │ │ ├── DCwide.pl
│ │ │ ├── Dash.pl
│ │ │ ├── Deprecat.pl
│ │ │ ├── Deseret.pl
│ │ │ ├── Devanaga.pl
│ │ │ ├── Diacriti.pl
│ │ │ ├── Digit.pl
│ │ │ ├── Ethiopic.pl
│ │ │ ├── Extender.pl
│ │ │ ├── Georgian.pl
│ │ │ ├── Gothic.pl
│ │ │ ├── Graph.pl
│ │ │ ├── Grapheme.pl
│ │ │ ├── Greek.pl
│ │ │ ├── Gujarati.pl
│ │ │ ├── Gurmukhi.pl
│ │ │ ├── Han.pl
│ │ │ ├── Hangul.pl
│ │ │ ├── Hanunoo.pl
│ │ │ ├── Hebrew.pl
│ │ │ ├── HexDigit.pl
│ │ │ ├── Hiragana.pl
│ │ │ ├── Hyphen.pl
│ │ │ ├── IdContin.pl
│ │ │ ├── IdStart.pl
│ │ │ ├── Ideograp.pl
│ │ │ ├── IdsBinar.pl
│ │ │ ├── IdsTrina.pl
│ │ │ ├── InAegean.pl
│ │ │ ├── InAlphab.pl
│ │ │ ├── InArabi2.pl
│ │ │ ├── InArabi3.pl
│ │ │ ├── InArabic.pl
│ │ │ ├── InArmeni.pl
│ │ │ ├── InArrows.pl
│ │ │ ├── InBasicL.pl
│ │ │ ├── InBengal.pl
│ │ │ ├── InBlockE.pl
│ │ │ ├── InBopom2.pl
│ │ │ ├── InBopomo.pl
│ │ │ ├── InBoxDra.pl
│ │ │ ├── InBraill.pl
│ │ │ ├── InBuhid.pl
│ │ │ ├── InByzant.pl
│ │ │ ├── InCherok.pl
│ │ │ ├── InCjkCo2.pl
│ │ │ ├── InCjkCo3.pl
│ │ │ ├── InCjkCo4.pl
│ │ │ ├── InCjkCom.pl
│ │ │ ├── InCjkRad.pl
│ │ │ ├── InCjkSym.pl
│ │ │ ├── InCjkUn2.pl
│ │ │ ├── InCjkUn3.pl
│ │ │ ├── InCjkUni.pl
│ │ │ ├── InCombi2.pl
│ │ │ ├── InCombi3.pl
│ │ │ ├── InCombin.pl
│ │ │ ├── InContro.pl
│ │ │ ├── InCurren.pl
│ │ │ ├── InCyprio.pl
│ │ │ ├── InCyril2.pl
│ │ │ ├── InCyrill.pl
│ │ │ ├── InDesere.pl
│ │ │ ├── InDevana.pl
│ │ │ ├── InDingba.pl
│ │ │ ├── InEnclo2.pl
│ │ │ ├── InEnclos.pl
│ │ │ ├── InEthiop.pl
│ │ │ ├── InGenera.pl
│ │ │ ├── InGeomet.pl
│ │ │ ├── InGeorgi.pl
│ │ │ ├── InGothic.pl
│ │ │ ├── InGreek.pl
│ │ │ ├── InGreekA.pl
│ │ │ ├── InGreekE.pl
│ │ │ ├── InGujara.pl
│ │ │ ├── InGurmuk.pl
│ │ │ ├── InHalfwi.pl
│ │ │ ├── InHangu2.pl
│ │ │ ├── InHangu3.pl
│ │ │ ├── InHangul.pl
│ │ │ ├── InHanuno.pl
│ │ │ ├── InHebrew.pl
│ │ │ ├── InHighPr.pl
│ │ │ ├── InHighSu.pl
│ │ │ ├── InHiraga.pl
│ │ │ ├── InIdeogr.pl
│ │ │ ├── InIpaExt.pl
│ │ │ ├── InKanbun.pl
│ │ │ ├── InKangxi.pl
│ │ │ ├── InKannad.pl
│ │ │ ├── InKatak2.pl
│ │ │ ├── InKataka.pl
│ │ │ ├── InKhmer.pl
│ │ │ ├── InKhmerS.pl
│ │ │ ├── InLao.pl
│ │ │ ├── InLatin1.pl
│ │ │ ├── InLatin2.pl
│ │ │ ├── InLatin3.pl
│ │ │ ├── InLatinE.pl
│ │ │ ├── InLetter.pl
│ │ │ ├── InLimbu.pl
│ │ │ ├── InLinea2.pl
│ │ │ ├── InLinear.pl
│ │ │ ├── InLowSur.pl
│ │ │ ├── InMalaya.pl
│ │ │ ├── InMathe2.pl
│ │ │ ├── InMathem.pl
│ │ │ ├── InMisce2.pl
│ │ │ ├── InMisce3.pl
│ │ │ ├── InMisce4.pl
│ │ │ ├── InMisce5.pl
│ │ │ ├── InMiscel.pl
│ │ │ ├── InMongol.pl
│ │ │ ├── InMusica.pl
│ │ │ ├── InMyanma.pl
│ │ │ ├── InNumber.pl
│ │ │ ├── InOgham.pl
│ │ │ ├── InOldIta.pl
│ │ │ ├── InOptica.pl
│ │ │ ├── InOriya.pl
│ │ │ ├── InOsmany.pl
│ │ │ ├── InPhonet.pl
│ │ │ ├── InPrivat.pl
│ │ │ ├── InRunic.pl
│ │ │ ├── InShavia.pl
│ │ │ ├── InSinhal.pl
│ │ │ ├── InSmallF.pl
│ │ │ ├── InSpacin.pl
│ │ │ ├── InSpecia.pl
│ │ │ ├── InSupers.pl
│ │ │ ├── InSuppl2.pl
│ │ │ ├── InSuppl3.pl
│ │ │ ├── InSuppl4.pl
│ │ │ ├── InSuppl5.pl
│ │ │ ├── InSupple.pl
│ │ │ ├── InSyriac.pl
│ │ │ ├── InTagalo.pl
│ │ │ ├── InTagban.pl
│ │ │ ├── InTags.pl
│ │ │ ├── InTaiLe.pl
│ │ │ ├── InTaiXua.pl
│ │ │ ├── InTamil.pl
│ │ │ ├── InTelugu.pl
│ │ │ ├── InThaana.pl
│ │ │ ├── InThai.pl
│ │ │ ├── InTibeta.pl
│ │ │ ├── InUgarit.pl
│ │ │ ├── InUnifie.pl
│ │ │ ├── InVaria2.pl
│ │ │ ├── InVariat.pl
│ │ │ ├── InYiRadi.pl
│ │ │ ├── InYiSyll.pl
│ │ │ ├── InYijing.pl
│ │ │ ├── Inherite.pl
│ │ │ ├── JoinCont.pl
│ │ │ ├── Kannada.pl
│ │ │ ├── Katakana.pl
│ │ │ ├── Khmer.pl
│ │ │ ├── L.pl
│ │ │ ├── L_.pl
│ │ │ ├── Lao.pl
│ │ │ ├── Latin.pl
│ │ │ ├── Limbu.pl
│ │ │ ├── LinearB.pl
│ │ │ ├── Ll.pl
│ │ │ ├── Lm.pl
│ │ │ ├── Lo.pl
│ │ │ ├── LogicalO.pl
│ │ │ ├── Lower.pl
│ │ │ ├── Lowercas.pl
│ │ │ ├── Lt.pl
│ │ │ ├── Lu.pl
│ │ │ ├── M.pl
│ │ │ ├── Malayala.pl
│ │ │ ├── Math.pl
│ │ │ ├── Mc.pl
│ │ │ ├── Me.pl
│ │ │ ├── Mirrored.pl
│ │ │ ├── Mn.pl
│ │ │ ├── Mongolia.pl
│ │ │ ├── Myanmar.pl
│ │ │ ├── N.pl
│ │ │ ├── Nd.pl
│ │ │ ├── Nl.pl
│ │ │ ├── No.pl
│ │ │ ├── Nonchara.pl
│ │ │ ├── Ogham.pl
│ │ │ ├── OldItali.pl
│ │ │ ├── Oriya.pl
│ │ │ ├── Osmanya.pl
│ │ │ ├── OtherAlp.pl
│ │ │ ├── OtherDef.pl
│ │ │ ├── OtherGra.pl
│ │ │ ├── OtherIdS.pl
│ │ │ ├── OtherLow.pl
│ │ │ ├── OtherMat.pl
│ │ │ ├── OtherUpp.pl
│ │ │ ├── P.pl
│ │ │ ├── Pc.pl
│ │ │ ├── Pd.pl
│ │ │ ├── Pe.pl
│ │ │ ├── Pf.pl
│ │ │ ├── Pi.pl
│ │ │ ├── Po.pl
│ │ │ ├── Print.pl
│ │ │ ├── Ps.pl
│ │ │ ├── Punct.pl
│ │ │ ├── Quotatio.pl
│ │ │ ├── Radical.pl
│ │ │ ├── Runic.pl
│ │ │ ├── S.pl
│ │ │ ├── Sc.pl
│ │ │ ├── Shavian.pl
│ │ │ ├── Sinhala.pl
│ │ │ ├── Sk.pl
│ │ │ ├── Sm.pl
│ │ │ ├── So.pl
│ │ │ ├── SoftDott.pl
│ │ │ ├── Space.pl
│ │ │ ├── SpacePer.pl
│ │ │ ├── Syriac.pl
│ │ │ ├── Tagalog.pl
│ │ │ ├── Tagbanwa.pl
│ │ │ ├── TaiLe.pl
│ │ │ ├── Tamil.pl
│ │ │ ├── Telugu.pl
│ │ │ ├── Terminal.pl
│ │ │ ├── Thaana.pl
│ │ │ ├── Thai.pl
│ │ │ ├── Tibetan.pl
│ │ │ ├── Title.pl
│ │ │ ├── Ugaritic.pl
│ │ │ ├── UnifiedI.pl
│ │ │ ├── Upper.pl
│ │ │ ├── Uppercas.pl
│ │ │ ├── WhiteSpa.pl
│ │ │ ├── Word.pl
│ │ │ ├── XDigit.pl
│ │ │ ├── Yi.pl
│ │ │ ├── Z.pl
│ │ │ ├── Zl.pl
│ │ │ ├── Zp.pl
│ │ │ ├── Zs.pl
│ │ │ ├── _CanonDC.pl
│ │ │ ├── _CaseIgn.pl
│ │ │ ├── _CombAbo.pl
│ │ │ ├── bc/
│ │ │ │ ├── AL.pl
│ │ │ │ ├── AN.pl
│ │ │ │ ├── B.pl
│ │ │ │ ├── BN.pl
│ │ │ │ ├── CS.pl
│ │ │ │ ├── EN.pl
│ │ │ │ ├── ES.pl
│ │ │ │ ├── ET.pl
│ │ │ │ ├── L.pl
│ │ │ │ ├── LRE.pl
│ │ │ │ ├── LRO.pl
│ │ │ │ ├── NSM.pl
│ │ │ │ ├── ON.pl
│ │ │ │ ├── PDF.pl
│ │ │ │ ├── R.pl
│ │ │ │ ├── RLE.pl
│ │ │ │ ├── RLO.pl
│ │ │ │ ├── S.pl
│ │ │ │ └── WS.pl
│ │ │ ├── ccc/
│ │ │ │ ├── A.pl
│ │ │ │ ├── AL.pl
│ │ │ │ ├── AR.pl
│ │ │ │ ├── ATAR.pl
│ │ │ │ ├── ATB.pl
│ │ │ │ ├── ATBL.pl
│ │ │ │ ├── B.pl
│ │ │ │ ├── BL.pl
│ │ │ │ ├── BR.pl
│ │ │ │ ├── DA.pl
│ │ │ │ ├── DB.pl
│ │ │ │ ├── IS.pl
│ │ │ │ ├── KV.pl
│ │ │ │ ├── L.pl
│ │ │ │ ├── NK.pl
│ │ │ │ ├── NR.pl
│ │ │ │ ├── OV.pl
│ │ │ │ ├── R.pl
│ │ │ │ └── VR.pl
│ │ │ ├── dt/
│ │ │ │ ├── can.pl
│ │ │ │ ├── com.pl
│ │ │ │ ├── enc.pl
│ │ │ │ ├── fin.pl
│ │ │ │ ├── font.pl
│ │ │ │ ├── fra.pl
│ │ │ │ ├── init.pl
│ │ │ │ ├── iso.pl
│ │ │ │ ├── med.pl
│ │ │ │ ├── nar.pl
│ │ │ │ ├── nb.pl
│ │ │ │ ├── sml.pl
│ │ │ │ ├── sqr.pl
│ │ │ │ ├── sub.pl
│ │ │ │ ├── sup.pl
│ │ │ │ ├── vert.pl
│ │ │ │ └── wide.pl
│ │ │ ├── ea/
│ │ │ │ ├── A.pl
│ │ │ │ ├── F.pl
│ │ │ │ ├── H.pl
│ │ │ │ ├── N.pl
│ │ │ │ ├── Na.pl
│ │ │ │ └── W.pl
│ │ │ ├── gc_sc/
│ │ │ │ ├── AHex.pl
│ │ │ │ ├── ASCII.pl
│ │ │ │ ├── Alnum.pl
│ │ │ │ ├── Alpha.pl
│ │ │ │ ├── Alphabet.pl
│ │ │ │ ├── Any.pl
│ │ │ │ ├── Arab.pl
│ │ │ │ ├── Armn.pl
│ │ │ │ ├── AsciiHex.pl
│ │ │ │ ├── Assigned.pl
│ │ │ │ ├── Beng.pl
│ │ │ │ ├── BidiC.pl
│ │ │ │ ├── BidiCont.pl
│ │ │ │ ├── Blank.pl
│ │ │ │ ├── Bopo.pl
│ │ │ │ ├── Brai.pl
│ │ │ │ ├── Buhd.pl
│ │ │ │ ├── C.pl
│ │ │ │ ├── Canadian.pl
│ │ │ │ ├── Cc.pl
│ │ │ │ ├── Cf.pl
│ │ │ │ ├── Cher.pl
│ │ │ │ ├── Cn.pl
│ │ │ │ ├── Cntrl.pl
│ │ │ │ ├── Co.pl
│ │ │ │ ├── Cprt.pl
│ │ │ │ ├── Cs.pl
│ │ │ │ ├── Cyrl.pl
│ │ │ │ ├── Dash.pl
│ │ │ │ ├── Dash2.pl
│ │ │ │ ├── Dep.pl
│ │ │ │ ├── Deprecat.pl
│ │ │ │ ├── Deva.pl
│ │ │ │ ├── Dia.pl
│ │ │ │ ├── Diacriti.pl
│ │ │ │ ├── Digit.pl
│ │ │ │ ├── Dsrt.pl
│ │ │ │ ├── Ethi.pl
│ │ │ │ ├── Ext.pl
│ │ │ │ ├── Extender.pl
│ │ │ │ ├── Geor.pl
│ │ │ │ ├── Goth.pl
│ │ │ │ ├── GrLink.pl
│ │ │ │ ├── Graph.pl
│ │ │ │ ├── Grapheme.pl
│ │ │ │ ├── Grek.pl
│ │ │ │ ├── Gujr.pl
│ │ │ │ ├── Guru.pl
│ │ │ │ ├── Hang.pl
│ │ │ │ ├── Hani.pl
│ │ │ │ ├── Hano.pl
│ │ │ │ ├── Hebr.pl
│ │ │ │ ├── Hex.pl
│ │ │ │ ├── HexDigit.pl
│ │ │ │ ├── Hira.pl
│ │ │ │ ├── Hyphen.pl
│ │ │ │ ├── Hyphen2.pl
│ │ │ │ ├── IDSB.pl
│ │ │ │ ├── IDST.pl
│ │ │ │ ├── IdContin.pl
│ │ │ │ ├── IdStart.pl
│ │ │ │ ├── Ideo.pl
│ │ │ │ ├── Ideograp.pl
│ │ │ │ ├── IdsBinar.pl
│ │ │ │ ├── IdsTrina.pl
│ │ │ │ ├── InAegean.pl
│ │ │ │ ├── InAlphab.pl
│ │ │ │ ├── InArabi2.pl
│ │ │ │ ├── InArabi3.pl
│ │ │ │ ├── InArabic.pl
│ │ │ │ ├── InArmeni.pl
│ │ │ │ ├── InArrows.pl
│ │ │ │ ├── InBasicL.pl
│ │ │ │ ├── InBengal.pl
│ │ │ │ ├── InBlockE.pl
│ │ │ │ ├── InBopom2.pl
│ │ │ │ ├── InBopomo.pl
│ │ │ │ ├── InBoxDra.pl
│ │ │ │ ├── InBraill.pl
│ │ │ │ ├── InBuhid.pl
│ │ │ │ ├── InByzant.pl
│ │ │ │ ├── InCherok.pl
│ │ │ │ ├── InCjkCo2.pl
│ │ │ │ ├── InCjkCo3.pl
│ │ │ │ ├── InCjkCo4.pl
│ │ │ │ ├── InCjkCom.pl
│ │ │ │ ├── InCjkRad.pl
│ │ │ │ ├── InCjkSym.pl
│ │ │ │ ├── InCjkUn2.pl
│ │ │ │ ├── InCjkUn3.pl
│ │ │ │ ├── InCjkUni.pl
│ │ │ │ ├── InCombi2.pl
│ │ │ │ ├── InCombi3.pl
│ │ │ │ ├── InCombin.pl
│ │ │ │ ├── InContro.pl
│ │ │ │ ├── InCurren.pl
│ │ │ │ ├── InCyprio.pl
│ │ │ │ ├── InCyril2.pl
│ │ │ │ ├── InCyrill.pl
│ │ │ │ ├── InDesere.pl
│ │ │ │ ├── InDevana.pl
│ │ │ │ ├── InDingba.pl
│ │ │ │ ├── InEnclo2.pl
│ │ │ │ ├── InEnclos.pl
│ │ │ │ ├── InEthiop.pl
│ │ │ │ ├── InGenera.pl
│ │ │ │ ├── InGeomet.pl
│ │ │ │ ├── InGeorgi.pl
│ │ │ │ ├── InGothic.pl
│ │ │ │ ├── InGreekA.pl
│ │ │ │ ├── InGreekE.pl
│ │ │ │ ├── InGujara.pl
│ │ │ │ ├── InGurmuk.pl
│ │ │ │ ├── InHalfwi.pl
│ │ │ │ ├── InHangu2.pl
│ │ │ │ ├── InHangu3.pl
│ │ │ │ ├── InHangul.pl
│ │ │ │ ├── InHanuno.pl
│ │ │ │ ├── InHebrew.pl
│ │ │ │ ├── InHighPr.pl
│ │ │ │ ├── InHighSu.pl
│ │ │ │ ├── InHiraga.pl
│ │ │ │ ├── InIdeogr.pl
│ │ │ │ ├── InIpaExt.pl
│ │ │ │ ├── InKanbun.pl
│ │ │ │ ├── InKangxi.pl
│ │ │ │ ├── InKannad.pl
│ │ │ │ ├── InKatak2.pl
│ │ │ │ ├── InKataka.pl
│ │ │ │ ├── InKhmer.pl
│ │ │ │ ├── InKhmerS.pl
│ │ │ │ ├── InLao.pl
│ │ │ │ ├── InLatin1.pl
│ │ │ │ ├── InLatin2.pl
│ │ │ │ ├── InLatin3.pl
│ │ │ │ ├── InLatinE.pl
│ │ │ │ ├── InLetter.pl
│ │ │ │ ├── InLimbu.pl
│ │ │ │ ├── InLinea2.pl
│ │ │ │ ├── InLinear.pl
│ │ │ │ ├── InLowSur.pl
│ │ │ │ ├── InMalaya.pl
│ │ │ │ ├── InMathe2.pl
│ │ │ │ ├── InMathem.pl
│ │ │ │ ├── InMisce2.pl
│ │ │ │ ├── InMisce3.pl
│ │ │ │ ├── InMisce4.pl
│ │ │ │ ├── InMisce5.pl
│ │ │ │ ├── InMiscel.pl
│ │ │ │ ├── InMongol.pl
│ │ │ │ ├── InMusica.pl
│ │ │ │ ├── InMyanma.pl
│ │ │ │ ├── InNumber.pl
│ │ │ │ ├── InOgham.pl
│ │ │ │ ├── InOldIta.pl
│ │ │ │ ├── InOptica.pl
│ │ │ │ ├── InOriya.pl
│ │ │ │ ├── InOsmany.pl
│ │ │ │ ├── InPhonet.pl
│ │ │ │ ├── InPrivat.pl
│ │ │ │ ├── InRunic.pl
│ │ │ │ ├── InShavia.pl
│ │ │ │ ├── InSinhal.pl
│ │ │ │ ├── InSmallF.pl
│ │ │ │ ├── InSpacin.pl
│ │ │ │ ├── InSpecia.pl
│ │ │ │ ├── InSupers.pl
│ │ │ │ ├── InSuppl2.pl
│ │ │ │ ├── InSuppl3.pl
│ │ │ │ ├── InSuppl4.pl
│ │ │ │ ├── InSuppl5.pl
│ │ │ │ ├── InSupple.pl
│ │ │ │ ├── InSyriac.pl
│ │ │ │ ├── InTagalo.pl
│ │ │ │ ├── InTagban.pl
│ │ │ │ ├── InTags.pl
│ │ │ │ ├── InTaiLe.pl
│ │ │ │ ├── InTaiXua.pl
│ │ │ │ ├── InTamil.pl
│ │ │ │ ├── InTelugu.pl
│ │ │ │ ├── InThaana.pl
│ │ │ │ ├── InThai.pl
│ │ │ │ ├── InTibeta.pl
│ │ │ │ ├── InUgarit.pl
│ │ │ │ ├── InUnifie.pl
│ │ │ │ ├── InVaria2.pl
│ │ │ │ ├── InVariat.pl
│ │ │ │ ├── InYiRadi.pl
│ │ │ │ ├── InYiSyll.pl
│ │ │ │ ├── InYijing.pl
│ │ │ │ ├── JoinC.pl
│ │ │ │ ├── JoinCont.pl
│ │ │ │ ├── Kana.pl
│ │ │ │ ├── Katakana.pl
│ │ │ │ ├── Khmr.pl
│ │ │ │ ├── Knda.pl
│ │ │ │ ├── L.pl
│ │ │ │ ├── LC.pl
│ │ │ │ ├── LOE.pl
│ │ │ │ ├── Laoo.pl
│ │ │ │ ├── Latn.pl
│ │ │ │ ├── Limb.pl
│ │ │ │ ├── LinearB.pl
│ │ │ │ ├── Ll.pl
│ │ │ │ ├── Lm.pl
│ │ │ │ ├── Lo.pl
│ │ │ │ ├── LogicalO.pl
│ │ │ │ ├── Lower.pl
│ │ │ │ ├── Lowercas.pl
│ │ │ │ ├── Lt.pl
│ │ │ │ ├── Lu.pl
│ │ │ │ ├── M.pl
│ │ │ │ ├── Math.pl
│ │ │ │ ├── Mc.pl
│ │ │ │ ├── Me.pl
│ │ │ │ ├── Mlym.pl
│ │ │ │ ├── Mn.pl
│ │ │ │ ├── Mong.pl
│ │ │ │ ├── Mymr.pl
│ │ │ │ ├── N.pl
│ │ │ │ ├── NChar.pl
│ │ │ │ ├── Nd.pl
│ │ │ │ ├── Nl.pl
│ │ │ │ ├── No.pl
│ │ │ │ ├── Nonchara.pl
│ │ │ │ ├── OAlpha.pl
│ │ │ │ ├── ODI.pl
│ │ │ │ ├── OGrExt.pl
│ │ │ │ ├── OIDS.pl
│ │ │ │ ├── OLower.pl
│ │ │ │ ├── OMath.pl
│ │ │ │ ├── OUpper.pl
│ │ │ │ ├── Ogam.pl
│ │ │ │ ├── OldItali.pl
│ │ │ │ ├── Orya.pl
│ │ │ │ ├── Osma.pl
│ │ │ │ ├── OtherAlp.pl
│ │ │ │ ├── OtherDef.pl
│ │ │ │ ├── OtherGra.pl
│ │ │ │ ├── OtherIdS.pl
│ │ │ │ ├── OtherLow.pl
│ │ │ │ ├── OtherMat.pl
│ │ │ │ ├── OtherUpp.pl
│ │ │ │ ├── P.pl
│ │ │ │ ├── Pc.pl
│ │ │ │ ├── Pd.pl
│ │ │ │ ├── Pe.pl
│ │ │ │ ├── Pf.pl
│ │ │ │ ├── Pi.pl
│ │ │ │ ├── Po.pl
│ │ │ │ ├── Print.pl
│ │ │ │ ├── Ps.pl
│ │ │ │ ├── Punct.pl
│ │ │ │ ├── QMark.pl
│ │ │ │ ├── Qaai.pl
│ │ │ │ ├── Quotatio.pl
│ │ │ │ ├── Radical.pl
│ │ │ │ ├── Radical2.pl
│ │ │ │ ├── Runr.pl
│ │ │ │ ├── S.pl
│ │ │ │ ├── SD.pl
│ │ │ │ ├── STerm.pl
│ │ │ │ ├── Sc.pl
│ │ │ │ ├── Shaw.pl
│ │ │ │ ├── Sinh.pl
│ │ │ │ ├── Sk.pl
│ │ │ │ ├── Sm.pl
│ │ │ │ ├── So.pl
│ │ │ │ ├── SoftDott.pl
│ │ │ │ ├── Space.pl
│ │ │ │ ├── SpacePer.pl
│ │ │ │ ├── Sterm2.pl
│ │ │ │ ├── Syrc.pl
│ │ │ │ ├── Tagb.pl
│ │ │ │ ├── TaiLe.pl
│ │ │ │ ├── Taml.pl
│ │ │ │ ├── Telu.pl
│ │ │ │ ├── Term.pl
│ │ │ │ ├── Terminal.pl
│ │ │ │ ├── Tglg.pl
│ │ │ │ ├── Thaa.pl
│ │ │ │ ├── Thai.pl
│ │ │ │ ├── Tibt.pl
│ │ │ │ ├── Title.pl
│ │ │ │ ├── UIdeo.pl
│ │ │ │ ├── Ugar.pl
│ │ │ │ ├── UnifiedI.pl
│ │ │ │ ├── Upper.pl
│ │ │ │ ├── Uppercas.pl
│ │ │ │ ├── VS.pl
│ │ │ │ ├── Variatio.pl
│ │ │ │ ├── WSpace.pl
│ │ │ │ ├── WhiteSpa.pl
│ │ │ │ ├── Word.pl
│ │ │ │ ├── XDigit.pl
│ │ │ │ ├── Yiii.pl
│ │ │ │ ├── Z.pl
│ │ │ │ ├── Zl.pl
│ │ │ │ ├── Zp.pl
│ │ │ │ ├── Zs.pl
│ │ │ │ ├── Zyyy.pl
│ │ │ │ ├── _CanonDC.pl
│ │ │ │ ├── _CaseIgn.pl
│ │ │ │ └── _CombAbo.pl
│ │ │ ├── hst/
│ │ │ │ ├── L.pl
│ │ │ │ ├── LV.pl
│ │ │ │ ├── LVT.pl
│ │ │ │ ├── T.pl
│ │ │ │ └── V.pl
│ │ │ ├── jt/
│ │ │ │ ├── C.pl
│ │ │ │ ├── D.pl
│ │ │ │ ├── R.pl
│ │ │ │ └── U.pl
│ │ │ ├── lb/
│ │ │ │ ├── AI.pl
│ │ │ │ ├── AL.pl
│ │ │ │ ├── B2.pl
│ │ │ │ ├── BA.pl
│ │ │ │ ├── BB.pl
│ │ │ │ ├── BK.pl
│ │ │ │ ├── CB.pl
│ │ │ │ ├── CL.pl
│ │ │ │ ├── CM.pl
│ │ │ │ ├── CR.pl
│ │ │ │ ├── EX.pl
│ │ │ │ ├── GL.pl
│ │ │ │ ├── HY.pl
│ │ │ │ ├── ID.pl
│ │ │ │ ├── IN.pl
│ │ │ │ ├── IS.pl
│ │ │ │ ├── LF.pl
│ │ │ │ ├── NL.pl
│ │ │ │ ├── NS.pl
│ │ │ │ ├── NU.pl
│ │ │ │ ├── OP.pl
│ │ │ │ ├── PO.pl
│ │ │ │ ├── PR.pl
│ │ │ │ ├── QU.pl
│ │ │ │ ├── SA.pl
│ │ │ │ ├── SG.pl
│ │ │ │ ├── SP.pl
│ │ │ │ ├── SY.pl
│ │ │ │ ├── WJ.pl
│ │ │ │ ├── XX.pl
│ │ │ │ └── ZW.pl
│ │ │ └── nt/
│ │ │ ├── De.pl
│ │ │ ├── Di.pl
│ │ │ └── Nu.pl
│ │ ├── mktables
│ │ └── version
│ ├── utf8.pm
│ ├── utf8_heavy.pl
│ ├── util.pm
│ ├── validate.pl
│ ├── vars.pm
│ ├── warnings/
│ │ └── register.pm
│ └── warnings.pm
├── locale.c
├── mg.c
├── mg.h
├── nostdio.h
├── numeric.c
├── op.c
├── op.h
├── opcode.h
├── opnames.h
├── out.txt
├── pad.c
├── pad.h
├── parser-util.c
├── patchlevel.h
├── perl.c
├── perl.h
├── perlapi.c
├── perlapi.h
├── perlio.c
├── perlio.h
├── perliol.h
├── perlmain.c
├── perlsdio.h
├── perlsfio.h
├── perlvars.h
├── perly.c
├── perly.h
├── pfunc.h
├── poll.c
├── poll.h
├── pp.c
├── pp.h
├── pp_ctl.c
├── pp_hot.c
├── pp_pack.c
├── pp_proto.h
├── pp_sort.c
├── pp_sys.c
├── ppport.h
├── proto.h
├── reentr.h
├── reentr.inc
├── regcomp.c
├── regcomp.h
├── regexec.c
├── regexp.h
├── regnodes.h
├── run.c
├── scope.c
├── scope.h
├── spec_config.h
├── specrand.c
├── specrand.h
├── stdio.c
├── sv.c
├── sv.h
├── taint.c
├── thrdvar.h
├── thread.h
├── toke.c
├── tokenpos.h
├── universal.c
├── utf8.c
├── utf8.h
├── utfebcdic.h
├── util.c
├── util.h
├── warnings.h
├── win32/
│ ├── dirent.h
│ ├── netdb.h
│ ├── perlhost.h
│ ├── perllib.c
│ ├── sys/
│ │ └── socket.h
│ ├── vdir.h
│ ├── vmem.h
│ ├── win32.c
│ ├── win32.h
│ ├── win32io.c
│ ├── win32iop.h
│ ├── win32sck.c
│ ├── win32thread.c
│ └── win32thread.h
└── xsutils.c
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
Heap-Layers
DieHard
LLVMStabilizer.so
LLVMStabilizer.dylib
libstabilizer.a
libstabilizer.so
libstabilizer.dylib
runtime/obj
pass/obj
tests/HelloWorld/obj
tests/HelloWorld/hello
tests/libquantum/obj
tests/libquantum/libquantum
tests/bzip2/obj
tests/bzip2/bzip2
tests/perlbench/obj
tests/perlbench/perlbench
tests/perlbench/validate
nbproject
================================================
FILE: .hgignore
================================================
LLVMStabilizer.so
LLVMStabilizer.dylib
libstabilizer.so
libstabilizer.dylib
pass/obj
runtime/obj
tests/HelloWorld/obj
tests/libquantum/obj
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.
================================================
FILE: Makefile
================================================
ROOT = .
DIRS = pass runtime
include $(ROOT)/common.mk
clean::
@$(MAKE) -C tests clean
test: build
@$(MAKE) -C tests test
================================================
FILE: README.md
================================================
## Stabilizer: Statistically Sound Performance Evaluation
[Charlie Curtsinger](https://curtsinger.cs.grinnell.edu/) and [Emery D. Berger](https://www.emeryberger.com)
University of Massachusetts Amherst
### Abstract
Researchers and software developers require effective performance
evaluation. Researchers must evaluate optimizations or measure
overhead. Software developers use automatic performance regression tests to discover when changes improve or degrade performance.
The standard methodology is to compare execution times before and
after applying changes.
Unfortunately, modern architectural features make this approach
unsound. Statistically sound evaluation requires multiple samples
to test whether one can or cannot (with high confidence) reject the
null hypothesis that results are the same before and after. However,
caches and branch predictors make performance dependent on
machine-specific parameters and the exact layout of code, stack
frames, and heap objects. A single binary constitutes just one sample
from the space of program layouts, regardless of the number of runs.
Since compiler optimizations and code changes also alter layout, it
is currently impossible to distinguish the impact of an optimization
from that of its layout effects.
**Stabilizer** is a system that enables the use of
the powerful statistical techniques required for sound performance
evaluation on modern architectures. Stabilizer forces executions
to sample the space of memory configurations by repeatedly rerandomizing layouts of code, stack, and heap objects at runtime.
STABILIZER thus makes it possible to control for layout effects.
Re-randomization also ensures that layout effects follow a Gaussian
distribution, enabling the use of statistical tests like ANOVA. We
demonstrate Stabilizer's’s efficiency (< 7% median overhead) and
its effectiveness by evaluating the impact of LLVM’s optimizations
on the SPEC CPU2006 benchmark suite. We find that, while `-O2`
has a significant impact relative to `-O1`, the performance impact of
`-O3` over `-O2` optimizations is indistinguishable from random noise.
A full description of Stabilizer is available in the
[technical paper](http://www.cs.umass.edu/~emery/pubs/stabilizer-asplos13.pdf), which appeared at
ASPLOS 2013.
See also this [nice blog post](https://fgiesen.wordpress.com/2017/09/02/papers-i-like-part-5/) about this research.
### Building Requirements
_NOTE: This project is no longer being actively maintained, and only works on quite old versions of LLVM._
Stabilizer requires [LLVM 3.1](http://llvm.org/releases/download.html#3.1).
Stabilizer runs on OSX and Linux, and supports x86, x86_64, and PowerPC.
Stabilizer requires LLVM 3.1. Follow the directions
[here](http://clang.llvm.org/get_started.html) to build LLVM 3.1 and the Clang
front-end. Stabilizer's build system assumes LLVM include files will be
accessible through your default include path.
By default, Stabilizer will use GCC and the
[Dragonegg](http://dragonegg.llvm.org/) plugin to produce LLVM IR. Fortran
programs can only be built with the GCC front end. Stabilizer is tested
against GCC version 4.6.2.
Stabilizer's compiler driver `szc` is written in Python. It uses the
`argparse` module, so a relatively modern version of Python (>=2.7) is required.
### Building Stabilizer
```
$ git clone git://github.com/ccurtsinger/stabilizer.git stabilizer
$ make
```
By default, Stabilizer is build with debug output enabled. Run
`make clean release` to build the release version with asserts and debug output
disabled.
### Using Stabilizer
Stabilizer includes the `szc` compiler driver, which builds programs using the
Stabilizer compiler transformations. `szc` passes on common GCC flags, and is
compatible with C, C++ and Fortran inputs.
To compile a program in `foo.c` with Stabilizer, run:
```
$ szc -Rcode -Rstack -Rheap foo.c -o foo
```
The `-R` flags enable randomizations, and may be used in any combination.
Stabilizer uses GCC with the Dragonegg plugin as its default front-end. To
use clang, pass `-frontend=clang` to `szc`.
The resulting executable is linked against with `libstabilizer.so` (or `.dylib`
on OSX). Place this library somewhere in your system's dynamic library search
path or (preferably) add the Stabilizer base directory to your `LD_LIBRARY_PATH`
or `DYLD_LIBRARY_PATH` environment variable.
### SPEC CPU2006
The `szchi.cfg` and `szclo.cfg` config files can be installed in a SPEC CPU2006
config directory to build and run benchmarks with Stabilizer. The szchi config
`-O2` for base and `-O3` for peak tuning, and szclo uses `-O0` and `-O1`.
The `run.py` and `process.py` scripts were used to drive experiments and
collect results. The run script accepts optimization levels, benchmarks to
enable (or disable with a "-" prefix), a number of runs, and build
configurations in any order. For example:
```
$ ./run.py 10 bzip2 code code.stack code.heap.stack
```
This will run the `bzip2` benchmark 10 times in each of three randomization
configurations. The `runspec` tool must be in your path, so `cd` to your SPEC
installation and `sourceh shrc` first.
```
$ ./run.py 10 -astar code link O2 O3
```
This will run every benchmark except `astar` 10 times with link randomization
at `-O2` and `-O3` optimization levels.
Be warned: there is no easy way to distinguish `O2` and `O0` results after the
fact: both are marked as "base" tuning. Keep these results in separate
directories.
The process script reads `.rsf` files from SPEC and provides some summary
statistics, or collects results in an easy-to-process format.
```
$ ./process.py $SPEC/result/*.rsf
```
This will print average runtimes for each benchmark in each configuration and
tuning level for the runs in your SPEC results directory.
Pass the `-trim` flag to remove the highest and lowest runtimes before computing
the average.
The `-norm` flag tests the results for normality using the Shapiro-Wilk test.
The `-all` flag dumps all results to console, suitable for pasting into a
spreadsheet or CSV file.
================================================
FILE: common.mk
================================================
# Get the current OS and architecture
OS ?= $(shell uname -s)
CPU ?= $(shell uname -m)
PLATFORM ?= $(OS).$(CPU)
TARGET_PLATFORM ?= $(PLATFORM)
# Set the default compilers and flags
CC = clang
CXX = clang++
CFLAGS ?= -Os
CXXFLAGS ?= $(CFLAGS)
# Include platform-specific rules
ifneq ($(CROSS_TARGET),)
include $(ROOT)/platforms/$(TARGET_PLATFORM).mk
else
include $(ROOT)/platforms/$(PLATFORM).mk
endif
# Set the default shared library filename suffix
SHLIB_SUFFIX ?= so
# Don't build into subdirectories by default
DIRS ?=
# Don't require any libraries by default
LIBS ?=
# Set the default include directories
INCLUDE_DIRS ?=
# Recurse into subdirectories for the 'clean' and 'build' targets
RECURSIVE_TARGETS ?= clean build
# Build by default
all: debug
# Just remove the targets
clean::
ifneq ($(TARGETS),)
@rm -f $(TARGETS)
endif
# Set the default source and include files with wildcards
SRCS ?= $(wildcard *.c) $(wildcard *.cpp) $(wildcard *.cc) $(wildcard *.C)
OBJS ?= $(addprefix obj/, $(patsubst %.c, %.o, $(patsubst %.cpp, %.o, $(patsubst %.cc, %.o, $(patsubst %.C, %.o, $(SRCS))))))
INCLUDES ?= $(wildcard *.h) $(wildcard *.hpp) $(wildcard *.hh) $(wildcard *.H) $(wildcard $(addsuffix /*.h, $(INCLUDE_DIRS))) $(wildcard $(addsuffix /*.hpp, $(INCLUDE_DIRS))) $(wildcard $(addsuffix /*.hh, $(INCLUDE_DIRS))) $(wildcard $(addsuffix /*.H, $(INCLUDE_DIRS)))
# Clean up objects
clean::
ifneq ($(OBJS),)
@rm -f $(OBJS)
endif
INDENT +=" "
export INDENT
# Generate flags to link required libraries and get includes
LIBFLAGS = $(addprefix -l, $(LIBS))
INCFLAGS = $(addprefix -I, $(INCLUDE_DIRS))
SHARED_LIB_TARGETS = $(filter %.$(SHLIB_SUFFIX), $(TARGETS))
STATIC_LIB_TARGETS = $(filter %.a, $(TARGETS))
OTHER_TARGETS = $(filter-out %.$(SHLIB_SUFFIX), $(filter-out %.a, $(TARGETS)))
release: DEBUG=
release: build
debug: DEBUG=1
debug: build
build:: $(TARGETS) $(INCLUDE_DIRS)
obj/%.o:: %.c Makefile $(ROOT)/common.mk $(INCLUDE_DIRS) $(INCLUDES)
@mkdir -p obj
@echo $(INDENT)[$(notdir $(firstword $(CC)))] Compiling $< for $(if $(DEBUG),Debug,Release) build
@$(CC) $(CFLAGS) $(if $(DEBUG),-g,-DNDEBUG) $(INCFLAGS) -c $< -o $@
obj/%.o:: %.cpp Makefile $(ROOT)/common.mk $(INCLUDE_DIRS) $(INCLUDES)
@mkdir -p obj
@echo $(INDENT)[$(notdir $(firstword $(CXX)))] Compiling $< for $(if $(DEBUG),Debug,Release) build
@$(CXX) $(CXXFLAGS) $(if $(DEBUG),-g,-DNDEBUG) $(INCFLAGS) -c $< -o $@
obj/%.o:: %.cc Makefile $(ROOT)/common.mk $(INCLUDE_DIRS) $(INCLUDES)
@mkdir -p obj
@echo $(INDENT)[$(notdir $(firstword $(CXX)))] Compiling $< for $(if $(DEBUG),Debug,Release) build
@$(CXX) $(CXXFLAGS) $(if $(DEBUG),-g,-DNDEBUG) $(INCFLAGS) -c $< -o $@
obj/%.o:: %.C Makefile $(ROOT)/common.mk $(INCLUDE_DIRS) $(INCLUDES)
@mkdir -p obj
@echo $(INDENT)[$(notdir $(firstword $(CXX)))] Compiling $< for $(if $(DEBUG),Debug,Release) build
@$(CXX) $(CXXFLAGS) $(if $(DEBUG),-g,-DNDEBUG) $(INCFLAGS) -c $< -o $@
$(SHARED_LIB_TARGETS):: $(OBJS) $(INCLUDE_DIRS) $(INCLUDES) Makefile $(ROOT)/common.mk
@echo $(INDENT)[$(notdir $(firstword $(CXXLIB)))] Linking $@ for $(if $(DEBUG),Debug,Release) build
@$(CXXLIB) $(CXXFLAGS) $(INCFLAGS) $(OBJS) -o $@ $(LIBFLAGS)
$(STATIC_LIB_TARGETS):: $(OBJS) $(INCLUDE_DIRS) $(INCLUDES) Makefile $(ROOT)/common.mk
@echo $(INDENT)[ar] Linking $@ for $(if $(DEBUG),Debug,Release) build
@ar rcs $@ $(OBJS)
$(OTHER_TARGETS):: $(OBJS) $(INCLUDE_DIRS) $(INCLUDES) Makefile $(ROOT)/common.mk
@echo $(INDENT)[$(notdir $(firstword $(CXX)))] Linking $@ for $(if $(DEBUG),Debug,Release) build
@$(CXX) $(CXXFLAGS) $(if $(DEBUG),-g,-DNDEBUG) $(INCFLAGS) $(OBJS) -o $@ $(LIBFLAGS)
$(RECURSIVE_TARGETS)::
@for dir in $(DIRS); do \
echo "$(INDENT)[$@] Entering $$dir"; \
$(MAKE) -C $$dir $@ DEBUG=$(DEBUG); \
done
$(ROOT)/Heap-Layers:
@ echo $(INDENT)[git] Checking out Heap-Layers
@rm -rf $(ROOT)/Heap-Layers
@git clone https://github.com/emeryberger/Heap-Layers.git $(ROOT)/Heap-Layers
$(ROOT)/DieHard/src/include $(ROOT)/DieHard/src/include/math $(ROOT)/DieHard/src/include/rng $(ROOT)/DieHard/src/include/static $(ROOT)/DieHard/src/include/util:
@echo $(INDENT)[git] Checking out DieHard
@rm -rf $(ROOT)/DieHard
@git clone https://github.com/emeryberger/DieHard.git $(ROOT)/DieHard
================================================
FILE: pass/IntrinsicLibcalls.h
================================================
/*
* IntrinsicLibcalls.h
*
* Created on: Apr 2, 2010
* Author: charlie
*/
#ifndef INTRINSICLIBCALLS_H_
#define INTRINSICLIBCALLS_H_
#include <map>
#include <set>
using namespace std;
using namespace llvm;
map<StringRef, StringRef> libcall_map;
set<StringRef> inlined;
void InitLibcalls() {
inlined.insert("llvm.va_start");
inlined.insert("llvm.va_copy");
inlined.insert("llvm.va_end");
inlined.insert("llvm.dbg.declare");
inlined.insert("llvm.dbg.value");
inlined.insert("llvm.expect.i8");
inlined.insert("llvm.expect.i16");
inlined.insert("llvm.expect.i32");
inlined.insert("llvm.expect.i64");
inlined.insert("llvm.uadd.with.overflow.i32");
inlined.insert("llvm.objectsize.i8");
inlined.insert("llvm.objectsize.i16");
inlined.insert("llvm.objectsize.i32");
inlined.insert("llvm.objectsize.i64");
inlined.insert("llvm.bswap.i8");
inlined.insert("llvm.bswap.i16");
inlined.insert("llvm.bswap.i32");
inlined.insert("llvm.stacksave");
inlined.insert("llvm.stackrestore");
inlined.insert("llvm.trap");
inlined.insert("llvm.uadd.with.overflow.i64");
inlined.insert("llvm.umul.with.overflow.i64");
inlined.insert("llvm.eh.exception");
inlined.insert("llvm.eh.selector");
inlined.insert("llvm.lifetime.start");
inlined.insert("llvm.lifetime.end");
libcall_map["llvm.memcpy.p0i8.p0i8.i8"] = "memcpy";
libcall_map["llvm.memcpy.p0i8.p0i8.i16"] = "memcpy";
libcall_map["llvm.memcpy.p0i8.p0i8.i32"] = "memcpy";
libcall_map["llvm.memcpy.p0i8.p0i8.i64"] = "memcpy";
libcall_map["llvm.memcpy.i8"] = "memcpy";
libcall_map["llvm.memcpy.i16"] = "memcpy";
libcall_map["llvm.memcpy.i32"] = "memcpy";
libcall_map["llvm.memcpy.i64"] = "memcpy";
libcall_map["llvm.memmove.p0i8.p0i8.i8"] = "memmove";
libcall_map["llvm.memmove.p0i8.p0i8.i16"] = "memmove";
libcall_map["llvm.memmove.p0i8.p0i8.i32"] = "memmove";
libcall_map["llvm.memmove.p0i8.p0i8.i64"] = "memmove";
libcall_map["llvm.memmove.i8"] = "memmove";
libcall_map["llvm.memmove.i16"] = "memmove";
libcall_map["llvm.memmove.i32"] = "memmove";
libcall_map["llvm.memmove.i64"] = "memmove";
libcall_map["llvm.memset.p0i8.i8"] = "memset_i8";
libcall_map["llvm.memset.p0i8.i16"] = "memset_i16";
libcall_map["llvm.memset.p0i8.i32"] = "memset_i32";
libcall_map["llvm.memset.p0i8.i64"] = "memset_i64";
libcall_map["llvm.memset.i8"] = "memset_i8";
libcall_map["llvm.memset.i16"] = "memset_i16";
libcall_map["llvm.memset.i32"] = "memset_i32";
libcall_map["llvm.memset.i64"] = "memset_i64";
libcall_map["llvm.sqrt.f32"] = "sqrtf";
libcall_map["llvm.sqrt.f64"] = "sqrt";
libcall_map["llvm.sqrt.f80"] = "sqrtl";
libcall_map["llvm.log.f32"] = "logf";
libcall_map["llvm.log.f64"] = "log";
libcall_map["llvm.log.f80"] = "logl";
libcall_map["llvm.exp.f32"] = "expf";
libcall_map["llvm.exp.f64"] = "exp";
libcall_map["llvm.exp.f80"] = "expl";
libcall_map["llvm.pow.f32"] = "powf";
libcall_map["llvm.pow.f64"] = "pow";
libcall_map["llvm.pow.f80"] = "powl";
libcall_map["llvm.powi.f32"] = "powif";
libcall_map["llvm.powi.f64"] = "powif";
libcall_map["llvm.powi.f80"] = "powil";
libcall_map["llvm.log10.f32"] = "log10f";
libcall_map["llvm.log10.f64"] = "log10";
libcall_map["llvm.log10.f80"] = "log10l";
}
bool isAlwaysInlined(StringRef intrinsic) {
return inlined.find(intrinsic) != inlined.end();
}
StringRef GetLibcall(StringRef intrinsic) {
return libcall_map[intrinsic];
map<StringRef, StringRef>::iterator i = libcall_map.find(intrinsic);
if(i == libcall_map.end()) {
return "";
} else {
return i->second;
}
}
#endif /* INTRINSICLIBCALLS_H_ */
================================================
FILE: pass/LowerIntrinsics.cpp
================================================
#define DEBUG_TYPE "lower_intrinsics"
#include <iostream>
#include <set>
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Instructions.h"
#include "llvm/Support/raw_ostream.h"
#include "IntrinsicLibcalls.h"
using namespace std;
using namespace llvm;
struct LowerIntrinsics: public ModulePass {
static char ID;
LowerIntrinsics() : ModulePass(ID) {
}
virtual bool runOnModule(Module &m) {
InitLibcalls();
set<Function*> toDelete;
for(Module::iterator fun = m.begin(); fun != m.end(); fun++) {
llvm::Function &f = *fun;
if(f.isIntrinsic() && !isAlwaysInlined(f.getName())) {
StringRef r = GetLibcall(f.getName());
if(!r.empty()) {
Function *f_extern = m.getFunction(r);
if(!f_extern) {
f_extern = Function::Create(
f.getFunctionType(),
Function::ExternalLinkage,
r,
&m
);
}
f.replaceAllUsesWith(f_extern);
toDelete.insert(&f);
} else {
errs()<<"warning: unable to handle intrinsic "<<f.getName().str()<<"\n";
}
}
}
for(set<Function*>::iterator iter = toDelete.begin(); iter != toDelete.end(); iter++) {
(*iter)->eraseFromParent();
}
return true;
}
};
char LowerIntrinsics::ID = 0;
static RegisterPass<LowerIntrinsics> X("lower-intrinsics", "Replace all intrinsics with direct libcalls");
================================================
FILE: pass/Makefile
================================================
ROOT = ..
TARGETS = $(ROOT)/LLVMStabilizer.$(SHLIB_SUFFIX)
LIBS =
include $(ROOT)/common.mk
CXXFLAGS += -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -fno-exceptions -fno-rtti -fno-common
================================================
FILE: pass/Stabilizer.cpp
================================================
#define DEBUG_TYPE "stabilizer"
#include <llvm/Pass.h>
#include <llvm/Module.h>
#include <llvm/Constants.h>
#include <llvm/Intrinsics.h>
#include <llvm/Instructions.h>
#include <llvm/Support/raw_ostream.h>
#include <llvm/Support/CommandLine.h>
#include <llvm/Support/TypeBuilder.h>
#include <map>
#include <set>
#include <vector>
#include <llvm/Intrinsics.gen>
using namespace llvm;
using namespace llvm::types;
using namespace llvm::cl;
using namespace std;
enum {
ALIGN = 64
};
// Randomization configuration options
opt<bool> stabilize_heap ("stabilize-heap", init(false), desc("Randomize heap object placement"));
opt<bool> stabilize_stack ("stabilize-stack", init(false), desc("Randomize stack frame placement"));
opt<bool> stabilize_code ("stabilize-code", init(false), desc("Randomize function placement"));
struct StabilizerPass : public ModulePass {
static char ID;
Function* registerFunction;
Function* registerConstructor;
Function* registerStackPad;
StabilizerPass() : ModulePass(ID) {}
enum Platform {
x86_64,
x86_32,
PowerPC,
INVALID
};
/**
* \brief Get the architecture targeted by a given module
* \arg m The module being transformed
* \returns A Platform value
*/
Platform getPlatform(Module& m) {
string triple = m.getTargetTriple();
// Convert the target-triple to lowercase using C++'s elegant, intuitive API
transform(triple.begin(), triple.end(), triple.begin(), ::tolower);
if(triple.find("x86_64") != string::npos
|| triple.find("amd64") != string::npos) {
return x86_64;
} else if(triple.find("i386") != string::npos
|| triple.find("i486") != string::npos
|| triple.find("i586") != string::npos
|| triple.find("i686") != string::npos) {
return x86_32;
} else if(triple.find("powerpc") != string::npos) {
return PowerPC;
} else {
return INVALID;
}
}
/**
* \brief Get the intptr_t type for the given platform
* \arg m The module being transformed
* \returns The width of a pointer in bits
*/
Type* getIntptrType(Module& m) {
if(m.getPointerSize() == Module::Pointer32) {
return Type::getInt32Ty(m.getContext());
} else {
return Type::getInt64Ty(m.getContext());
}
}
size_t getIntptrSize(Module& m) {
if(m.getPointerSize() == Module::Pointer32) {
return 32;
} else {
return 64;
}
}
Constant* getInt(Module& m, size_t bits, uint64_t value, bool is_signed) {
return Constant::getIntegerValue(Type::getIntNTy(m.getContext(), bits), APInt(bits, value, is_signed));
}
Constant* getIntptr(Module& m, uint64_t value, bool is_signed) {
return getInt(m, getIntptrSize(m), value, is_signed);
}
/**
* \brief Check if the target platform uses PC-relative addressing for data
* \arg m The module being transformed
* \returns true if the platform supports PC-relative data addressing modes
*/
bool isDataPCRelative(Module& m) {
switch(getPlatform(m)) {
case x86_64:
return true;
case x86_32:
case PowerPC:
return false;
default:
return true;
}
}
/**
* \brief Entry point for the Stabilizer compiler pass
* \arg m The module being transformed
* \returns whether or not the module was modified (always true)
*/
virtual bool runOnModule(Module &m) {
// Replace calls to heap functions with Stabilizer's random heap
if(stabilize_heap) {
randomizeHeap(m);
}
// Build a set of locally-defined functions
set<Function*> local_functions;
for(Module::iterator f = m.begin(); f != m.end(); f++) {
if(!f->isIntrinsic()
&& !f->isDeclaration()
&& !f->getName().equals("__gxx_personality_v0")) {
local_functions.insert(&*f);
}
}
declareRuntimeFunctions(m);
map<Function*, GlobalVariable*> stackPads;
// Declare the stack pad table type
Type* stackPadType = Type::getInt8Ty(m.getContext());
// Enable stack randomization
if(stabilize_stack) {
// Transform each function
for(set<Function*>::iterator f_iter = local_functions.begin(); f_iter != local_functions.end(); f_iter++) {
Function* f = *f_iter;
// Create the stack pad table
GlobalVariable* pad = new GlobalVariable(
m,
stackPadType,
false,
GlobalValue::InternalLinkage,
getInt(m, 8, 0, false),
f->getName()+".stack_pad"
);
stackPads[f] = pad;
randomizeStack(m, *f, pad);
}
}
// Get any existing module constructors
vector<Value*> old_ctors = getConstructors(m);
// Create a new constructor
Function* ctor = makeConstructor(m, "stabilizer.module_ctor");
BasicBlock* ctor_bb = BasicBlock::Create(m.getContext(), "", ctor);
// Enable code randomization
if(stabilize_code) {
// Transform each function and register it with the stabilizer runtime
for(set<Function*>::iterator f_iter = local_functions.begin();
f_iter != local_functions.end(); f_iter++) {
Function* f = *f_iter;
vector<Value*> args = randomizeCode(m, *f);
Value* table = stackPads[f];
if(table == NULL) {
table = Constant::getNullValue(PointerType::get(stackPadType, 0));
}
args.push_back(table);
CallInst::Create(registerFunction, args, "", ctor_bb);
}
}
// Register each existing constructor with the stabilizer runtime
for(vector<Value*>::iterator ctor_iter = old_ctors.begin(); ctor_iter != old_ctors.end(); ctor_iter++) {
vector<Value*> args;
args.push_back(*ctor_iter);
CallInst::Create(registerConstructor, args, "", ctor_bb);
}
// If we're not randomizing code, declare the stack tables by themselves
if(stabilize_stack && !stabilize_code) {
for(map<Function*, GlobalVariable*>::iterator iter = stackPads.begin(); iter != stackPads.end(); iter++) {
vector<Value*> args;
args.push_back(iter->second);
CallInst::Create(registerStackPad, args, "", ctor_bb);
}
}
ReturnInst::Create(m.getContext(), ctor_bb);
Function *main = m.getFunction("main");
if(main != NULL) {
main->setName("stabilizer_main");
}
return true;
}
/**
* \brief Get a list of module constructors
* \arg m The module to scan
*/
vector<Value*> getConstructors(Module& m) {
vector<Value*> result;
// Get the constructor table
GlobalVariable *ctors = m.getGlobalVariable("llvm.global_ctors", false);
// If not found, there aren't any constructors
if(ctors != NULL) {
// Get the constructor table initializer
Constant* initializer = ctors->getInitializer();
if(isa<ConstantArray>(initializer)) {
ConstantArray* table = dyn_cast<ConstantArray>(initializer);
// Get each entry in the table
for(ConstantArray::op_iterator i = table->op_begin(); i != table->op_end(); i++) {
ConstantStruct* entry = dyn_cast<ConstantStruct>(i->get());
Constant* f = entry->getOperand(1);
result.push_back(f);
}
} else {
// Must be an empty ctor table...
}
}
return result;
}
/**
* \brief Create a single module constructor
* Replaces any existing constructors
* \arg m The module to add a constructor to
* \arg name The name of the new constructor function
* \returns The new constructor function
*/
Function* makeConstructor(Module& m, StringRef name) {
// Void type
Type* void_t = Type::getVoidTy(m.getContext());
// 32 bit integer type
Type* i32_t = Type::getInt32Ty(m.getContext());
// Constructor function type
FunctionType* ctor_fn_t = FunctionType::get(void_t, false);
PointerType* ctor_fn_p_t = PointerType::get(ctor_fn_t, 0);
// Constructor table entry type
StructType* ctor_entry_t = StructType::get(i32_t, ctor_fn_p_t, NULL);
// Create constructor function
Function* init = Function::Create(ctor_fn_t, Function::InternalLinkage, name, &m);
// Sequence of constructor table entries
vector<Constant*> ctor_entries;
// Add the entry for the new constructor
ctor_entries.push_back(
ConstantStruct::get(ctor_entry_t,
ConstantInt::get(i32_t, 65535, false),
init,
NULL
)
);
// set up the constant initializer for the new constructor table
Constant *ctor_array_const = ConstantArray::get(
ArrayType::get(
ctor_entries[0]->getType(),
ctor_entries.size()
),
ctor_entries
);
// create the new constructor table
GlobalVariable *new_ctors = new GlobalVariable(
m,
ctor_array_const->getType(),
true,
GlobalVariable::AppendingLinkage,
ctor_array_const,
""
);
// Get the existing constructor array from the module, if any
GlobalVariable *ctors = m.getGlobalVariable("llvm.global_ctors", false);
// give the new constructor table the appropriate name, taking it from the current table if one exists
if(ctors) {
new_ctors->takeName(ctors);
ctors->setName("old.llvm.global_ctors");
ctors->setLinkage(GlobalVariable::PrivateLinkage);
ctors->eraseFromParent();
} else {
new_ctors->setName("llvm.global_ctors");
}
return init;
}
/**
* \brief Randomize the program stack on each function call
* Adds a random pad (obtained from the Stabilizer runtime) to the stack
* pointer prior to each function call, then restores the stack after the call.
*
* \arg m The module being transformed
* \arg f The function being transformed
*/
void randomizeStack(Module& m, llvm::Function& f, GlobalVariable* stackPad) {
Function* stacksave = Intrinsic::getDeclaration(&m, Intrinsic::stacksave);
Function* stackrestore = Intrinsic::getDeclaration(&m, Intrinsic::stackrestore);
// Get all the callsites in this function
vector<CallInst*> calls;
for(Function::iterator b_iter = f.begin(); b_iter != f.end(); b_iter++) {
BasicBlock& b = *b_iter;
for(BasicBlock::iterator i_iter = b.begin(); i_iter != b.end(); i_iter++) {
Instruction& i = *i_iter;
if(isa<CallInst>(&i)) {
CallInst* c = dyn_cast<CallInst>(&i);
calls.push_back(c);
}
}
}
//////////////////////////////////
// Pad the stack before each callsite
for(vector<CallInst*>::iterator c_iter = calls.begin(); c_iter != calls.end(); c_iter++) {
CallInst* c = *c_iter;
Instruction* next = c->getNextNode();
// Load the stack pad size and widen it to an intptr
Value* pad = new LoadInst(stackPad, "pad", c);
Value* wide_pad = ZExtInst::CreateZExtOrBitCast(pad, getIntptrType(m), "", c);
// Multiply the pad by the required stack alignment
BinaryOperator* padSize = BinaryOperator::CreateNUWMul(
wide_pad,
getIntptr(m, 16, false),
"aligned_pad",
c
);
CallInst* oldStack = CallInst::Create(stacksave, "", c);
PtrToIntInst* oldStackInt = new PtrToIntInst(oldStack, getIntptrType(m), "", c);
BinaryOperator* newStackInt = BinaryOperator::CreateSub(oldStackInt, padSize, "", c);
IntToPtrInst* newStack = new IntToPtrInst(newStackInt, Type::getInt8PtrTy(m.getContext()), "", c);
vector<Value*> newStackArgs;
newStackArgs.push_back(newStack);
CallInst::Create(stackrestore, newStackArgs, "", c);
vector<Value*> oldStackArgs;
oldStackArgs.push_back(oldStack);
CallInst::Create(stackrestore, oldStackArgs, "", next);
}
}
/**
* \brief Transform a function to reference globals only through a relocation table.
*
* \arg m The module being transformed
* \arg f The function being transformed
* \returns The arguments to be passed to stabilizer_register_function
*/
vector<Value*> randomizeCode(Module& m, Function& f) {
// Add a dummy function used to compute the size
Function* next = Function::Create(
FunctionType::get(Type::getVoidTy(m.getContext()), false),
GlobalValue::InternalLinkage,
"stabilizer.dummy."+f.getName()
);
// Align the following function to a cache line to avoid mixing code/data in cache
next->setAlignment(ALIGN);
// Put a basic block and return instruction into the dummy function
BasicBlock *dummy_block = BasicBlock::Create(m.getContext(), "", next);
ReturnInst::Create(m.getContext(), dummy_block);
// Ensure the dummy is placed immediately after our function
if(f.getNextNode() == NULL) {
m.getFunctionList().setNext(&f, next);
m.getFunctionList().addNodeToList(next);
} else {
m.getFunctionList().setNext(next, f.getNextNode());
m.getFunctionList().setNext(&f, next);
m.getFunctionList().addNodeToList(next);
}
// Remove stack protection (creates implicit global references)
f.removeFnAttr(Attribute::StackProtect);
f.removeFnAttr(Attribute::StackProtectReq);
// Remove linkonce_odr linkage
if(f.getLinkage() == GlobalValue::LinkOnceODRLinkage) {
f.setLinkage(GlobalValue::ExternalLinkage);
}
// Replace some floating point operations with calls to un-randomized functions
//if(isDataPCRelative(m)) {
// Always do this--required on PowerPC
extractFloatOperations(f);
//}
// Collect all the referenced global values in this function
map<Constant*, set<Use*> > references = findPCRelativeUsesIn(f);
if(references.size() > 0) {
// Build an ordered list of referenced constants
vector<Constant*> referencedValues;
for(map<Constant*, set<Use*> >::iterator p_iter = references.begin();
p_iter != references.end(); p_iter++) {
pair<Constant*, set<Use*> > p = *p_iter;
referencedValues.push_back(p.first);
}
// Create an ordered list of types for the referenced constants
vector<Type*> referencedTypes;
for(vector<Constant*>::iterator c_iter = referencedValues.begin();
c_iter != referencedValues.end(); c_iter++) {
Constant* c = *c_iter;
referencedTypes.push_back(c->getType());
}
// Create the struct type for the relocation table
StructType* relocationTableType = StructType::create(
referencedTypes,
(f.getName()+".relocation_table_t").str(),
false
);
// Create the relocation table global variable
GlobalVariable* relocationTable = new GlobalVariable(
m,
relocationTableType,
false, // No, the table needs to be mutable
GlobalVariable::InternalLinkage,
ConstantStruct::get(relocationTableType, referencedValues),
f.getName()+".relocation_table"
);
// The referenced relocation table may not be the global one (for PC-relative data)
Constant* actualRelocationTable = relocationTable;
// Cast next-function pointer to the relocation table type for PC-relative data
if(isDataPCRelative(m)) {
Type* ptr = PointerType::get(relocationTableType, 0);
actualRelocationTable = ConstantExpr::getPointerCast(next, ptr);
}
// Rewrite global references to use the relocation table
size_t index = 0;
for(vector<Constant*>::iterator c_iter = referencedValues.begin(); c_iter != referencedValues.end(); c_iter++) {
Constant* c = *c_iter;
for(set<Use*>::iterator u_iter = references[c].begin();
u_iter != references[c].end(); u_iter++) {
Use* u = *u_iter;
Instruction* insertion_point = dyn_cast<Instruction>(u->getUser());
assert(insertion_point != NULL && "Only instruction uses can be rewritten");
if(isa<PHINode>(insertion_point)) {
PHINode* phi = dyn_cast<PHINode>(insertion_point);
BasicBlock *incoming = phi->getIncomingBlock(*u);
insertion_point = incoming->getTerminator();
}
// Get the relocation table slot
vector<Constant*> indices;
indices.push_back(Constant::getIntegerValue(Type::getInt32Ty(m.getContext()), APInt(32, 0, false)));
indices.push_back(Constant::getIntegerValue(Type::getInt32Ty(m.getContext()), APInt(32, (uint64_t)index, false)));
Constant* slot = ConstantExpr::getGetElementPtr(
actualRelocationTable,
indices,
true // Yes, it is in bounds
);
Value* loaded = new LoadInst(
slot,
c->getName()+".indirect",
insertion_point
);
u->set(loaded);
}
index++;
}
vector<Value*> args;
// The function base
args.push_back(ConstantExpr::getPointerCast(&f, Type::getInt8PtrTy(m.getContext())));
// The function limit
args.push_back(ConstantExpr::getPointerCast(next, Type::getInt8PtrTy(m.getContext())));
// The global relocation table
args.push_back(ConstantExpr::getPointerCast(relocationTable, Type::getInt8PtrTy(m.getContext())));
// The size of the relocation table
args.push_back(ConstantExpr::getIntegerCast(ConstantExpr::getSizeOf(relocationTableType), Type::getInt32Ty(m.getContext()), false));
// If true, the function uses an adjacent relocation table, not the global
args.push_back(Constant::getIntegerValue(Type::getInt1Ty(m.getContext()), APInt(1, isDataPCRelative(m), false)));
return args;
} else {
vector<Value*> args;
// The function base
args.push_back(ConstantExpr::getPointerCast(&f, Type::getInt8PtrTy(m.getContext())));
// The function limit
args.push_back(ConstantExpr::getPointerCast(next, Type::getInt8PtrTy(m.getContext())));
// The global relocation table (null)
args.push_back(Constant::getNullValue(Type::getInt8PtrTy(m.getContext())));
// The size of the relocation table (0)
args.push_back(Constant::getIntegerValue(Type::getInt32Ty(m.getContext()), APInt(32, 0, false)));
// PC-relative data? Doesn't matter
args.push_back(Constant::getIntegerValue(Type::getInt1Ty(m.getContext()), APInt(1, 0, false)));
return args;
}
}
/**
* Check if a value is or contains a global value.
*/
bool containsGlobal(Value* v) {
if(isa<Function>(v)) {
Function* f = dyn_cast<Function>(v);
if(f->isIntrinsic() || f->getName().equals("__gxx_personality_v0")) {
return false;
} else {
return true;
}
} else if(isa<GlobalValue>(v)) {
return true;
} else if(isa<ConstantExpr>(v)) {
ConstantExpr* e = dyn_cast<ConstantExpr>(v);
for(ConstantExpr::op_iterator use = e->op_begin(); use != e->op_end(); use++) {
if(containsGlobal(use->get())) {
return true;
}
}
}
return false;
}
/**
* \brief Find all uses inside instructions that may result in PC-relative addressing.
*
* \arg f The function to scan for PC-relative uses
* \returns A map of all used values, each with a set of uses
*/
map<Constant*, set<Use*> > findPCRelativeUsesIn(Function& f) {
map<Constant*, set<Use*> > result;
for(Function::iterator b = f.begin(); b != f.end(); b++) {
for(BasicBlock::iterator i_iter = b->begin(); i_iter != b->end(); i_iter++) {
Instruction* i = &*i_iter;
if(isa<PHINode>(i)) {
PHINode* phi = dyn_cast<PHINode>(i);
for(size_t index = 0; index < phi->getNumIncomingValues(); index++) {
Value* operand = phi->getIncomingValue(index);
if(isa<Constant>(operand) && containsGlobal(operand)) {
Constant* c = dyn_cast<Constant>(operand);
if(result.find(c) == result.end()) {
result[c] = set<Use*>();
}
size_t operand_index = phi->getOperandNumForIncomingValue(index);
Use& use = phi->getOperandUse(operand_index);
result[c].insert(&use);
}
}
} else {
// TODO: only process control flow targets on platforms that don't have PC-relative data addressing
for(Instruction::op_iterator use = i->op_begin(); use != i->op_end(); use++) {
Value* operand = use->get();
if(isa<Constant>(operand) && containsGlobal(operand)) {
Constant* c = dyn_cast<Constant>(operand);
if(result.find(c) == result.end()) {
result[c] = set<Use*>();
}
result[c].insert(use);
}
}
}
}
}
return result;
}
/**
* \brief Replace certain floating point operations with function calls.
* Some floating point operations (definitely int-to-float and float-to-int)
* create implicit references to floating point constants. Replace these
* with function calls so they don't produce PC-relative data references in
* randomizable code.
*
* \arg f The function to scan for floating point operations
*/
void extractFloatOperations(Function& f) {
Module& m = *f.getParent();
vector<Instruction*> to_delete;
for(Function::iterator b_iter = f.begin(); b_iter != f.end(); b_iter++) {
BasicBlock& b = *b_iter;
for(BasicBlock::iterator i_iter = b.begin(); i_iter != b.end(); i_iter++) {
Instruction& i = *i_iter;
if(isa<FPToSIInst>(&i)
|| isa<FPToUIInst>(&i)
|| isa<SIToFPInst>(&i)
|| isa<UIToFPInst>(&i)
|| (isa<FPTruncInst>(&i) && getPlatform(m) == PowerPC)) {
Function* f = getFloatConversion(m, i.getOpcode(), i.getOperand(0)->getType(), i.getType());
vector<Value*> args;
args.push_back(i.getOperand(0));
CallInst *ci = CallInst::Create(f, ArrayRef<Value*>(args), "", &i);
i.replaceAllUsesWith(ci);
to_delete.push_back(&i);
} else {
for(Instruction::op_iterator op_iter = i.op_begin(); op_iter != i.op_end(); op_iter++) {
Value* op = *op_iter;
if(isa<Constant>(op)) {
Constant* c = dyn_cast<Constant>(op);
if(containsConstantFloat(c)) {
Type* t = op->getType();
GlobalVariable* g = new GlobalVariable(m, t, true, GlobalVariable::InternalLinkage, c, "fconst");
Instruction* insertion_point = &i;
if(isa<PHINode>(insertion_point)) {
PHINode* phi = dyn_cast<PHINode>(insertion_point);
BasicBlock *incoming = phi->getIncomingBlock(*op_iter);
insertion_point = incoming->getTerminator();
}
LoadInst* load = new LoadInst(g, "fconst.load", insertion_point);
op_iter->set(load);
}
}
}
}
}
}
for(vector<Instruction*>::iterator i_iter = to_delete.begin();
i_iter != to_delete.end(); i_iter++) {
Instruction* i = *i_iter;
i->eraseFromParent();
}
}
/**
* \brief Check if a constant value contains a floating point constant
* \arg c The constant to check
* \returns true if c is a ConstantFP or contains a ConstantFP
*/
bool containsConstantFloat(Constant* c) {
if(isa<ConstantFP>(c)) {
return true;
} else if(isa<ConstantExpr>(c)) {
for(Constant::op_iterator op_iter = c->op_begin(); op_iter != c->op_end(); op_iter++) {
Constant* op = dyn_cast<Constant>(op_iter->get());
if(containsConstantFloat(op)) {
return true;
}
}
}
return false;
}
/**
* \brief Get a function to convert between floating point and integer types
* Extracts floating point conversion operations into an unrandomized function,
* which sidesteps issues caused by implicit global references by the ftosi,
* ftoui, uitof, and sitof instructions.
*
* \arg m The module being processed
* \arg in The type of the input value (some float or int type)
* \arg out The type of the output value (some float or int type)
* \arg is_signed If true, the function should generate a signed integer conversion
* \returns A pointer to a function that performs the required type conversion
*/
Function* getFloatConversion(Module& m, unsigned opcode, Type* in, Type* out) {
// LLVM stream bullshit
string name;
raw_string_ostream ss(name);
if(opcode == Instruction::FPToUI) {
ss << "fptoui";
} else if(opcode == Instruction::FPToSI) {
ss << "fptosi";
} else if(opcode == Instruction::UIToFP) {
ss << "uitofp";
} else if(opcode == Instruction::SIToFP) {
ss << "sitofp";
} else if(opcode == Instruction::FPTrunc) {
ss << "fptrunc";
} else {
errs() << "Invalid float conversion arguments\n";
errs() << " opcode: " << opcode << "\n";
errs() << " in: ";
in->print(errs());
errs() << "\n";
errs() << " out: ";
out->print(errs());
errs() << "\n";
abort();
}
// Include in and out types in the function name
ss<<".";
in->print(ss);
ss<<".";
out->print(ss);
// Check the module for a function with this name
Function *f = m.getFunction(ss.str());
// If not found, create the function
if(f == NULL) {
vector<Type*> params;
params.push_back(in);
f = Function::Create(
FunctionType::get(out, params, false),
Function::InternalLinkage,
ss.str(),
&m
);
BasicBlock *b = BasicBlock::Create(m.getContext(), "", f);
Instruction *r;
// Insert the required conversion instruction
if(opcode == Instruction::FPToUI) {
r = new FPToUIInst(&*f->arg_begin(), out, "", b);
} else if(opcode == Instruction::FPToSI) {
r = new FPToSIInst(&*f->arg_begin(), out, "", b);
} else if(opcode == Instruction::UIToFP) {
r = new UIToFPInst(&*f->arg_begin(), out, "", b);
} else if(opcode == Instruction::SIToFP) {
r = new SIToFPInst(&*f->arg_begin(), out, "", b);
} else if(opcode == Instruction::FPTrunc) {
r = new FPTruncInst(&*f->arg_begin(), out, "", b);
}
ReturnInst::Create(m.getContext(), r, b);
}
return f;
}
/**
* \brief Replace all heap calls with references to Stabilizer's randomized
* heap.
*
* \arg m The module to transform
*/
void randomizeHeap(Module& m) {
Function *malloc_fn = m.getFunction("malloc");
Function *calloc_fn = m.getFunction("calloc");
Function *realloc_fn = m.getFunction("realloc");
Function *free_fn = m.getFunction("free");
if(malloc_fn) {
Function *stabilizer_malloc = Function::Create(
malloc_fn->getFunctionType(),
Function::ExternalLinkage,
"stabilizer_malloc",
&m
);
malloc_fn->replaceAllUsesWith(stabilizer_malloc);
}
if(calloc_fn) {
Function *stabilizer_calloc = Function::Create(
calloc_fn->getFunctionType(),
Function::ExternalLinkage,
"stabilizer_calloc",
&m
);
calloc_fn->replaceAllUsesWith(stabilizer_calloc);
}
if(realloc_fn) {
Function *stabilizer_realloc = Function::Create(
realloc_fn->getFunctionType(),
Function::ExternalLinkage,
"stabilizer_realloc",
&m
);
realloc_fn->replaceAllUsesWith(stabilizer_realloc);
}
if(free_fn) {
Function *stabilizer_free = Function::Create(
free_fn->getFunctionType(),
Function::ExternalLinkage,
"stabilizer_free",
&m
);
free_fn->replaceAllUsesWith(stabilizer_free);
}
}
/**
* \brief Declare all of Stabilizer's runtime functions
* \arg m The module to transform
*/
void declareRuntimeFunctions(Module& m) {
// Declare the register_function runtime function
vector<Type*> register_function_params;
register_function_params.push_back(Type::getInt8PtrTy(m.getContext()));
register_function_params.push_back(Type::getInt8PtrTy(m.getContext()));
register_function_params.push_back(Type::getInt8PtrTy(m.getContext()));
register_function_params.push_back(Type::getInt32Ty(m.getContext()));
register_function_params.push_back(Type::getInt1Ty(m.getContext()));
register_function_params.push_back(PointerType::get(Type::getInt8Ty(m.getContext()), 0));
registerFunction = Function::Create(
FunctionType::get(Type::getVoidTy(m.getContext()), register_function_params, false),
Function::ExternalLinkage,
"stabilizer_register_function",
&m
);
registerFunction->addFnAttr(Attribute::NonLazyBind);
// Declare the register_constructor runtime function
registerConstructor = Function::Create(
TypeBuilder<void(void()), true>::get(m.getContext()),
Function::ExternalLinkage,
"stabilizer_register_constructor",
&m
);
registerConstructor->addFnAttr(Attribute::NonLazyBind);
// Declare the register_stack_table runtime function
vector<Type*> params;
params.push_back(PointerType::get(Type::getInt8Ty(m.getContext()), 0));
registerStackPad = Function::Create(
FunctionType::get(Type::getVoidTy(m.getContext()), params, false),
Function::ExternalLinkage,
"stabilizer_register_stack_pad",
&m
);
registerStackPad->addFnAttr(Attribute::NonLazyBind);
}
};
char StabilizerPass::ID = 0;
static RegisterPass<StabilizerPass> X("stabilize", "Add support for runtime randomization of program layout");
================================================
FILE: platforms/Darwin.i386.mk
================================================
include $(ROOT)/platforms/Darwin.x86_64.mk
CFLAGS += -m32
CXXFLAGS += -m32
================================================
FILE: platforms/Darwin.x86_64.mk
================================================
SHLIB_SUFFIX = dylib
CFLAGS = -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS
SZCFLAGS = -frontend=clang
LD_PATH_VAR = DYLD_LIBRARY_PATH
CXXLIB = $(CXX) -shared -fPIC -compatibility_version 1 -current_version 1 -Wl,-flat_namespace,-undefined,suppress -dynamiclib
================================================
FILE: platforms/Linux.i386.mk
================================================
include $(ROOT)/platforms/Linux.x86_64.mk
CFLAGS += -m32
CXXFLAGS += -m32
================================================
FILE: platforms/Linux.i686.mk
================================================
include $(ROOT)/platforms/Linux.i386.mk
================================================
FILE: platforms/Linux.ppc.mk
================================================
CC = gcc
CXX = g++
CFLAGS =
CXXFLAGS = $(CFLAGS)
SZCFLAGS = -frontend=clang
LD_PATH_VAR = LD_LIBRARY_PATH
CXXLIB = $(CXX) -shared
================================================
FILE: platforms/Linux.x86_64.mk
================================================
SZCFLAGS =
LD_PATH_VAR = LD_LIBRARY_PATH
CXXFLAGS = -fPIC
CXXLIB = $(CXX) -shared -fPIC
================================================
FILE: process.py
================================================
#!/usr/bin/env python
import sys
import argparse
from numpy import mean, median, std, histogram
from scipy.stats import shapiro, anderson
parser = argparse.ArgumentParser(description='SPEC CPU2006 Output File Processor')
parser.add_argument('-norm', action='store_true')
parser.add_argument('-range', action='store_true')
parser.add_argument('-len', action='store_true')
parser.add_argument('-r', action='store_true')
parser.add_argument('-trim', action='store_true')
parser.add_argument('-all', action='store_true')
parser.add_argument('-ext', choices=['code', 'code.stack', 'code.heap.stack', 'link'], default=False)
parser.add_argument('-tune', choices=['base', 'peak'], default=False)
parser.add_argument('files', nargs='+')
args = parser.parse_args()
if args.ext == False:
args.ext = ['code', 'code.stack', 'code.heap.stack', 'link']
else:
args.ext = [args.ext]
if args.tune == False:
args.tune = ['base', 'peak']
else:
args.tune = [args.tune]
results = []
for filename in args.files:
f = open(filename, 'r')
bits = {}
for line in f:
if line.startswith('spec.cpu2006.results'):
(s, c, r, bmk, tune, n, key_value) = line.split('.', 6)
(key, value) = key_value.split(':', 1)
(ignore, bmk) = bmk.split('_')
if bmk not in bits:
bits[bmk] = {}
if n not in bits[bmk]:
bits[bmk][n] = {}
bits[bmk][n]['tune'] = tune
bits[bmk][n][key.strip()] = value.strip()
for bmk in bits:
for n in bits[bmk]:
results.append(bits[bmk][n])
def where(results, key, *values):
return filter(lambda r: r[key] in values, results)
def distinct(results, key):
values = []
for r in results:
if r[key] not in values:
values.append(r[key])
return values
def keymap(results, key, f):
next_results = []
for r in results:
next_r = dict(r)
next_r[key] = f(r[key])
next_results.append(next_r)
return next_results
def get(results, *keys):
next_results = []
for r in results:
next_r = {}
for k in r:
if k in keys:
next_r[k] = r[k]
next_results.append(next_r)
return next_results
def group(results, *keys):
if len(keys) == 0:
return results
key = keys[0]
grouped = {}
for r in results:
if r[key] not in grouped:
grouped[r[key]] = []
new_r = dict(r)
del new_r[key]
if len(new_r) == 1:
new_r = new_r.values()[0]
grouped[r[key]].append(new_r)
for g in grouped:
grouped[g] = group(grouped[g], *keys[1:])
return grouped
def pad(s, length=20):
if len(s) < length:
return s + ' '*(length - len(s))
else:
return s[0:length]
results = where(results, 'valid', 'S')
results = get(results, 'benchmark', 'tune', 'reported_time', 'ext')
results = keymap(results, 'benchmark', lambda b: b.split('.')[1])
results = keymap(results, 'reported_time', float)
exts = distinct(results, 'ext')
tunes = distinct(results, 'tune')
benchmarks = distinct(results, 'benchmark')
results = group(results, 'benchmark', 'tune', 'ext')
if args.trim:
for benchmark in results:
for tune in results[benchmark]:
for ext in results[benchmark][tune]:
values = results[benchmark][tune][ext]
hi = max(values)
lo = min(values)
del values[values.index(hi)]
del values[values.index(lo)]
results[benchmark][tune][ext] = values
#if args.r:
# for benchmark in results:
# sets = []
# for tune in results[benchmark]:
# for ext in results[benchmark][tune]:
# name = benchmark+'_'+tune+'_'+ext.replace('.', '_')
# values = results[benchmark][tune][ext]
# print name+' = c('+', '.join(map(str, values))+')'
# sets.append('"'+ext.replace('.', '_')+'"='+name)
# print benchmark+' <- list(' + ', '.join(sets) + ')'
if args.r:
benchmarks = []
tunes = []
exts = []
times = []
for benchmark in results:
for tune in results[benchmark]:
if tune in args.tune:
for ext in results[benchmark][tune]:
if ext in args.ext:
for time in results[benchmark][tune][ext]:
benchmarks.append('"'+benchmark+'"')
tunes.append('"'+tune+'"')
exts.append('"'+ext+'"')
times.append(str(time))
print 'dat <- data.frame(benchmark=c(' + ', '.join(benchmarks) + '), tune=c(' + ', '.join(tunes) + '), ext=c(' + ', '.join(exts) + '), time=c(' + ', '.join(times) + '))'
elif args.all:
benchmarks.sort()
tunes.sort()
exts.sort()
for tune in tunes:
if tune in args.tune:
for benchmark in benchmarks:
for ext in exts:
if ext in args.ext:
if tune in results[benchmark] and ext in results[benchmark][tune]:
row = [benchmark+'_'+ext+'_'+tune]
row += results[benchmark][tune][ext]
print ', '.join(map(str, row))
else:
benchmarks.sort()
tunes.sort()
exts.sort()
headings = ['Benchmark']
columns = []
for ext in exts:
if ext in args.ext:
for tune in tunes:
if tune in args.tune:
found = False
for benchmark in benchmarks:
found |= tune in results[benchmark] and ext in results[benchmark][tune]
if found:
headings.append(ext+'_'+tune)
columns.append(ext+'_'+tune)
print ', '.join(map(pad, headings))
for benchmark in benchmarks:
print pad(benchmark)+',',
values = []
for ext in exts:
if ext in args.ext:
for tune in tunes:
if tune in args.tune:
if (ext+'_'+tune) in columns:
if (tune not in results[benchmark] or ext not in results[benchmark][tune]):
values.append('')
elif args.norm:
if len(results[benchmark][tune][ext]) < 3:
values.append('')
else:
(k2, p) = shapiro(results[benchmark][tune][ext])
values.append(p > 0.05)
#(A2, critical, sig) = anderson(results[benchmark][ext])
#values.append(A2 <= critical[1])
elif args.range:
avg = mean(results[benchmark][tune][ext])
up = max(results[benchmark][tune][ext]) - avg
down = avg - min(results[benchmark][tune][ext])
values.append(max(up / avg, down / avg))
elif args.len:
values.append(len(results[benchmark][tune][ext]))
else:
values.append(mean(results[benchmark][tune][ext]))
print ', '.join(map(pad, map(str, values)))
================================================
FILE: run.py
================================================
#!/usr/bin/env python
import os
import sys
benchmarks = ['astar', 'bwaves', 'bzip2', 'cactusADM', 'calculix', 'gcc', 'gobmk', 'gromacs', 'h264ref', 'hmmer', 'lbm', 'leslie3d', 'libquantum', 'mcf', 'milc', 'namd', 'perlbench', 'sjeng', 'sphinx3', 'wrf', 'zeusmp']
iterations = 10
to_run = []
dont_run = []
configs = ['code', 'code.stack', 'code.heap.stack', 'stack', 'heap.stack', 'heap', 'link']
tune = 'O2'
size = 'train'
run_configs = []
for arg in sys.argv[1:]:
if arg in benchmarks:
to_run.append(arg)
elif arg.startswith('-') and arg[1:] in benchmarks:
dont_run.append(arg[1:])
elif arg in configs:
run_configs.append(arg)
elif arg in ['O0', 'O1', 'O2', 'O3']:
tune = arg
elif arg in ['test', 'train', 'ref']:
size = arg
else:
iterations = int(arg)
if len(to_run) == 0:
to_run = benchmarks
if len(run_configs) == 0:
run_configs = configs
for bmk in dont_run:
if bmk in to_run:
to_run.remove(bmk)
def runspec(bench, size, tune, ext, n, rebuild=False):
if tune == 'O0' or tune == 'O1':
real_config = 'szclo'
elif tune == 'O2' or tune == 'O3':
real_config = 'szchi'
if tune == 'O0' or tune == 'O2':
real_tune = 'base'
elif tune == 'O1' or tune == 'O3':
real_tune = 'peak'
cmd = 'runspec --config='+real_config+' --mach=linux --action=run --tune='+real_tune+' --size='+size+' --ext='+ext+' -n '+str(n)
if rebuild:
cmd += ' --rebuild'
cmd += ' '+bench
os.system(cmd)
for bmk in to_run:
for config in run_configs:
if config == 'link':
for i in range(0, iterations):
runspec(bmk, size, tune, 'link', 1, rebuild=True)
else:
runspec(bmk, size, tune, config, iterations, rebuild=True)
================================================
FILE: runtime/Arch.h
================================================
/**
* Macros for target-specific code.
*/
#if !defined(RUNTIME_ARCH_H)
#define RUNTIME_ARCH_H
#if defined(__APPLE__)
# define _OSX(x) x
# define IS_OSX 1
#else
# define _OSX(x)
# define IS_OSX 0
#endif
#if defined(__linux__)
# define _LINUX(x) x
# define IS_LINUX 1
#else
# define _LINUX(x)
# define IS_LINUX 0
#endif
#if defined(__i386__)
# define _X86(x) x
# define _AnyX86(x) x
# define IS_X86 1
#else
# define _X86(x)
# define IS_X86 0
#endif
#if defined(__x86_64__)
# define _X86_64(x) x
# define _AnyX86(x) x
# define IS_X86_64 1
#else
# define _X86_64(x)
# define IS_X86_64 0
#endif
#if defined(__powerpc__) || defined(__ppc__)
# define _PPC(x) x
# define _AnyX86(x)
# define IS_PPC 1
#else
# define _PPC(x)
# define IS_PPC 0
#endif
#endif
================================================
FILE: runtime/Context.h
================================================
/**
* Signal context and stack-walking code
*/
#if !defined(RUNTIME_CONTEXT_H)
#define RUNTIME_CONTEXT_H
#if !defined(_XOPEN_SOURCE)
// Digging inside of ucontext_t is deprecated unless this macros is defined
#define _XOPEN_SOURCE
#endif
#include <stdint.h>
#include <sys/mman.h>
#include <ucontext.h>
#include "Arch.h"
/**
* A stack walking iterator
*/
struct Stack {
private:
/// A pointer to the current stack frame
void** _frame;
public:
/**
* Initialize a stack with a frame address
* \arg frame The starting frame pointer
*/
inline Stack(void* frame) : _frame((void**)frame) {}
/**
* Get the return address from the current frame
* \returns A reference to the return address
*/
inline void*& ret() {
return _frame[1];
}
/**
* Get the next frame pointer up the stack
* \returns A reference to the next frame pointer
*/
inline void*& fp() {
return _frame[0];
}
/**
* Move up to the next frame
*/
inline void operator++(int) {
_frame = (void**)fp();
}
};
struct Context {
private:
/// The actual signal context
ucontext_t* _c;
public:
Context(void* c) : _c((ucontext_t*)c) {}
inline void*& ip() {
_OSX(_AnyX86(return *(void**)&_c->uc_mcontext->__ss.__rip));
_LINUX(_AnyX86(return *(void**)&_c->uc_mcontext.gregs[REG_RIP]));
_LINUX(_PPC(return *(void**)&_c->uc_mcontext.regs->nip));
ABORT("Instruction pointer not available on current target");
}
/**
* Get a reference to the context stack pointer
* \returns A reference to the stack pointer
*/
inline void*& sp() {
_OSX(_AnyX86(return *(void**)&_c->uc_mcontext->__ss.__rsp));
_LINUX(_AnyX86(return *(void**)&_c->uc_mcontext.gregs[REG_RSP]));
_LINUX(_PPC(return *(void**)&_c->uc_mcontext.regs->gpr[PT_R1]));
ABORT("Stack pointer not available on current target");
}
/**
* Get a reference to the context frame pointer
* \returns A reference to the frame pointer
*/
inline void*& fp() {
_OSX(_AnyX86(return *(void**)&_c->uc_mcontext->__ss.__rbp));
_LINUX(_AnyX86(return *(void**)&_c->uc_mcontext.gregs[REG_RBP]));
_LINUX(_PPC(return *(void**)&_c->uc_mcontext.regs->gpr[PT_R1]));
ABORT("Frame pointer not available on current target");
}
/**
* Get an iterator to walk the context's stack
* \returns A Stack iterator
*/
inline Stack stack() {
return Stack(fp());
}
};
#endif
================================================
FILE: runtime/Debug.cpp
================================================
#include <execinfo.h>
#include "Debug.h"
#include "FunctionLocation.h"
/**
* Dump a stack trace to screen.
*
* Use the system backtrace() function to get return address on the stack,
* rewrite them to refer to original code locations, then use
* backtrace_symbols() to resolve symbols.
*/
void panic() {
void* real_buffer[100];
void* adjusted_buffer[100];
size_t num = backtrace(real_buffer, 100);
for(size_t i=0; i<num; i++) {
adjusted_buffer[i] = FunctionLocation::adjust(real_buffer[i]);
}
char** strings = backtrace_symbols(adjusted_buffer, num);
if(strings == NULL) {
perror("backtrace_symbols");
abort();
}
for(size_t i=0; i<num; i++) {
fprintf(stderr, "%s [at %p]\n", strings[i], real_buffer[i]);
}
free(strings);
}
================================================
FILE: runtime/Debug.h
================================================
#if !defined(RUNTIME_DEBUG_H)
#define RUNTIME_DEBUG_H
void panic();
#if !defined(NDEBUG)
#include <stdio.h>
#include <assert.h>
#define DEBUG(...) fprintf(stderr, " [%s:%d] ", __FILE__, __LINE__); fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n")
#else
#define DEBUG(_fmt, ...)
#endif
#define ABORT(...) fprintf(stderr, " [%s:%d] ABORT: ", __FILE__, __LINE__); fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n"); panic(); abort()
#endif
================================================
FILE: runtime/Function.cpp
================================================
#include "Function.h"
#include "FunctionLocation.h"
/**
* Free the current function location and stack pad table
*/
Function::~Function() {
if(_current != NULL) {
_current->release();
}
if(_stackPad != NULL) {
getDataHeap()->free(_stackPad);
}
}
/**
* Copy the code and relocation table for this function. Use the pre-assembled
* code/table chunk if the function has already been relocated.
*
* \arg target The destination of the copy.
*/
void Function::copyTo(void* target) {
if(_current == NULL) {
// Copy the code from the original function
memcpy(target, _code.base(), _code.size());
// Patch in the saved header, since the original has been overwritten
*(FunctionHeader*)target = _savedHeader;
// If there is a stack pad table, move it to a random location
if(_stackPad != NULL) {
uintptr_t* table = (uintptr_t*)_table.base();
for(size_t i=0; i<_table.size(); i+=sizeof(uintptr_t)) {
if(table[i] == (uintptr_t)_stackPad) {
_stackPad = (uint8_t*)getDataHeap()->malloc(1);
table[i] = (uintptr_t)_stackPad;
}
}
}
// Copy the relocation table, if needed
if(_tableAdjacent) {
uint8_t* a = (uint8_t*)target;
memcpy(&a[_code.size()], _table.base(), _table.size());
}
} else {
memcpy(target, _current->_memory.base(), getAllocationSize());
}
}
/**
* Create a new FunctionLocation for this Function.
* \arg relocation The ID for the current relocation phase.
* \returns Whether or not a new location was created
*/
FunctionLocation* Function::relocate() {
FunctionLocation* oldLocation = _current;
_current = new FunctionLocation(this);
_current->activate();
// Fill the stack pad table with random bytes
if(_stackPad != NULL) {
// Update random stack pad
*_stackPad = getRandomByte();
}
return oldLocation;
}
================================================
FILE: runtime/Function.h
================================================
#if !defined(RUNTIME_FUNCTION_H)
#define RUNTIME_FUNCTION_H
#include <string.h>
#include <sys/mman.h>
#include "Util.h"
#include "Jump.h"
#include "Trap.h"
#include "Heap.h"
#include "MemRange.h"
struct Function;
struct FunctionLocation;
struct FunctionHeader {
private:
union {
uint8_t _jmp[sizeof(Jump)];
uint8_t _trap[sizeof(Trap)];
};
Function* _f;
public:
FunctionHeader(Function* f) : _f(f) {}
void jumpTo(void* target) {
new(_jmp) Jump(target);
}
void trap() {
new(_trap) Trap();
}
Function* getFunction() {
return _f;
}
};
struct Function {
private:
friend class FunctionLocation;
MemRange _code;
MemRange _table;
FunctionHeader* _header;
FunctionHeader _savedHeader;
bool _tableAdjacent; //< If true, the relocation table should be placed next to the function
uint8_t* _stackPad; //< The address of the stack pad value for this function
FunctionLocation* _current;
/**
* \brief Place a jump instruction to forward calls to this function
* \arg target The destination of the jump instruction
*/
inline void forward(void* target) {
_header->jumpTo(target);
flush_icache(_header, sizeof(FunctionHeader));
}
void copyTo(void* target);
public:
/**
* \brief Allocate Function objects on the randomized heap
* \arg sz The object size
*/
void* operator new(size_t sz) {
return getDataHeap()->malloc(sz);
}
/**
* \brief Free allocated memory to the randomized heap
* \arg p The object base pointer
*/
void operator delete(void* p) {
getDataHeap()->free(p);
}
/**
* \brief Create a new runtime representation of a function
* \arg codeBase The address of the function
* \arg codeLimit The top of the function
* \arg tableBase The address of the function's relocation table
* \arg tableSize The size of the function's relocation table
* \arg tableAdjacent If true, the relocation table should be placed immediately after the function
* \arg stackPad The address of this function's stack pad size
*/
inline Function(void* codeBase, void* codeLimit, void* tableBase, size_t tableSize, bool tableAdjacent, uint8_t* stackPad) :
_code(codeBase, codeLimit), _table(tableBase, tableSize), _savedHeader(*(FunctionHeader*)_code.base()) {
this->_tableAdjacent = tableAdjacent;
this->_stackPad = stackPad;
this->_current = NULL;
// Make the function header writable
if(mprotect(_code.pageBase(), _code.pageSize(), PROT_READ | PROT_WRITE | PROT_EXEC)) {
perror("Unable make code writable");
abort();
}
// Make a copy of the function header
_savedHeader = *(FunctionHeader*)_code.base();
_header = new(_code.base()) FunctionHeader(this);
}
/**
* \brief Free all code locations when deleted
*/
~Function();
FunctionLocation* relocate();
/**
* \brief Place a trap instruction at the beginning of this function
*/
inline void setTrap() {
_header->trap();
}
inline void* getCodeBase() {
return _code.base();
}
inline size_t getCodeSize() {
return _code.size();
}
inline size_t getAllocationSize() {
if(_tableAdjacent) {
return _code.size() + _table.size();
} else {
return _code.size();
}
}
inline FunctionLocation* getCurrentLocation() {
return _current;
}
};
#endif
================================================
FILE: runtime/FunctionLocation.h
================================================
#if !defined(RUNTIME_FUNCTIONLOCATION_H)
#define RUNTIME_FUNCTIONLOCATION_H
#include <set>
#include "MemRange.h"
#include "Function.h"
using namespace std;
struct FunctionLocation {
private:
friend class Function;
Function* _f;
MemRange _memory;
bool _defunct;
bool _marked;
static inline set<FunctionLocation*>& getRegistry() {
static set<FunctionLocation*> _registry;
return _registry;
}
static FunctionLocation* find(void* p) {
for(set<FunctionLocation*>::iterator iter = getRegistry().begin(); iter != getRegistry().end(); iter++) {
FunctionLocation* l = *iter;
if(l->_memory.contains(p)) {
return l;
}
}
return NULL;
}
public:
FunctionLocation(Function* f) : _f(f), _memory(getCodeHeap()->malloc(_f->getAllocationSize()), _f->getAllocationSize()) {
if(_memory.base() == NULL) {
perror("code malloc");
ABORT("Couldn't allocate memory for function relocation");
}
_defunct = false;
_marked = false;
_f->copyTo(_memory.base());
getRegistry().insert(this);
}
~FunctionLocation() {
getCodeHeap()->free(_memory.base());
}
/**
* \brief Allocate FunctionLocation objects on the randomized heap
* \arg sz The object size
*/
void* operator new(size_t sz) {
return getDataHeap()->malloc(sz);
}
/**
* \brief Free allocated memory to the randomized heap
* \arg p The object base pointer
*/
void operator delete(void* p) {
getDataHeap()->free(p);
}
void activate() {
_f->forward(_memory.base());
}
void release() {
_defunct = true;
}
void* getBase() {
return _memory.base();
}
static void mark(void* p) {
FunctionLocation* l = find(p);
if(l != NULL) {
l->_marked = true;
}
}
static void sweep() {
set<FunctionLocation*>::iterator iter = getRegistry().begin();
while(iter != getRegistry().end()) {
FunctionLocation* l = *iter;
if(l->_defunct && !l->_marked) {
getRegistry().erase(iter++);
delete l;
} else {
l->_marked = false;
iter++;
}
}
}
static void* adjust(void* p) {
FunctionLocation* l = find(p);
if(l != NULL) {
size_t offset = l->_memory.offsetOf(p);
return l->_f->_code.offsetIn(offset);
} else {
return p;
}
}
};
#endif
================================================
FILE: runtime/Heap.cpp
================================================
#include "Heap.h"
DataHeapType* getDataHeap() {
static char buf[sizeof(DataHeapType)];
static DataHeapType* _theDataHeap = new (buf) DataHeapType;
return _theDataHeap;
}
CodeHeapType* getCodeHeap() {
static char buf[sizeof(CodeHeapType)];
static CodeHeapType* _theCodeHeap = new (buf) CodeHeapType;
return _theCodeHeap;
}
================================================
FILE: runtime/Heap.h
================================================
#if !defined(RUNTIME_HEAP_H)
#define RUNTIME_HEAP_H
#include <heaplayers>
#include <shuffleheap.h>
#include "Util.h"
#include "MMapSource.h"
enum {
DataShuffle = 256,
DataProt = PROT_READ | PROT_WRITE,
DataFlags = MAP_PRIVATE | MAP_ANONYMOUS,
DataSize = 0x2000000,
CodeShuffle = 256,
CodeProt = PROT_READ | PROT_WRITE | PROT_EXEC,
CodeFlags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_32BIT,
CodeSize = 0x2000000
};
class DataSource : public SizeHeap<FreelistHeap<BumpAlloc<DataSize, MMapSource<DataProt, DataFlags>, 16> > > {};
class CodeSource : public SizeHeap<FreelistHeap<BumpAlloc<CodeSize, MMapSource<CodeProt, CodeFlags>, CODE_ALIGN> > > {};
typedef ANSIWrapper<KingsleyHeap<ShuffleHeap<DataShuffle, DataSource>, DataSource> > DataHeapType;
typedef ANSIWrapper<KingsleyHeap<ShuffleHeap<CodeShuffle, CodeSource>, CodeSource> > CodeHeapType;
DataHeapType* getDataHeap();
CodeHeapType* getCodeHeap();
#endif
================================================
FILE: runtime/Intrinsics.cpp
================================================
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <string.h>
extern "C" {
float powif(float b, int e) {
return powf(b, (float)e);
}
void memset_i32(void* p, uint8_t val, uint32_t len, uint32_t align, bool isvolatile) {
memset(p, val, len);
}
void memset_i64(void* p, uint8_t val, uint64_t len, uint32_t align, bool isvolatile) {
memset(p, val, len);
}
}
================================================
FILE: runtime/Jump.h
================================================
#ifndef RUNTIME_JUMP_H
#define RUNTIME_JUMP_H
#include <new>
#include <stdint.h>
#include "Arch.h"
#include "Debug.h"
struct X86Jump32 {
volatile uint8_t jmp_opcode;
volatile uint32_t jmp_offset;
X86Jump32(void *target) {
jmp_opcode = 0xE9;
jmp_offset = (uint32_t)((intptr_t)target - (intptr_t)this) - sizeof(struct X86Jump32);
}
} __attribute__((packed));
struct X86Jump64 {
volatile uint32_t sub_8_rsp;
volatile uint32_t mov_imm_0rsp;
volatile uint32_t target_low;
volatile uint32_t mov_imm_4rsp;
volatile uint32_t target_high;
volatile uint8_t retq;
X86Jump64(void *target) {
/* x86_64 doesn't have an immediate 64 bit jump, so build one:
* 1. Move down 8 bytes on the stack
* 2. Put the target address on the stack in 32 bit chunks
* 3. Return
*/
sub_8_rsp = 0x08EC8348; // move the stack pointer down 8 bytes
mov_imm_0rsp = 0x002444C7; // move an immediate to 0(%rsp)
target_low = (uint32_t)(int64_t)target;
mov_imm_4rsp = 0x042444C7; // move an immediate to 4(%rsp)
target_high = (uint32_t)((int64_t)target >> 32);
retq = 0xC3;
}
} __attribute__((packed));
struct X86_64Jump {
union {
uint8_t jmp32[sizeof(X86Jump32)];
uint8_t jmp64[sizeof(X86Jump64)];
};
X86_64Jump(void *target) {
if((uintptr_t)target - (uintptr_t)this <= 0x00000000FFFFFFFFu || (uintptr_t)this - (uintptr_t)target <= 0x00000000FFFFFFFFu) {
new(this) X86Jump32(target);
} else {
new(this) X86Jump64(target);
}
}
} __attribute__((packed));
struct PPCJump {
union {
uint32_t ba;
struct{
volatile uint32_t lis_to_r0;
volatile uint32_t ori_r0;
volatile uint32_t mtctr;
volatile uint32_t bctr;
};
} __attribute__((packed));
PPCJump(void *target) {
uintptr_t t = (uintptr_t)target;
uintptr_t pos_offset = t - (uintptr_t)this;
intptr_t neg_offset = (intptr_t)this - (intptr_t)t;
/*if(t < 1<<25) {
DEBUG("absolute jump");
ba = 0x48000002;
ba |= t & 0x03FFFFFCu;
} else if(pos_offset < 1<<25) {
DEBUG(" use positive offset");
ba = 0x48000000;
ba |= (uint32_t)pos_offset & 0x03FFFFFC;
} else if(-neg_offset < 1<<25) {
DEBUG(" use negative offset\n");
ba = 0x48000000;
ba |= neg_offset & 0x03FFFFFC;
} else { */
DEBUG("slow jump");
lis_to_r0=0x3c000000 | ((t>>16)&0xFFFFu);
ori_r0=0x60000000 | (t&0xFFFFu);
mtctr=0x7c0903a6;
bctr=0x4e800420;
// }
}
} __attribute__((packed));
#if IS_X86
typedef X86Jump32 Jump;
#elif IS_X86_64
typedef X86_64Jump Jump;
#elif IS_PPC
typedef PPCJump Jump;
#endif
#endif
================================================
FILE: runtime/MMapSource.h
================================================
#if !defined(RUNTIME_MMAPSOURCE_H)
#define RUNTIME_MMAPSOURCE_H
#include "Util.h"
template<int Prot, int Flags> class MMapSource {
private:
bool _exhausted32;
public:
enum { Alignment = PAGESIZE };
MMapSource() {
_exhausted32 = false;
}
inline void* malloc(size_t sz) {
void* ptr;
if(Flags & MAP_32BIT) {
// If we haven't exhausted the 32 bit pages
if(!_exhausted32) {
ptr = mmap(NULL, sz, Prot, Flags, -1, 0);
if(ptr != MAP_FAILED) {
return ptr;
} else {
_exhausted32 = true;
}
}
}
// Try the map without the MAP_32BIT flag set
ptr = mmap(NULL, sz, Prot, Flags & ~MAP_32BIT, -1, 0);
if(ptr == MAP_FAILED) {
ptr = NULL;
}
return ptr;
}
};
#endif
================================================
FILE: runtime/Makefile
================================================
ROOT = ..
CROSS_TARGET = 1
TARGETS = $(ROOT)/libstabilizer.$(SHLIB_SUFFIX) $(ROOT)/libstabilizer.a
INCLUDE_DIRS = $(ROOT)/Heap-Layers \
$(ROOT)/DieHard/src/include \
$(ROOT)/DieHard/src/include/math \
$(ROOT)/DieHard/src/include/rng \
$(ROOT)/DieHard/src/include/static \
$(ROOT)/DieHard/src/include/util
include $(ROOT)/common.mk
================================================
FILE: runtime/MemRange.h
================================================
#if !defined(RUNTIME_MEMRANGE_H)
#define RUNTIME_MEMRANGE_H
#include "Util.h"
struct MemRange {
private:
uintptr_t _base;
uintptr_t _limit;
public:
inline MemRange(void* base, size_t size) {
_base = (uintptr_t)base;
_limit = _base + size;
}
inline MemRange(void* base, void* limit) {
_base = (uintptr_t)base;
_limit = (uintptr_t)limit;
}
inline void* base() {
return (void*)_base;
}
inline void* pageBase() {
return (void*)(_base - _base % PAGESIZE);
}
inline void* pageLimit() {
uintptr_t l = _limit + PAGESIZE - 1;
return (void*)(l - l % PAGESIZE);
}
inline size_t pageSize() {
return (uintptr_t)pageLimit() - (uintptr_t)pageBase();
}
inline void* limit() {
return (void*)_limit;
}
inline size_t size() {
return (size_t)(_limit - _base);
}
inline size_t offsetOf(void* p) {
return (uintptr_t)p - _base;
}
inline void* offsetIn(size_t offset) {
return (void*)(_base + offset);
}
inline bool contains(void* p) {
return offsetOf(p) < size();
}
};
#endif
================================================
FILE: runtime/Trap.h
================================================
#if !defined(RUNTIME_TRAP_H)
#define RUNTIME_TRAP_H
#include <signal.h>
#include "Arch.h"
struct X86Trap {
uint8_t trap_opcode;
enum { TrapSignal = SIGTRAP };
enum { TrapAdjust = 1 };
X86Trap() {
trap_opcode = 0xCC;
}
} __attribute__((packed));
struct PPCTrap {
uint32_t trap_opcode;
enum { TrapSignal = SIGILL };
enum { TrapAdjust = 0 };
PPCTrap() {
trap_opcode = 0x0;
}
} __attribute__((packed));
#if IS_X86
typedef X86Trap Trap;
#elif IS_X86_64
typedef X86Trap Trap;
#elif IS_PPC
typedef PPCTrap Trap;
#endif
#endif
================================================
FILE: runtime/Util.h
================================================
#ifndef RUNTIME_UTIL_H
#define RUNTIME_UTIL_H
#include <stdint.h>
#include <sys/mman.h>
#include <randomnumbergenerator.h>
#include "Arch.h"
#ifndef PAGESIZE
#define PAGESIZE 4096
#endif
#ifndef MAP_ANONYMOUS
#define MAP_ANONYMOUS MAP_ANON
#endif
#ifndef MAP_32BIT
#define MAP_32BIT 0
#endif
#if !defined(CODE_ALIGN)
#define CODE_ALIGN 32
#endif
static void flush_icache(void* begin, size_t size) {
_PPC(
uintptr_t p = (uintptr_t)begin & ~15UL;
for (size_t i = 0; i < size; i += 16) {
asm("icbi 0,%0" : : "r"(p));
p += 16;
}
asm("isync");
)
}
static inline uint8_t getRandomByte() {
static RandomNumberGenerator _rng;
static uint8_t _randCount = 0;
static union {
uint8_t _rands[sizeof(int)];
int _bigRand;
};
if(_randCount == sizeof(int)) {
_bigRand = _rng.next();
_randCount = sizeof(int);
}
uint8_t r = _rands[_randCount];
_randCount++;
return r;
}
#endif
================================================
FILE: runtime/libstabilizer.cpp
================================================
#include <set>
#include <vector>
#include <math.h>
#include <signal.h>
#include <stdlib.h>
#include <execinfo.h>
#include "Function.h"
#include "FunctionLocation.h"
#include "Debug.h"
#include "Heap.h"
#include "Context.h"
using namespace std;
extern "C" int stabilizer_main(int argc, char **argv);
int main(int argc, char** argv);
void onTrap(int sig, siginfo_t* info, void*);
void onTimer(int sig, siginfo_t* info, void*);
void onFault(int sig, siginfo_t* info, void*);
void setTimer(int msec);
void setHandler(int sig, void(*fn)(int, siginfo_t*, void*));
typedef void(*ctor_t)();
set<Function*> functions;
set<Function*> live_functions;
set<uint8_t*> stack_pads;
vector<ctor_t> constructors;
bool rerandomizing = false;
size_t interval = 500;
void** topFrame = NULL;
/**
* Entry point for a program run with Stabilizer. The program's existing
* main function has been renamed 'stabilizer_main' by the compiler pass.
*
* 1. Save the current top of the stack
* 2. Set signal handlers for debug traps, timers, and segfaults for error handling
* 3. Place a trap instruction at the start of each randomizable function to trigger relocation on-demand
* 4. Set the re-randomization timer
* 5. Call module constructors
* 6. Invoke stabilizer_main
*/
int main(int argc, char **argv) {
DEBUG("Initializing Stabilizer");
topFrame = (void**)__builtin_frame_address(0);
DEBUG("Stack top is at %p", topFrame);
// Register signal handlers
setHandler(Trap::TrapSignal, onTrap);
setHandler(SIGALRM, onTimer);
setHandler(SIGSEGV, onFault);
DEBUG("Signal handlers installed");
// Lazily relocate functions
for(set<Function*>::iterator iter = functions.begin(); iter != functions.end(); iter++) {
Function* f = *iter;
f->setTrap();
}
DEBUG("Trapped all functions");
// Set the re-randomization timer
setTimer(interval);
DEBUG("Set re-randomization timer");
// Call all constructors
for(vector<ctor_t>::iterator i = constructors.begin(); i != constructors.end(); i++) {
(*i)();
}
DEBUG("Finished with program constructors");
// Call the old main function
int r = stabilizer_main(argc, argv);
DEBUG("Shutting down");
return r;
}
extern "C" {
void stabilizer_register_function(void* codeBase, void* codeLimit, void* tableBase, size_t tableSize, bool adjacent, uint8_t* stackPad) {
Function* f = new Function(codeBase, codeLimit, tableBase, tableSize, adjacent, stackPad);
functions.insert(f);
}
void stabilizer_register_constructor(ctor_t ctor) {
constructors.push_back(ctor);
}
void stabilizer_register_stack_pad(uint8_t* pad) {
stack_pads.insert(pad);
}
void* stabilizer_malloc(size_t sz) {
return getDataHeap()->malloc(sz);
}
void* stabilizer_calloc(size_t n, size_t sz) {
return getDataHeap()->calloc(n, sz);
}
void* stabilizer_realloc(void *p, size_t sz) {
return getDataHeap()->realloc(p, sz);
}
void stabilizer_free(void *p) {
if(getDataHeap()->getSize(p) == 0) {
free(p);
} else {
getDataHeap()->free(p);
}
}
void reportDoubleFreeError() {
ABORT("Double free error");
}
}
void onTrap(int sig, siginfo_t* info, void* p) {
Context c(p);
// Back up over the trap instruction
c.ip() = (void*)((uintptr_t)c.ip() - Trap::TrapAdjust);
// Extract the trapped function (stored next to the trap instruction)
FunctionHeader* h = (FunctionHeader*)c.ip();
Function* f = h->getFunction();
// If the trap was placed to trigger a re-randomization
if(rerandomizing) {
DEBUG("Re-randomization started after trap on %p", c.ip());
live_functions.empty();
// Mark all on-stack function locations as used
Stack s = c.stack();
while(s.fp() != topFrame) {
FunctionLocation::mark(s.ret());
s++;
}
// Mark the current instruction pointer as used
FunctionLocation::mark((void*)c.ip());
// Mark the top return address on the stack as used
FunctionLocation::mark(*(void**)c.sp());
// Collect unused function locations
FunctionLocation::sweep();
rerandomizing = false;
setTimer(interval);
}
// Relocate the function
FunctionLocation* oldLocation = f->relocate();
live_functions.insert(f);
if(oldLocation != NULL) {
oldLocation->release();
}
c.ip() = f->getCurrentLocation()->getBase();
}
void onTimer(int sig, siginfo_t* info, void* p) {
Context c(p);
DEBUG("Re-randomization timer fired at %p", c.ip());
if(functions.size() == 0) {
DEBUG("Re-randomizing stack pads");
for(set<uint8_t*>::iterator iter = stack_pads.begin(); iter != stack_pads.end(); iter++) {
uint8_t* pad = *iter;
**iter = getRandomByte();
}
setTimer(interval);
} else {
DEBUG("Placing traps");
for(set<Function*>::iterator iter = live_functions.begin(); iter != live_functions.end(); iter++) {
Function* f = *iter;
if(c.ip() == f->getCodeBase()) {
DEBUG("Forwarding from trap at %p", c.ip());
c.ip() = f->getCurrentLocation()->getBase();
}
f->setTrap();
}
live_functions.clear();
}
rerandomizing = true;
}
void onFault(int sig, siginfo_t* info, void* p) {
Context c(p);
ABORT("Fault at %p, accessing address %p", c.ip(), info->si_addr);
}
void setTimer(int msec) {
struct itimerval timer;
timer.it_value.tv_sec = (msec - msec % 1000) / 1000;
timer.it_value.tv_usec = 1000 * (msec % 1000);
timer.it_interval.tv_sec = 0;
timer.it_interval.tv_usec = 0;
setitimer(ITIMER_REAL, &timer, 0);
}
void setHandler(int sig, void(*fn)(int, siginfo_t*, void*)) {
struct sigaction sa;
sa.sa_sigaction = (void(*)(int, siginfo_t*, void*))fn;
sa.sa_flags = SA_SIGINFO;
sigaction(sig, &sa, NULL);
}
================================================
FILE: szc
================================================
#!/usr/bin/env python
import os
import sys
import random
import argparse
from distutils import util
parser = argparse.ArgumentParser(description="Stabilizer Compiler Driver")
# Which randomizations should be run
parser.add_argument('-R', action='append', choices=['code', 'heap', 'stack', 'link'], default=[])
# Driver control arguments
parser.add_argument('-v', action='store_true')
parser.add_argument('-lang', choices=['c', 'c++', 'fortran'])
parser.add_argument('-platform', choices=['auto', 'linux', 'osx'], default='auto')
parser.add_argument('-frontend', choices=['gcc', 'clang'], default='gcc')
# Compiler pass-through arguments
parser.add_argument('-c', action='store_true')
parser.add_argument('-o')
parser.add_argument('-O', type=int, default=2)
parser.add_argument('-g', action='store_true')
parser.add_argument('-f', action='append', default=[])
parser.add_argument('-D', action='append', default=[])
parser.add_argument('-L', action='append', default=[])
parser.add_argument('-I', action='append', default=[])
parser.add_argument('-l', action='append', default=[])
parser.add_argument('input', nargs='+')
# Do the parse
args = parser.parse_args()
def getPlatform():
if util.get_platform().startswith('macosx'):
return 'osx'
elif util.get_platform().startswith('linux'):
return 'linux'
else:
print 'Unsupported platform'
exit(2)
def arg(flag, values):
if not isinstance(values, list):
values = [values]
cmd = ''
for v in values:
if v == True:
cmd += ' -'+flag
elif v == False:
pass
else:
cmd += ' -'+flag+v
return cmd
if args.platform == 'auto':
args.platform = getPlatform()
STABILIZER_HOME = os.path.dirname(__file__)
if args.platform == 'osx':
LIBSUFFIX = 'dylib'
args.frontend = 'clang'
else:
LIBSUFFIX = 'so'
opts = []
args.l.append('stdc++')
#args.v = True
if 'code' in args.R:
opts.append('lower-intrinsics')
opts.append('lowerswitch')
opts.append('lowerinvoke')
opts.append('stabilize-code')
if 'stack' in args.R:
opts.append('stabilize-stack')
if 'heap' in args.R:
opts.append('stabilize-heap')
if 'code' in args.R or 'heap' in args.R or 'stack' in args.R:
args.L.append(STABILIZER_HOME)
args.l.append('stabilizer')
opts.append('stabilize')
def compile(input):
if input.endswith('.o'):
return input
needsAssembly = False
if args.lang == 'fortran':
cmd = 'gfortran -O0 -fplugin=dragonegg -S -fplugin-arg-dragonegg-emit-ir'
cmd += arg('o ', args.o+'.s')
needsAssembly = True
elif args.frontend == 'gcc':
cmd = 'gcc -O0 -fplugin=dragonegg -S -fplugin-arg-dragonegg-emit-ir'
cmd += arg('o ', args.o+'.s')
needsAssembly = True
else:
cmd = 'clang -O0 -c -emit-llvm'
cmd += arg('o ', args.o)
cmd += arg('O', 0)
cmd += arg('g', args.g)
cmd += arg('I', args.I)
cmd += arg('f', args.f)
cmd += arg('D', args.D)
cmd += ' '+input
if args.v:
print cmd
os.system(cmd)
if needsAssembly:
cmd = 'llvm-as -o ' + args.o + ' ' + args.o + '.s'
if args.v:
print cmd
os.system(cmd)
return args.o
def link(inputs):
cmd = 'llvm-link -o ' + args.o + '.bc '
if 'link' in args.R:
random.shuffle(inputs)
cmd += ' '.join(inputs)
if args.v:
print cmd
os.system(cmd)
return args.o + '.bc'
def transform(input):
cmd = 'opt -o ' + args.o + '.opt.bc'
cmd += ' ' + input
if args.O > 0:
cmd += ' -O'+str(args.O)
cmd += ' -load='+STABILIZER_HOME+'/LLVMStabilizer.'+LIBSUFFIX
cmd += arg('', opts)
if args.v:
print cmd
os.system(cmd)
return args.o + '.opt.bc'
def codegen(input):
cmd = 'llc -O0 -relocation-model=pic -disable-fp-elim'
cmd += ' -o ' + args.o + '.s'
cmd += ' ' + input
if args.v:
print cmd
os.system(cmd)
if args.lang == 'fortran':
cmd = 'gfortran'
else:
cmd = args.frontend
cmd += ' ' + args.o + '.s'
cmd += arg('o ', args.o)
cmd += arg('f', args.f)
cmd += arg('L', args.L)
cmd += arg('l', args.l)
if args.v:
print cmd
os.system(cmd)
return args.o
# Build up program arguments
object_files = map(compile, args.input)
if not args.c:
linked = link(object_files)
transformed = transform(linked)
codegen(transformed)
================================================
FILE: szchi.cfg
================================================
ignore_errors = no
tune = base
ext = szc
output_format = csv,screen
reportable = no
teeout = yes
teerunout = yes
makeflags = -j
##########################################
# Compiler and Runtime
##########################################
default:
CC = szc -lang=c
CXX = szc -lang=c++
FC = szc -lang=fortran
default=default=code,code.heap,code.link,code.stack,code.heap.link,code.heap.stack,code.link.stack,code.heap.link.stack:
CC += -Rcode
CXX += -Rcode
FC += -Rcode
default=default=heap,code.heap,heap.link,heap.stack,code.heap.link,code.heap.stack,heap.link.stack,code.heap.link.stack:
CC += -Rheap
CXX += -Rheap
FC += -Rheap
default=default=stack,code.stack,heap.stack,link.stack,code.heap.stack,code.link.stack,heap.link.stack,code.heap.link.stack:
CC += -Rstack
CXX += -Rstack
FC += -Rstack
default=default=link,code.link,heap.link,link.stack,code.heap.link,code.link.stack,heap.link.stack,code.heap.link.stack:
CC += -Rlink
CXX += -Rlink
FC += -Rlink
##########################################
# Optimization
##########################################
default=base:
COPTIMIZE = -O2 -fno-strict-aliasing
CXXOPTIMIZE = -O2 -fno-strict-aliasing
FOPTIMIZE = -O2 -fno-strict-aliasing
default=peak:
COPTIMIZE = -O3 -fno-strict-aliasing
CXXOPTIMIZE = -O3 -fno-strict-aliasing
FOPTIMIZE = -O3 -fno-strict-aliasing
##########################################
# Portability
##########################################
default:
PORTABILITY = -DSPEC_CPU_LP64
400.perlbench=default=default=linux:
CPORTABILITY = -DSPEC_CPU_LINUX_X64
403.gcc=default=default=osx:
CPORTABILITY = -DSPEC_CPU_MACOSX
462.libquantum=default=default=linux:
CPORTABILITY = -DSPEC_CPU_LINUX
462.libquantum=default=defaut=osx:
CPORTABILITY = -DSPEC_CPU_MACOSX
481.wrf=default=default=linux:
CPORTABILITY = -DSPEC_CPU_CASE_FLAG -DSPEC_CPU_LINUX
483.xalancbmk=default=default=linux:
CXXPORTABILITY = -DSPEC_CPU_LINUX
483.xalancbmk=default=default=osx:
CXXPORTABILITY = -DSPEC_CPU_MACOSX
================================================
FILE: szclo.cfg
================================================
ignore_errors = no
tune = base
ext = szc
output_format = csv,screen
reportable = no
teeout = yes
teerunout = yes
makeflags = -j
##########################################
# Compiler and Runtime
##########################################
default:
CC = szc -lang=c
CXX = szc -lang=c++
FC = szc -lang=fortran
default=default=code,code.heap,code.link,code.stack,code.heap.link,code.heap.stack,code.link.stack,code.heap.link.stack:
CC += -Rcode
CXX += -Rcode
FC += -Rcode
default=default=heap,code.heap,heap.link,heap.stack,code.heap.link,code.heap.stack,heap.link.stack,code.heap.link.stack:
CC += -Rheap
CXX += -Rheap
FC += -Rheap
default=default=stack,code.stack,heap.stack,link.stack,code.heap.stack,code.link.stack,heap.link.stack,code.heap.link.stack:
CC += -Rstack
CXX += -Rstack
FC += -Rstack
default=default=link,code.link,heap.link,link.stack,code.heap.link,code.link.stack,heap.link.stack,code.heap.link.stack:
CC += -Rlink
CXX += -Rlink
FC += -Rlink
##########################################
# Optimization
##########################################
default=base:
COPTIMIZE = -O0 -fno-strict-aliasing
CXXOPTIMIZE = -O0 -fno-strict-aliasing
FOPTIMIZE = -O0 -fno-strict-aliasing
default=peak:
COPTIMIZE = -O1 -fno-strict-aliasing
CXXOPTIMIZE = -O1 -fno-strict-aliasing
FOPTIMIZE = -O1 -fno-strict-aliasing
##########################################
# Portability
##########################################
default:
PORTABILITY = -DSPEC_CPU_LP64
400.perlbench=default=default=linux:
CPORTABILITY = -DSPEC_CPU_LINUX_X64 -frontend=gcc
403.gcc=default=default=osx:
CPORTABILITY = -DSPEC_CPU_MACOSX
462.libquantum=default=default=linux:
CPORTABILITY = -DSPEC_CPU_LINUX
462.libquantum=default=defaut=osx:
CPORTABILITY = -DSPEC_CPU_MACOSX
481.wrf=default=default=linux:
CPORTABILITY = -DSPEC_CPU_CASE_FLAG -DSPEC_CPU_LINUX
483.xalancbmk=default=default=linux:
CXXPORTABILITY = -DSPEC_CPU_LINUX
483.xalancbmk=default=default=osx:
CXXPORTABILITY = -DSPEC_CPU_MACOSX
================================================
FILE: tests/Context/Makefile
================================================
ROOT = ../..
include $(ROOT)/common.mk
test:: hello.cpp stub.asm
yasm -o stub.o -f macho64 stub.asm
clang++ -g -I$(ROOT)/runtime -o hello hello.cpp stub.o
./hello
================================================
FILE: tests/Context/hello.cpp
================================================
#include <stdio.h>
#include <signal.h>
#include <sys/mman.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <new>
#include "Util.h"
#include "Jump.h"
using namespace std;
extern "C" uint8_t saveState;
extern "C" uint8_t stub;
extern "C" size_t stubSize;
void foo(int x, int y, int z) {
char buf[512];
sprintf(buf, "in foo: %x %x %x\n", x, y, z);
}
void bar(int x, int y, int z) {
char buf[512];
sprintf(buf, "in bar: %x %x %x\n", x, y, z);
}
void placeStub(void* p) {
size_t copySize = stubSize + sizeof(X86Jump64) + sizeof(void*);
void* base = ALIGN_DOWN(p, PAGESIZE);
void* limit = ALIGN_UP((uintptr_t)p + copySize, PAGESIZE);
size_t size = (uintptr_t)limit - (uintptr_t)base;
if(mprotect(base, size, PROT_READ | PROT_WRITE | PROT_EXEC)) {
perror("mprotect");
}
uint8_t* restore = new uint8_t[copySize];
memcpy(restore, (void*)p, copySize);
uint8_t* x = (uint8_t*)p;
memcpy((void*)x, (void*)&stub, stubSize);
x += stubSize;
new(x) Jump((void*)&saveState);
x += sizeof(X86Jump64);
*(void**)x = restore;
}
void placeTrap(void* p) {
size_t copySize = stubSize + sizeof(X86Jump64) + sizeof(void*);
void* base = ALIGN_DOWN(p, PAGESIZE);
void* limit = ALIGN_UP((uintptr_t)p + copySize, PAGESIZE);
size_t size = (uintptr_t)limit - (uintptr_t)base;
if(mprotect(base, size, PROT_READ | PROT_WRITE | PROT_EXEC)) {
perror("mprotect");
}
uint8_t* restore = new uint8_t[copySize];
memcpy(restore, (void*)p, copySize);
uint8_t* x = (uint8_t*)p;
*x = 0xCC;
x += stubSize + sizeof(X86Jump64);
*(void**)x = restore;
}
extern "C" void doStuff(void* source, void* restore) {
/*int count = 0;
int primes[100];
for(int x=2; count<100; x++) {
bool is_prime = true;
for(int d=0; d<count && is_prime; d++) {
if(x % primes[d] == 0) {
is_prime = false;
}
}
if(is_prime) {
primes[count] = x;
count++;
}
}
for(int i=0; i<100; i++) {
printf("%d ", primes[i]);
}*/
size_t restoreSize = stubSize + sizeof(X86Jump64) + sizeof(void*);
uint8_t** restorePtr = (uint8_t**)((uintptr_t)source + restoreSize - sizeof(void*));
memcpy((void*)source, *restorePtr, restoreSize);
}
void trap(int sig, siginfo_t *info, void *c) {
void* restore = (void*)GET_CONTEXT_IP(c);
void* source = (void*)((uintptr_t)restore - 1);
SET_CONTEXT_IP(c, (uintptr_t)source);
doStuff(source, restore);
}
int main(int argc, char** argv) {
struct sigaction sa;
sa.sa_sigaction = &trap;
sa.sa_flags = SA_SIGINFO;
sigaction(SIGTRAP, &sa, NULL);
/*placeStub((void*)foo);
placeTrap((void*)bar);
foo(0x12345, 0xABCDE, 0xD00FCA75);
bar(0x12345, 0xABCDE, 0xD00FCA75);*/
uint8_t* p = &stub;
for(int i=0; i<stubSize; i++) {
printf("%x ", *p);
p++;
}
for(int i=0; i<1; i++) {
placeTrap((void*)foo);
foo(0x12345, 0xABCDE, 0xD00FCA75);
}
return 0;
}
================================================
FILE: tests/Context/stub.asm
================================================
global _stub
global _stubSize
global _saveState
extern _doStuff
BITS 64
_stub:
lea rax, [rip-7]
sub rsp, 8
mov [rsp], rax
.end
_stubSize:
dq _stub.end - _stub
_saveState:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push r11
push r10
push r9
push r8
push rsi
push rdi
push rdx
push rcx
push rbx
push rax
mov rdi, 8[rbp]
lea rsi, (_stub.end - _stub)[rdi]
call _doStuff
pop rax
pop rbx
pop rcx
pop rdx
pop rdi
pop rsi
pop r8
pop r9
pop r10
pop r11
pop r12
pop r13
pop r14
pop r15
pop rbp
ret
================================================
FILE: tests/HelloWorld/Makefile
================================================
ROOT = ../..
TARGETS = hello
build:: hello
include $(ROOT)/common.mk
CC = $(ROOT)/szc $(SZCFLAGS) -Rcode -Rheap -Rstack
CXX = $(CC)
CXXFLAGS =
$(OBJS):: $(ROOT)/szc $(ROOT)/LLVMStabilizer.$(SHLIB_SUFFIX)
test:: hello
@echo $(INDENT)[test] Running 'hello'
@echo
@$(LD_PATH_VAR)=$(ROOT) ./hello
@echo
================================================
FILE: tests/HelloWorld/hello.cpp
================================================
#include <stdio.h>
void ctor() __attribute__((constructor));
void ctor() {
printf("Hello Constructor!\n");
}
int main(int argc, char** argv) {
printf("Hello World!\n");
return 0;
}
================================================
FILE: tests/LICENSE
================================================
The test programs in this directory are included for convenience, but are not integral parts of Stabilizer. Each test package has its own license independent of Stabilizer's top-level license.
================================================
FILE: tests/Makefile
================================================
ROOT = ..
RECURSIVE_TARGETS = test
DIRS = HelloWorld libquantum bzip2
include $(ROOT)/common.mk
================================================
FILE: tests/bzip2/Makefile
================================================
ROOT = ../..
TARGETS = bzip2
build:: bzip2
include $(ROOT)/common.mk
CC = $(ROOT)/szc $(SZCFLAGS) -Rcode -Rheap -Rstack
CXX = $(CC)
CFLAGS = -DSPEC_CPU -DSPEC_CPU_MACOSX
CXXFLAGS =
$(OBJS):: $(ROOT)/szc $(ROOT)/LLVMStabilizer.$(SHLIB_SUFFIX)
test:: bzip2
@echo $(INDENT)[test] Running 'bzip2'
@echo
@$(LD_PATH_VAR)=$(ROOT) ./bzip2 input.combined
@echo
================================================
FILE: tests/bzip2/blocksort.c
================================================
/*-------------------------------------------------------------*/
/*--- Block sorting machinery ---*/
/*--- blocksort.c ---*/
/*-------------------------------------------------------------*/
/*--
This file is a part of bzip2 and/or libbzip2, a program and
library for lossless, block-sorting data compression.
Copyright (C) 1996-2005 Julian R Seward. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
4. The name of the author may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Julian Seward, Cambridge, UK.
jseward@bzip.org
bzip2/libbzip2 version 1.0 of 21 March 2000
This program is based on (at least) the work of:
Mike Burrows
David Wheeler
Peter Fenwick
Alistair Moffat
Radford Neal
Ian H. Witten
Robert Sedgewick
Jon L. Bentley
For more information on these sources, see the manual.
To get some idea how the block sorting algorithms in this file
work, read my paper
On the Performance of BWT Sorting Algorithms
in Proceedings of the IEEE Data Compression Conference 2000,
Snowbird, Utah, USA, 27-30 March 2000. The main sort in this
file implements the algorithm called cache in the paper.
--*/
#include "bzlib_private.h"
/*---------------------------------------------*/
/*--- Fallback O(N log(N)^2) sorting ---*/
/*--- algorithm, for repetitive blocks ---*/
/*---------------------------------------------*/
/*---------------------------------------------*/
static
__inline__
void fallbackSimpleSort ( UInt32* fmap,
UInt32* eclass,
Int32 lo,
Int32 hi )
{
Int32 i, j, tmp;
UInt32 ec_tmp;
if (lo == hi) return;
if (hi - lo > 3) {
for ( i = hi-4; i >= lo; i-- ) {
tmp = fmap[i];
ec_tmp = eclass[tmp];
for ( j = i+4; j <= hi && ec_tmp > eclass[fmap[j]]; j += 4 )
fmap[j-4] = fmap[j];
fmap[j-4] = tmp;
}
}
for ( i = hi-1; i >= lo; i-- ) {
tmp = fmap[i];
ec_tmp = eclass[tmp];
for ( j = i+1; j <= hi && ec_tmp > eclass[fmap[j]]; j++ )
fmap[j-1] = fmap[j];
fmap[j-1] = tmp;
}
}
/*---------------------------------------------*/
#define fswap(zz1, zz2) \
{ Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; }
#define fvswap(zzp1, zzp2, zzn) \
{ \
Int32 yyp1 = (zzp1); \
Int32 yyp2 = (zzp2); \
Int32 yyn = (zzn); \
while (yyn > 0) { \
fswap(fmap[yyp1], fmap[yyp2]); \
yyp1++; yyp2++; yyn--; \
} \
}
#define fmin(a,b) ((a) < (b)) ? (a) : (b)
#define fpush(lz,hz) { stackLo[sp] = lz; \
stackHi[sp] = hz; \
sp++; }
#define fpop(lz,hz) { sp--; \
lz = stackLo[sp]; \
hz = stackHi[sp]; }
#define FALLBACK_QSORT_SMALL_THRESH 10
#define FALLBACK_QSORT_STACK_SIZE 100
static
void fallbackQSort3 ( UInt32* fmap,
UInt32* eclass,
Int32 loSt,
Int32 hiSt )
{
Int32 unLo, unHi, ltLo, gtHi, n, m;
Int32 sp, lo, hi;
UInt32 med, r, r3;
Int32 stackLo[FALLBACK_QSORT_STACK_SIZE];
Int32 stackHi[FALLBACK_QSORT_STACK_SIZE];
r = 0;
sp = 0;
fpush ( loSt, hiSt );
while (sp > 0) {
AssertH ( sp < FALLBACK_QSORT_STACK_SIZE, 1004 );
fpop ( lo, hi );
if (hi - lo < FALLBACK_QSORT_SMALL_THRESH) {
fallbackSimpleSort ( fmap, eclass, lo, hi );
continue;
}
/* Random partitioning. Median of 3 sometimes fails to
avoid bad cases. Median of 9 seems to help but
looks rather expensive. This too seems to work but
is cheaper. Guidance for the magic constants
7621 and 32768 is taken from Sedgewick's algorithms
book, chapter 35.
*/
r = ((r * 7621) + 1) % 32768;
r3 = r % 3;
if (r3 == 0) med = eclass[fmap[lo]]; else
if (r3 == 1) med = eclass[fmap[(lo+hi)>>1]]; else
med = eclass[fmap[hi]];
unLo = ltLo = lo;
unHi = gtHi = hi;
while (1) {
while (1) {
if (unLo > unHi) break;
n = (Int32)eclass[fmap[unLo]] - (Int32)med;
if (n == 0) {
fswap(fmap[unLo], fmap[ltLo]);
ltLo++; unLo++;
continue;
};
if (n > 0) break;
unLo++;
}
while (1) {
if (unLo > unHi) break;
n = (Int32)eclass[fmap[unHi]] - (Int32)med;
if (n == 0) {
fswap(fmap[unHi], fmap[gtHi]);
gtHi--; unHi--;
continue;
};
if (n < 0) break;
unHi--;
}
if (unLo > unHi) break;
fswap(fmap[unLo], fmap[unHi]); unLo++; unHi--;
}
AssertD ( unHi == unLo-1, "fallbackQSort3(2)" );
if (gtHi < ltLo) continue;
n = fmin(ltLo-lo, unLo-ltLo); fvswap(lo, unLo-n, n);
m = fmin(hi-gtHi, gtHi-unHi); fvswap(unLo, hi-m+1, m);
n = lo + unLo - ltLo - 1;
m = hi - (gtHi - unHi) + 1;
if (n - lo > hi - m) {
fpush ( lo, n );
fpush ( m, hi );
} else {
fpush ( m, hi );
fpush ( lo, n );
}
}
}
#undef fmin
#undef fpush
#undef fpop
#undef fswap
#undef fvswap
#undef FALLBACK_QSORT_SMALL_THRESH
#undef FALLBACK_QSORT_STACK_SIZE
/*---------------------------------------------*/
/* Pre:
nblock > 0
eclass exists for [0 .. nblock-1]
((UChar*)eclass) [0 .. nblock-1] holds block
ptr exists for [0 .. nblock-1]
Post:
((UChar*)eclass) [0 .. nblock-1] holds block
All other areas of eclass destroyed
fmap [0 .. nblock-1] holds sorted order
bhtab [ 0 .. 2+(nblock/32) ] destroyed
*/
#define SET_BH(zz) bhtab[(zz) >> 5] |= (1 << ((zz) & 31))
#define CLEAR_BH(zz) bhtab[(zz) >> 5] &= ~(1 << ((zz) & 31))
#define ISSET_BH(zz) (bhtab[(zz) >> 5] & (1 << ((zz) & 31)))
#define WORD_BH(zz) bhtab[(zz) >> 5]
#define UNALIGNED_BH(zz) ((zz) & 0x01f)
static
void fallbackSort ( UInt32* fmap,
UInt32* eclass,
UInt32* bhtab,
Int32 nblock,
Int32 verb )
{
Int32 ftab[257];
Int32 ftabCopy[256];
Int32 H, i, j, k, l, r, cc, cc1;
Int32 nNotDone;
Int32 nBhtab;
UChar* eclass8 = (UChar*)eclass;
/*--
Initial 1-char radix sort to generate
initial fmap and initial BH bits.
--*/
if (verb >= 4)
VPrintf0 ( " bucket sorting ...\n" );
for (i = 0; i < 257; i++) ftab[i] = 0;
for (i = 0; i < nblock; i++) ftab[eclass8[i]]++;
for (i = 0; i < 256; i++) ftabCopy[i] = ftab[i];
for (i = 1; i < 257; i++) ftab[i] += ftab[i-1];
for (i = 0; i < nblock; i++) {
j = eclass8[i];
k = ftab[j] - 1;
ftab[j] = k;
fmap[k] = i;
}
nBhtab = 2 + (nblock / 32);
for (i = 0; i < nBhtab; i++) bhtab[i] = 0;
for (i = 0; i < 256; i++) SET_BH(ftab[i]);
/*--
Inductively refine the buckets. Kind-of an
"exponential radix sort" (!), inspired by the
Manber-Myers suffix array construction algorithm.
--*/
/*-- set sentinel bits for block-end detection --*/
for (i = 0; i < 32; i++) {
SET_BH(nblock + 2*i);
CLEAR_BH(nblock + 2*i + 1);
}
/*-- the log(N) loop --*/
H = 1;
while (1) {
if (verb >= 4)
VPrintf1 ( " depth %6d has ", H );
j = 0;
for (i = 0; i < nblock; i++) {
if (ISSET_BH(i)) j = i;
k = fmap[i] - H; if (k < 0) k += nblock;
eclass[k] = j;
}
nNotDone = 0;
r = -1;
while (1) {
/*-- find the next non-singleton bucket --*/
k = r + 1;
while (ISSET_BH(k) && UNALIGNED_BH(k)) k++;
if (ISSET_BH(k)) {
while (WORD_BH(k) == 0xffffffff) k += 32;
while (ISSET_BH(k)) k++;
}
l = k - 1;
if (l >= nblock) break;
while (!ISSET_BH(k) && UNALIGNED_BH(k)) k++;
if (!ISSET_BH(k)) {
while (WORD_BH(k) == 0x00000000) k += 32;
while (!ISSET_BH(k)) k++;
}
r = k - 1;
if (r >= nblock) break;
/*-- now [l, r] bracket current bucket --*/
if (r > l) {
nNotDone += (r - l + 1);
fallbackQSort3 ( fmap, eclass, l, r );
/*-- scan bucket and generate header bits-- */
cc = -1;
for (i = l; i <= r; i++) {
cc1 = eclass[fmap[i]];
if (cc != cc1) { SET_BH(i); cc = cc1; };
}
}
}
if (verb >= 4)
VPrintf1 ( "%6d unresolved strings\n", nNotDone );
H *= 2;
if (H > nblock || nNotDone == 0) break;
}
/*--
Reconstruct the original block in
eclass8 [0 .. nblock-1], since the
previous phase destroyed it.
--*/
if (verb >= 4)
VPrintf0 ( " reconstructing block ...\n" );
j = 0;
for (i = 0; i < nblock; i++) {
while (ftabCopy[j] == 0) j++;
ftabCopy[j]--;
eclass8[fmap[i]] = (UChar)j;
}
AssertH ( j < 256, 1005 );
}
#undef SET_BH
#undef CLEAR_BH
#undef ISSET_BH
#undef WORD_BH
#undef UNALIGNED_BH
/*---------------------------------------------*/
/*--- The main, O(N^2 log(N)) sorting ---*/
/*--- algorithm. Faster for "normal" ---*/
/*--- non-repetitive blocks. ---*/
/*---------------------------------------------*/
/*---------------------------------------------*/
static
__inline__
Bool mainGtU ( UInt32 i1,
UInt32 i2,
UChar* block,
UInt16* quadrant,
UInt32 nblock,
Int32* budget )
{
Int32 k;
UChar c1, c2;
UInt16 s1, s2;
AssertD ( i1 != i2, "mainGtU" );
/* 1 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 2 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 3 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 4 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 5 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 6 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 7 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 8 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 9 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 10 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 11 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
/* 12 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
i1++; i2++;
k = nblock + 8;
do {
/* 1 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
/* 2 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
/* 3 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
/* 4 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
/* 5 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
/* 6 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
/* 7 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
/* 8 */
c1 = block[i1]; c2 = block[i2];
if (c1 != c2) return (c1 > c2);
s1 = quadrant[i1]; s2 = quadrant[i2];
if (s1 != s2) return (s1 > s2);
i1++; i2++;
if (i1 >= nblock) i1 -= nblock;
if (i2 >= nblock) i2 -= nblock;
k -= 8;
(*budget)--;
}
while (k >= 0);
return False;
}
/*---------------------------------------------*/
/*--
Knuth's increments seem to work better
than Incerpi-Sedgewick here. Possibly
because the number of elems to sort is
usually small, typically <= 20.
--*/
static
Int32 incs[14] = { 1, 4, 13, 40, 121, 364, 1093, 3280,
9841, 29524, 88573, 265720,
797161, 2391484 };
static
void mainSimpleSort ( UInt32* ptr,
UChar* block,
UInt16* quadrant,
Int32 nblock,
Int32 lo,
Int32 hi,
Int32 d,
Int32* budget )
{
Int32 i, j, h, bigN, hp;
UInt32 v;
bigN = hi - lo + 1;
if (bigN < 2) return;
hp = 0;
while (incs[hp] < bigN) hp++;
hp--;
for (; hp >= 0; hp--) {
h = incs[hp];
i = lo + h;
while (True) {
/*-- copy 1 --*/
if (i > hi) break;
v = ptr[i];
j = i;
while ( mainGtU (
ptr[j-h]+d, v+d, block, quadrant, nblock, budget
) ) {
ptr[j] = ptr[j-h];
j = j - h;
if (j <= (lo + h - 1)) break;
}
ptr[j] = v;
i++;
/*-- copy 2 --*/
if (i > hi) break;
v = ptr[i];
j = i;
while ( mainGtU (
ptr[j-h]+d, v+d, block, quadrant, nblock, budget
) ) {
ptr[j] = ptr[j-h];
j = j - h;
if (j <= (lo + h - 1)) break;
}
ptr[j] = v;
i++;
/*-- copy 3 --*/
if (i > hi) break;
v = ptr[i];
j = i;
while ( mainGtU (
ptr[j-h]+d, v+d, block, quadrant, nblock, budget
) ) {
ptr[j] = ptr[j-h];
j = j - h;
if (j <= (lo + h - 1)) break;
}
ptr[j] = v;
i++;
if (*budget < 0) return;
}
}
}
/*---------------------------------------------*/
/*--
The following is an implementation of
an elegant 3-way quicksort for strings,
described in a paper "Fast Algorithms for
Sorting and Searching Strings", by Robert
Sedgewick and Jon L. Bentley.
--*/
#define mswap(zz1, zz2) \
{ Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; }
#define mvswap(zzp1, zzp2, zzn) \
{ \
Int32 yyp1 = (zzp1); \
Int32 yyp2 = (zzp2); \
Int32 yyn = (zzn); \
while (yyn > 0) { \
mswap(ptr[yyp1], ptr[yyp2]); \
yyp1++; yyp2++; yyn--; \
} \
}
static
__inline__
UChar mmed3 ( UChar a, UChar b, UChar c )
{
UChar t;
if (a > b) { t = a; a = b; b = t; };
if (b > c) {
b = c;
if (a > b) b = a;
}
return b;
}
#define mmin(a,b) ((a) < (b)) ? (a) : (b)
#define mpush(lz,hz,dz) { stackLo[sp] = lz; \
stackHi[sp] = hz; \
stackD [sp] = dz; \
sp++; }
#define mpop(lz,hz,dz) { sp--; \
lz = stackLo[sp]; \
hz = stackHi[sp]; \
dz = stackD [sp]; }
#define mnextsize(az) (nextHi[az]-nextLo[az])
#define mnextswap(az,bz) \
{ Int32 tz; \
tz = nextLo[az]; nextLo[az] = nextLo[bz]; nextLo[bz] = tz; \
tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \
tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; }
#define MAIN_QSORT_SMALL_THRESH 20
#define MAIN_QSORT_DEPTH_THRESH (BZ_N_RADIX + BZ_N_QSORT)
#define MAIN_QSORT_STACK_SIZE 100
static
void mainQSort3 ( UInt32* ptr,
UChar* block,
UInt16* quadrant,
Int32 nblock,
Int32 loSt,
Int32 hiSt,
Int32 dSt,
Int32* budget )
{
Int32 unLo, unHi, ltLo, gtHi, n, m, med;
Int32 sp, lo, hi, d;
Int32 stackLo[MAIN_QSORT_STACK_SIZE];
Int32 stackHi[MAIN_QSORT_STACK_SIZE];
Int32 stackD [MAIN_QSORT_STACK_SIZE];
Int32 nextLo[3];
Int32 nextHi[3];
Int32 nextD [3];
sp = 0;
mpush ( loSt, hiSt, dSt );
while (sp > 0) {
AssertH ( sp < MAIN_QSORT_STACK_SIZE, 1001 );
mpop ( lo, hi, d );
if (hi - lo < MAIN_QSORT_SMALL_THRESH ||
d > MAIN_QSORT_DEPTH_THRESH) {
mainSimpleSort ( ptr, block, quadrant, nblock, lo, hi, d, budget );
if (*budget < 0) return;
continue;
}
med = (Int32)
mmed3 ( block[ptr[ lo ]+d],
block[ptr[ hi ]+d],
block[ptr[ (lo+hi)>>1 ]+d] );
unLo = ltLo = lo;
unHi = gtHi = hi;
while (True) {
while (True) {
if (unLo > unHi) break;
n = ((Int32)block[ptr[unLo]+d]) - med;
if (n == 0) {
mswap(ptr[unLo], ptr[ltLo]);
ltLo++; unLo++; continue;
};
if (n > 0) break;
unLo++;
}
while (True) {
if (unLo > unHi) break;
n = ((Int32)block[ptr[unHi]+d]) - med;
if (n == 0) {
mswap(ptr[unHi], ptr[gtHi]);
gtHi--; unHi--; continue;
};
if (n < 0) break;
unHi--;
}
if (unLo > unHi) break;
mswap(ptr[unLo], ptr[unHi]); unLo++; unHi--;
}
AssertD ( unHi == unLo-1, "mainQSort3(2)" );
if (gtHi < ltLo) {
mpush(lo, hi, d+1 );
continue;
}
n = mmin(ltLo-lo, unLo-ltLo); mvswap(lo, unLo-n, n);
m = mmin(hi-gtHi, gtHi-unHi); mvswap(unLo, hi-m+1, m);
n = lo + unLo - ltLo - 1;
m = hi - (gtHi - unHi) + 1;
nextLo[0] = lo; nextHi[0] = n; nextD[0] = d;
nextLo[1] = m; nextHi[1] = hi; nextD[1] = d;
nextLo[2] = n+1; nextHi[2] = m-1; nextD[2] = d+1;
if (mnextsize(0) < mnextsize(1)) mnextswap(0,1);
if (mnextsize(1) < mnextsize(2)) mnextswap(1,2);
if (mnextsize(0) < mnextsize(1)) mnextswap(0,1);
AssertD (mnextsize(0) >= mnextsize(1), "mainQSort3(8)" );
AssertD (mnextsize(1) >= mnextsize(2), "mainQSort3(9)" );
mpush (nextLo[0], nextHi[0], nextD[0]);
mpush (nextLo[1], nextHi[1], nextD[1]);
mpush (nextLo[2], nextHi[2], nextD[2]);
}
}
#undef mswap
#undef mvswap
#undef mpush
#undef mpop
#undef mmin
#undef mnextsize
#undef mnextswap
#undef MAIN_QSORT_SMALL_THRESH
#undef MAIN_QSORT_DEPTH_THRESH
#undef MAIN_QSORT_STACK_SIZE
/*---------------------------------------------*/
/* Pre:
nblock > N_OVERSHOOT
block32 exists for [0 .. nblock-1 +N_OVERSHOOT]
((UChar*)block32) [0 .. nblock-1] holds block
ptr exists for [0 .. nblock-1]
Post:
((UChar*)block32) [0 .. nblock-1] holds block
All other areas of block32 destroyed
ftab [0 .. 65536 ] destroyed
ptr [0 .. nblock-1] holds sorted order
if (*budget < 0), sorting was abandoned
*/
#define BIGFREQ(b) (ftab[((b)+1) << 8] - ftab[(b) << 8])
#define SETMASK (1 << 21)
#define CLEARMASK (~(SETMASK))
static
void mainSort ( UInt32* ptr,
UChar* block,
UInt16* quadrant,
UInt32* ftab,
Int32 nblock,
Int32 verb,
Int32* budget )
{
Int32 i, j, k, ss, sb;
Int32 runningOrder[256];
Bool bigDone[256];
Int32 copyStart[256];
Int32 copyEnd [256];
UChar c1;
Int32 numQSorted;
UInt16 s;
if (verb >= 4) VPrintf0 ( " main sort initialise ...\n" );
/*-- set up the 2-byte frequency table --*/
for (i = 65536; i >= 0; i--) ftab[i] = 0;
j = block[0] << 8;
i = nblock-1;
for (; i >= 3; i -= 4) {
quadrant[i] = 0;
j = (j >> 8) | ( ((UInt16)block[i]) << 8);
ftab[j]++;
quadrant[i-1] = 0;
j = (j >> 8) | ( ((UInt16)block[i-1]) << 8);
ftab[j]++;
quadrant[i-2] = 0;
j = (j >> 8) | ( ((UInt16)block[i-2]) << 8);
ftab[j]++;
quadrant[i-3] = 0;
j = (j >> 8) | ( ((UInt16)block[i-3]) << 8);
ftab[j]++;
}
for (; i >= 0; i--) {
quadrant[i] = 0;
j = (j >> 8) | ( ((UInt16)block[i]) << 8);
ftab[j]++;
}
/*-- (emphasises close relationship of block & quadrant) --*/
for (i = 0; i < BZ_N_OVERSHOOT; i++) {
block [nblock+i] = block[i];
quadrant[nblock+i] = 0;
}
if (verb >= 4) VPrintf0 ( " bucket sorting ...\n" );
/*-- Complete the initial radix sort --*/
for (i = 1; i <= 65536; i++) ftab[i] += ftab[i-1];
s = block[0] << 8;
i = nblock-1;
for (; i >= 3; i -= 4) {
s = (s >> 8) | (block[i] << 8);
j = ftab[s] -1;
ftab[s] = j;
ptr[j] = i;
s = (s >> 8) | (block[i-1] << 8);
j = ftab[s] -1;
ftab[s] = j;
ptr[j] = i-1;
s = (s >> 8) | (block[i-2] << 8);
j = ftab[s] -1;
ftab[s] = j;
ptr[j] = i-2;
s = (s >> 8) | (block[i-3] << 8);
j = ftab[s] -1;
ftab[s] = j;
ptr[j] = i-3;
}
for (; i >= 0; i--) {
s = (s >> 8) | (block[i] << 8);
j = ftab[s] -1;
ftab[s] = j;
ptr[j] = i;
}
/*--
Now ftab contains the first loc of every small bucket.
Calculate the running order, from smallest to largest
big bucket.
--*/
for (i = 0; i <= 255; i++) {
bigDone [i] = False;
runningOrder[i] = i;
}
{
Int32 vv;
Int32 h = 1;
do h = 3 * h + 1; while (h <= 256);
do {
h = h / 3;
for (i = h; i <= 255; i++) {
vv = runningOrder[i];
j = i;
while ( BIGFREQ(runningOrder[j-h]) > BIGFREQ(vv) ) {
runningOrder[j] = runningOrder[j-h];
j = j - h;
if (j <= (h - 1)) goto zero;
}
zero:
runningOrder[j] = vv;
}
} while (h != 1);
}
/*--
The main sorting loop.
--*/
numQSorted = 0;
for (i = 0; i <= 255; i++) {
/*--
Process big buckets, starting with the least full.
Basically this is a 3-step process in which we call
mainQSort3 to sort the small buckets [ss, j], but
also make a big effort to avoid the calls if we can.
--*/
ss = runningOrder[i];
/*--
Step 1:
Complete the big bucket [ss] by quicksorting
any unsorted small buckets [ss, j], for j != ss.
Hopefully previous pointer-scanning phases have already
completed many of the small buckets [ss, j], so
we don't have to sort them at all.
--*/
for (j = 0; j <= 255; j++) {
if (j != ss) {
sb = (ss << 8) + j;
if ( ! (ftab[sb] & SETMASK) ) {
Int32 lo = ftab[sb] & CLEARMASK;
Int32 hi = (ftab[sb+1] & CLEARMASK) - 1;
if (hi > lo) {
if (verb >= 4)
VPrintf4 ( " qsort [0x%x, 0x%x] "
"done %d this %d\n",
(unsigned)ss, (unsigned)j, numQSorted, hi - lo + 1 );
mainQSort3 (
ptr, block, quadrant, nblock,
lo, hi, BZ_N_RADIX, budget
);
numQSorted += (hi - lo + 1);
if (*budget < 0) return;
}
}
ftab[sb] |= SETMASK;
}
}
AssertH ( !bigDone[ss], 1006 );
/*--
Step 2:
Now scan this big bucket [ss] so as to synthesise the
sorted order for small buckets [t, ss] for all t,
including, magically, the bucket [ss,ss] too.
This will avoid doing Real Work in subsequent Step 1's.
--*/
{
for (j = 0; j <= 255; j++) {
copyStart[j] = ftab[(j << 8) + ss] & CLEARMASK;
copyEnd [j] = (ftab[(j << 8) + ss + 1] & CLEARMASK) - 1;
}
for (j = ftab[ss << 8] & CLEARMASK; j < copyStart[ss]; j++) {
k = ptr[j]-1; if (k < 0) k += nblock;
c1 = block[k];
if (!bigDone[c1])
ptr[ copyStart[c1]++ ] = k;
}
for (j = (ftab[(ss+1) << 8] & CLEARMASK) - 1; j > copyEnd[ss]; j--) {
k = ptr[j]-1; if (k < 0) k += nblock;
c1 = block[k];
if (!bigDone[c1])
ptr[ copyEnd[c1]-- ] = k;
}
}
AssertH ( (copyStart[ss]-1 == copyEnd[ss])
||
/* Extremely rare case missing in bzip2-1.0.0 and 1.0.1.
Necessity for this case is demonstrated by compressing
a sequence of approximately 48.5 million of character
251; 1.0.0/1.0.1 will then die here. */
(copyStart[ss] == 0 && copyEnd[ss] == nblock-1),
1007 )
for (j = 0; j <= 255; j++) ftab[(j << 8) + ss] |= SETMASK;
/*--
Step 3:
The [ss] big bucket is now done. Record this fact,
and update the quadrant descriptors. Remember to
update quadrants in the overshoot area too, if
necessary. The "if (i < 255)" test merely skips
this updating for the last bucket processed, since
updating for the last bucket is pointless.
The quadrant array provides a way to incrementally
cache sort orderings, as they appear, so as to
make subsequent comparisons in fullGtU() complete
faster. For repetitive blocks this makes a big
difference (but not big enough to be able to avoid
the fallback sorting mechanism, exponential radix sort).
The precise meaning is: at all times:
for 0 <= i < nblock and 0 <= j <= nblock
if block[i] != block[j],
then the relative values of quadrant[i] and
quadrant[j] are meaningless.
else {
if quadrant[i] < quadrant[j]
then the string starting at i lexicographically
precedes the string starting at j
else if quadrant[i] > quadrant[j]
then the string starting at j lexicographically
precedes the string starting at i
else
the relative ordering of the strings starting
at i and j has not yet been determined.
}
--*/
bigDone[ss] = True;
if (i < 255) {
Int32 bbStart = ftab[ss << 8] & CLEARMASK;
Int32 bbSize = (ftab[(ss+1) << 8] & CLEARMASK) - bbStart;
Int32 shifts = 0;
while ((bbSize >> shifts) > 65534) shifts++;
for (j = bbSize-1; j >= 0; j--) {
Int32 a2update = ptr[bbStart + j];
UInt16 qVal = (UInt16)(j >> shifts);
quadrant[a2update] = qVal;
if (a2update < BZ_N_OVERSHOOT)
quadrant[a2update + nblock] = qVal;
}
AssertH ( ((bbSize-1) >> shifts) <= 65535, 1002 );
}
}
if (verb >= 4)
VPrintf3 ( " %d pointers, %d sorted, %d scanned\n",
nblock, numQSorted, nblock - numQSorted );
}
#undef BIGFREQ
#undef SETMASK
#undef CLEARMASK
/*---------------------------------------------*/
/* Pre:
nblock > 0
arr2 exists for [0 .. nblock-1 +N_OVERSHOOT]
((UChar*)arr2) [0 .. nblock-1] holds block
arr1 exists for [0 .. nblock-1]
Post:
((UChar*)arr2) [0 .. nblock-1] holds block
All other areas of block destroyed
ftab [ 0 .. 65536 ] destroyed
arr1 [0 .. nblock-1] holds sorted order
*/
void BZ2_blockSort ( EState* s )
{
UInt32* ptr = s->ptr;
UChar* block = s->block;
UInt32* ftab = s->ftab;
Int32 nblock = s->nblock;
Int32 verb = s->verbosity;
Int32 wfact = s->workFactor;
UInt16* quadrant;
Int32 budget;
Int32 budgetInit;
Int32 i;
if (nblock < 10000) {
fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb );
} else {
/* Calculate the location for quadrant, remembering to get
the alignment right. Assumes that &(block[0]) is at least
2-byte aligned -- this should be ok since block is really
the first section of arr2.
*/
i = nblock+BZ_N_OVERSHOOT;
if (i & 1) i++;
quadrant = (UInt16*)(&(block[i]));
/* (wfact-1) / 3 puts the default-factor-30
transition point at very roughly the same place as
with v0.1 and v0.9.0.
Not that it particularly matters any more, since the
resulting compressed stream is now the same regardless
of whether or not we use the main sort or fallback sort.
*/
if (wfact < 1 ) wfact = 1;
if (wfact > 100) wfact = 100;
budgetInit = nblock * ((wfact-1) / 3);
budget = budgetInit;
mainSort ( ptr, block, quadrant, ftab, nblock, verb, &budget );
if (verb >= 3)
VPrintf3 ( " %d work, %d block, ratio %5.2f\n",
budgetInit - budget,
nblock,
(float)(budgetInit - budget) /
(float)(nblock==0 ? 1 : nblock) );
if (budget < 0) {
if (verb >= 2)
VPrintf0 ( " too repetitive; using fallback"
" sorting algorithm\n" );
fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb );
}
}
s->origPtr = -1;
for (i = 0; i < s->nblock; i++)
if (ptr[i] == 0)
{ s->origPtr = i; break; };
AssertH( s->origPtr != -1, 1003 );
}
/*-------------------------------------------------------------*/
/*--- end blocksort.c ---*/
/*-------------------------------------------------------------*/
================================================
FILE: tests/bzip2/bzip2.c
================================================
/*-----------------------------------------------------------*/
/*--- A block-sorting, lossless compressor bzip2.c ---*/
/*-----------------------------------------------------------*/
/*--
This file is a part of bzip2 and/or libbzip2, a program and
library for lossless, block-sorting data compression.
Copyright (C) 1996-2005 Julian R Seward. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
4. The name of the author may not be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Julian Seward, Cambridge, UK.
jseward@bzip.org
bzip2/libbzip2 version 1.0 of 21 March 2000
This program is based on (at least) the work of:
Mike Burrows
David Wheeler
Peter Fenwick
Alistair Moffat
Radford Neal
Ian H. Witten
Robert Sedgewick
Jon L. Bentley
For more information on these sources, see the manual.
--*/
/*----------------------------------------------------*/
/*--- IMPORTANT ---*/
/*----------------------------------------------------*/
/*--
WARNING:
This program and library (attempts to) compress data by
performing several non-trivial transformations on it.
Unless you are 100% familiar with *all* the algorithms
contained herein, and with the consequences of modifying them,
you should NOT meddle with the compression or decompression
machinery. Incorrect changes can and very likely *will*
lead to disasterous loss of data.
DISCLAIMER:
I TAKE NO RESPONSIBILITY FOR ANY LOSS OF DATA ARISING FROM THE
USE OF THIS PROGRAM, HOWSOEVER CAUSED.
Every compression of a file implies an assumption that the
compressed file can be decompressed to reproduce the original.
Great efforts in design, coding and testing have been made to
ensure that this program works correctly. However, the
complexity of the algorithms, and, in particular, the presence
of various special cases in the code which occur with very low
but non-zero probability make it impossible to rule out the
possibility of bugs remaining in the program. DO NOT COMPRESS
ANY DATA WITH THIS PROGRAM AND/OR LIBRARY UNLESS YOU ARE PREPARED
TO ACCEPT THE POSSIBILITY, HOWEVER SMALL, THAT THE DATA WILL
NOT BE RECOVERABLE.
That is not to say this program is inherently unreliable.
Indeed, I very much hope the opposite is true. bzip2/libbzip2
has been carefully constructed and extensively tested.
PATENTS:
To the best of my knowledge, bzip2/libbzip2 does not use any
patented algorithms. However, I do not have the resources
available to carry out a full patent search. Therefore I cannot
give any guarantee of the above statement.
--*/
/*----------------------------------------------------*/
/*--- and now for something much more pleasant :-) ---*/
/*----------------------------------------------------*/
/*---------------------------------------------*/
/*--
Place a 1 beside your platform, and 0 elsewhere.
--*/
/*--
Generic 32-bit Unix.
Also works on 64-bit Unix boxes.
This is the default.
--*/
#if defined(SPEC_CPU)
#define BZ_UNIX 0
#else
#define BZ_UNIX 1
#endif
/*--
Win32, as seen by Jacob Navia's excellent
port of (Chris Fraser & David Hanson)'s excellent
lcc compiler. Or with MS Visual C.
This is selected automatically if compiled by a compiler which
defines _WIN32, not including the Cygwin GCC.
--*/
#define BZ_LCCWIN32 0
#if !defined(SPEC_CPU)
#if defined(_WIN32) && !defined(__CYGWIN__)
#undef BZ_LCCWIN32
#define BZ_LCCWIN32 1
#undef BZ_UNIX
#define BZ_UNIX 0
#endif
#endif /* !SPEC_CPU */
/*---------------------------------------------*/
/*--
Some stuff for all platforms.
--*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <math.h>
#include <errno.h>
#include <ctype.h>
#include "bzlib.h"
#include "spec.h"
#define ERROR_IF_EOF(i) { if ((i) == EOF) ioError(); }
#define ERROR_IF_NOT_ZERO(i) { if ((i) != 0) ioError(); }
#define ERROR_IF_MINUS_ONE(i) { if ((i) == (-1)) ioError(); }
/*---------------------------------------------*/
/*--
Platform-specific stuff.
--*/
#if BZ_UNIX
# include <fcntl.h>
# include <sys/types.h>
# include <utime.h>
# include <unistd.h>
# include <sys/stat.h>
# include <sys/times.h>
# define PATH_SEP '/'
# define MY_LSTAT lstat
# define MY_STAT stat
# define MY_S_ISREG S_ISREG
# define MY_S_ISDIR S_ISDIR
# define APPEND_FILESPEC(root, name) \
root=snocString((root), (name))
# define APPEND_FLAG(root, name) \
root=snocString((root), (name))
# define SET_BINARY_MODE(fd) /**/
# if !defined(SPEC_CPU) && defined(__GNUC__)
# define NORETURN __attribute__ ((noreturn))
# else
# define NORETURN /**/
# endif
# ifdef __DJGPP__
# include <io.h>
# include <fcntl.h>
# undef MY_LSTAT
# undef MY_STAT
# define MY_LSTAT stat
# define MY_STAT stat
# undef SET_BINARY_MODE
# define SET_BINARY_MODE(fd) \
do { \
int retVal = setmode ( fileno ( fd ), \
O_BINARY ); \
ERROR_IF_MINUS_ONE ( retVal ); \
} while ( 0 )
# endif
# ifdef __CYGWIN__
# include <io.h>
# include <fcntl.h>
# undef SET_BINARY_MODE
# define SET_BINARY_MODE(fd) \
do { \
int retVal = setmode ( fileno ( fd ), \
O_BINARY ); \
ERROR_IF_MINUS_ONE ( retVal ); \
} while ( 0 )
# endif
#endif /* BZ_UNIX */
#if BZ_LCCWIN32
# include <io.h>
# include <fcntl.h>
# include <sys\stat.h>
# define NORETURN /**/
# define PATH_SEP '\\'
# define MY_LSTAT _stat
# define MY_STAT _stat
# define MY_S_ISREG(x) ((x) & _S_IFREG)
# define MY_S_ISDIR(x) ((x) & _S_IFDIR)
# define APPEND_FLAG(root, name) \
root=snocString((root), (name))
# define APPEND_FILESPEC(root, name) \
root = snocString ((root), (name))
# define SET_BINARY_MODE(fd) \
do { \
int retVal = setmode ( fileno ( fd ), \
O_BINARY ); \
ERROR_IF_MINUS_ONE ( retVal ); \
} while ( 0 )
#endif /* BZ_LCCWIN32 */
/*---------------------------------------------*/
/*--
Some more stuff for all platforms :-)
--*/
typedef char Char;
typedef unsigned char Bool;
typedef unsigned char UChar;
typedef int Int32;
typedef unsigned int UInt32;
typedef short Int16;
typedef unsigned short UInt16;
#define True ((Bool)1)
#define False ((Bool)0)
/*--
IntNative is your platform's `native' int size.
Only here to avoid probs with 64-bit platforms.
--*/
typedef int IntNative;
/*---------------------------------------------------*/
/*--- Misc (file handling) data decls ---*/
/*---------------------------------------------------*/
Int32 verbosity;
Bool keepInputFiles, smallMode, deleteOutputOnInterrupt;
Bool forceOverwrite, testFailsExist, unzFailsExist, noisy;
Int32 numFileNames, numFilesProcessed, blockSize100k;
Int32 exitValue;
/*-- source modes; F==file, I==stdin, O==stdout --*/
#define SM_I2O 1
#define SM_F2O 2
#define SM_F2F 3
/*-- operation modes --*/
#define OM_Z 1
#define OM_UNZ 2
#define OM_TEST 3
Int32 opMode;
Int32 srcMode;
#define FILE_NAME_LEN 1034
Int32 longestFileName;
Char inName [FILE_NAME_LEN];
Char outName[FILE_NAME_LEN];
Char tmpName[FILE_NAME_LEN];
Char *progName;
Char progNameReally[FILE_NAME_LEN];
#if defined(SPEC_CPU)
int outputHandleJustInCase;
#else
FILE *outputHandleJustInCase;
#endif
Int32 workFactor;
static void panic ( Char* ) NORETURN;
static void ioError ( void ) NORETURN;
static void outOfMemory ( void ) NORETURN;
static void configError ( void ) NORETURN;
static void crcError ( void ) NORETURN;
static void cleanUpAndFail ( Int32 ) NORETURN;
static void compressedStreamEOF ( void ) NORETURN;
static void copyFileName ( Char*, Char* );
static void* myMalloc ( Int32 );
/*---------------------------------------------------*/
/*--- An implementation of 64-bit ints. Sigh. ---*/
/*--- Roll on widespread deployment of ANSI C9X ! ---*/
/*---------------------------------------------------*/
typedef
struct { UChar b[8]; }
UInt64;
static
void uInt64_from_UInt32s ( UInt64* n, UInt32 lo32, UInt32 hi32 )
{
n->b[7] = (UChar)((hi32 >> 24) & 0xFF);
n->b[6] = (UChar)((hi32 >> 16) & 0xFF);
n->b[5] = (UChar)((hi32 >> 8) & 0xFF);
n->b[4] = (UChar) (hi32 & 0xFF);
n->b[3] = (UChar)((lo32 >> 24) & 0xFF);
n->b[2] = (UChar)((lo32 >> 16) & 0xFF);
n->b[1] = (UChar)((lo32 >> 8) & 0xFF);
n->b[0] = (UChar) (lo32 & 0xFF);
}
static
double uInt64_to_double ( UInt64* n )
{
Int32 i;
double base = 1.0;
double sum = 0.0;
for (i = 0; i < 8; i++) {
sum += base * (double)(n->b[i]);
base *= 256.0;
}
return sum;
}
static
Bool uInt64_isZero ( UInt64* n )
{
Int32 i;
for (i = 0; i < 8; i++)
if (n->b[i] != 0) return 0;
return 1;
}
/* Divide *n by 10, and return the remainder. */
static
Int32 uInt64_qrm10 ( UInt64* n )
{
UInt32 rem, tmp;
Int32 i;
rem = 0;
for (i = 7; i >= 0; i--) {
tmp = rem * 256 + n->b[i];
n->b[i] = tmp / 10;
rem = tmp % 10;
}
return rem;
}
/* ... and the Whole Entire Point of all this UInt64 stuff is
so that we can supply the following function.
*/
static
void uInt64_toAscii ( char* outbuf, UInt64* n )
{
Int32 i, q;
UChar buf[32];
Int32 nBuf = 0;
UInt64 n_copy = *n;
do {
q = uInt64_qrm10 ( &n_copy );
buf[nBuf] = q + '0';
nBuf++;
} while (!uInt64_isZero(&n_copy));
outbuf[nBuf] = 0;
for (i = 0; i < nBuf; i++)
outbuf[i] = buf[nBuf-i-1];
}
/*---------------------------------------------------*/
/*--- Processing of complete files and streams ---*/
/*---------------------------------------------------*/
/*---------------------------------------------*/
static
#if defined(SPEC_CPU)
Bool myfeof ( int f )
#else
Bool myfeof ( FILE* f )
#endif
{
Int32 c = fgetc ( f );
if (c == EOF) return True;
ungetc ( c, f );
return False;
}
/*---------------------------------------------*/
#if defined(SPEC_CPU)
void compressStream ( int stream, int zStream )
#else
static
void compressStream ( FILE *stream, FILE *zStream )
#endif
{
BZFILE* bzf = NULL;
UChar ibuf[5000];
Int32 nIbuf;
UInt32 nbytes_in_lo32, nbytes_in_hi32;
UInt32 nbytes_out_lo32, nbytes_out_hi32;
Int32 bzerr, bzerr_dummy, ret;
SET_BINARY_MODE(stream);
SET_BINARY_MODE(zStream);
if (ferror(stream)) goto errhandler_io;
if (ferror(zStream)) goto errhandler_io;
bzf = BZ2_bzWriteOpen ( &bzerr, zStream,
blockSize100k, verbosity, workFactor );
if (bzerr != BZ_OK) goto errhandler;
if (verbosity >= 2) fprintf ( stderr, "\n" );
while (True) {
if (myfeof(stream)) break;
nIbuf = fread ( ibuf, sizeof(UChar), 5000, stream );
if (ferror(stream)) goto errhandler_io;
if (nIbuf > 0) BZ2_bzWrite ( &bzerr, bzf, (void*)ibuf, nIbuf );
if (bzerr != BZ_OK) goto errhandler;
}
BZ2_bzWriteClose64 ( &bzerr, bzf, 0,
&nbytes_in_lo32, &nbytes_in_hi32,
&nbytes_out_lo32, &nbytes_out_hi32 );
if (bzerr != BZ_OK) goto errhandler;
if (ferror(zStream)) goto errhandler_io;
ret = fflush ( zStream );
if (ret == EOF) goto errhandler_io;
#if defined(SPEC_CPU)
if (zStream != SPEC_STDOUT) {
#else
if (zStream != stdout) {
#endif
ret = fclose ( zStream );
outputHandleJustInCase = SPEC_NULLCAST NULL;
if (ret == EOF) goto errhandler_io;
}
outputHandleJustInCase = NULL;
if (ferror(stream)) goto errhandler_io;
ret = fclose ( stream );
if (ret == EOF) goto errhandler_io;
if (verbosity >= 1) {
if (nbytes_in_lo32 == 0 && nbytes_in_hi32 == 0) {
fprintf ( stderr, " no data compressed.\n");
} else {
Char buf_nin[32], buf_nout[32];
UInt64 nbytes_in, nbytes_out;
double nbytes_in_d, nbytes_out_d;
uInt64_from_UInt32s ( &nbytes_in,
nbytes_in_lo32, nbytes_in_hi32 );
uInt64_from_UInt32s ( &nbytes_out,
nbytes_out_lo32, nbytes_out_hi32 );
nbytes_in_d = uInt64_to_double ( &nbytes_in );
nbytes_out_d = uInt64_to_double ( &nbytes_out );
uInt64_toAscii ( buf_nin, &nbytes_in );
uInt64_toAscii ( buf_nout, &nbytes_out );
fprintf ( stderr, "%6.3f:1, %6.3f bits/byte, "
"%5.2f%% saved, %s in, %s out.\n",
nbytes_in_d / nbytes_out_d,
(8.0 * nbytes_out_d) / nbytes_in_d,
100.0 * (1.0 - nbytes_out_d / nbytes_in_d),
buf_nin,
buf_nout
);
}
}
return;
errhandler:
BZ2_bzWriteClose64 ( &bzerr_dummy, bzf, 1,
&nbytes_in_lo32, &nbytes_in_hi32,
&nbytes_out_lo32, &nbytes_out_hi32 );
switch (bzerr) {
case BZ_CONFIG_ERROR:
configError(); break;
case BZ_MEM_ERROR:
outOfMemory (); break;
case BZ_IO_ERROR:
errhandler_io:
ioError(); break;
default:
panic ( "compress:unexpected error" );
}
panic ( "compress:end" );
/*notreached*/
}
/*---------------------------------------------*/
#if defined(SPEC_CPU)
Bool uncompressStream ( int zStream, int stream )
#else
static
Bool uncompressStream ( FILE *zStream, FILE *stream )
#endif
{
BZFILE* bzf = NULL;
Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;
UChar obuf[5000];
UChar unused[BZ_MAX_UNUSED];
Int32 nUnused;
void* unusedTmpV;
UChar* unusedTmp;
nUnused = 0;
streamNo = 0;
SET_BINARY_MODE(stream);
SET_BINARY_MODE(zStream);
if (ferror(stream)) goto errhandler_io;
if (ferror(zStream)) goto errhandler_io;
while (True) {
bzf = BZ2_bzReadOpen (
&bzerr, zStream, verbosity,
(int)smallMode, unused, nUnused
);
if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
streamNo++;
while (bzerr == BZ_OK) {
nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
if (bzerr == BZ_DATA_ERROR_MAGIC) goto trycat;
if ((bzerr == BZ_OK || bzerr == BZ_STREAM_END) && nread > 0)
fwrite ( obuf, sizeof(UChar), nread, stream );
if (ferror(stream)) goto errhandler_io;
}
if (bzerr != BZ_STREAM_END) goto errhandler;
BZ2_bzReadGetUnused ( &bzerr, bzf, &unusedTmpV, &nUnused );
if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
unusedTmp = (UChar*)unusedTmpV;
for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
BZ2_bzReadClose ( &bzerr, bzf );
if (bzerr != BZ_OK) panic ( "decompress:bzReadGetUnused" );
if (nUnused == 0 && myfeof(zStream)) break;
}
closeok:
if (ferror(zStream)) goto errhandler_io;
ret = fclose ( zStream );
if (ret == EOF) goto errhandler_io;
if (ferror(stream)) goto errhandler_io;
ret = fflush ( stream );
if (ret != 0) goto errhandler_io;
#if defined(SPEC_CPU)
if (stream != SPEC_STDOUT) {
#else
if (stream != stdout) {
#endif
ret = fclose ( stream );
outputHandleJustInCase = SPEC_NULLCAST NULL;
if (ret == EOF) goto errhandler_io;
}
outputHandleJustInCase = NULL;
if (verbosity >= 2) fprintf ( stderr, "\n " );
return True;
trycat:
if (forceOverwrite) {
rewind(zStream);
while (True) {
if (myfeof(zStream)) break;
nread = fread ( obuf, sizeof(UChar), 5000, zStream );
if (ferror(zStream)) goto errhandler_io;
if (nread > 0) fwrite ( obuf, sizeof(UChar), nread, stream );
if (ferror(stream)) goto errhandler_io;
}
goto closeok;
}
errhandler:
BZ2_bzReadClose ( &bzerr_dummy, bzf );
switch (bzerr) {
case BZ_CONFIG_ERROR:
configError(); break;
case BZ_IO_ERROR:
errhandler_io:
ioError(); break;
case BZ_DATA_ERROR:
crcError();
case BZ_MEM_ERROR:
outOfMemory();
case BZ_UNEXPECTED_EOF:
compressedStreamEOF();
case BZ_DATA_ERROR_MAGIC:
#if defined(SPEC_CPU)
if (zStream != SPEC_STDIN) fclose(zStream);
if (stream != SPEC_STDOUT) fclose(stream);
#else
if (zStream != stdin) fclose(zStream);
if (stream != stdout) fclose(stream);
#endif
if (streamNo == 1) {
return False;
} else {
if (noisy)
fprintf ( stderr,
"\n%s: %s: trailing garbage after EOF ignored\n",
progName, inName );
return True;
}
default:
panic ( "decompress:unexpected error" );
}
panic ( "decompress:end" );
return True; /*notreached*/
}
/*---------------------------------------------*/
static
#if defined(SPEC_CPU)
Bool testStream ( int zStream )
#else
Bool testStream ( FILE *zStream )
#endif
{
BZFILE* bzf = NULL;
Int32 bzerr, bzerr_dummy, ret, nread, streamNo, i;
UChar obuf[5000];
UChar unused[BZ_MAX_UNUSED];
Int32 nUnused;
void* unusedTmpV;
UChar* unusedTmp;
nUnused = 0;
streamNo = 0;
SET_BINARY_MODE(zStream);
if (ferror(zStream)) goto errhandler_io;
while (True) {
bzf = BZ2_bzReadOpen (
&bzerr, zStream, verbosity,
(int)smallMode, unused, nUnused
);
if (bzf == NULL || bzerr != BZ_OK) goto errhandler;
streamNo++;
while (bzerr == BZ_OK) {
nread = BZ2_bzRead ( &bzerr, bzf, obuf, 5000 );
if (bzerr == BZ_DATA_ERROR_MAGIC) goto errhandler;
}
if (bzerr != BZ_STREAM_END) goto errhandler;
BZ2_bzReadGetUnused ( &bzerr, bzf, &unusedTmpV, &nUnused );
if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
unusedTmp = (UChar*)unusedTmpV;
for (i = 0; i < nUnused; i++) unused[i] = unusedTmp[i];
BZ2_bzReadClose ( &bzerr, bzf );
if (bzerr != BZ_OK) panic ( "test:bzReadGetUnused" );
if (nUnused == 0 && myfeof(zStream)) break;
}
if (ferror(zStream)) goto errhandler_io;
ret = fclose ( zStream );
if (ret == EOF) goto errhandler_io;
if (verbosity >= 2) fprintf ( stderr, "\n " );
return True;
errhandler:
BZ2_bzReadClose ( &bzerr_dummy, bzf );
if (verbosity == 0)
fprintf ( stderr, "%s: %s: ", progName, inName );
switch (bzerr) {
case BZ_CONFIG_ERROR:
configError(); break;
case BZ_IO_ERROR:
errhandler_io:
ioError(); break;
case BZ_DATA_ERROR:
fprintf ( stderr,
"data integrity (CRC) error in data\n" );
return False;
case BZ_MEM_ERROR:
outOfMemory();
case BZ_UNEXPECTED_EOF:
fprintf ( stderr,
"file ends unexpectedly\n" );
return False;
case BZ_DATA_ERROR_MAGIC:
#if defined(SPEC_CPU)
if (zStream != SPEC_STDIN) fclose(zStream);
#else
if (zStream != stdin) fclose(zStream);
#endif
if (streamNo == 1) {
fprintf ( stderr,
"bad magic number (file not created by bzip2)\n" );
return False;
} else {
if (noisy)
fprintf ( stderr,
"trailing garbage after EOF ignored\n" );
return True;
}
default:
panic ( "test:unexpected error" );
}
panic ( "test:end" );
return True; /*notreached*/
}
/*---------------------------------------------------*/
/*--- Error [non-] handling grunge ---*/
/*---------------------------------------------------*/
/*---------------------------------------------*/
static
void setExit ( Int32 v )
{
#if defined(SPEC_CPU)
exitValue = 0; /* Only a crash should generate an RE */
#else
if (v > exitValue) exitValue = v;
#endif
}
/*---------------------------------------------*/
static
void cadvise ( void )
{
if (noisy)
fprintf (
stderr,
"\nIt is possible that the compressed file(s) have become corrupted.\n"
"You can use the -tvv option to test integrity of such files.\n\n"
"You can use the `bzip2recover' program to attempt to recover\n"
"data from undamaged sections of corrupted files.\n\n"
);
}
/*---------------------------------------------*/
static
void showFileNames ( void )
{
if (noisy)
fprintf (
stderr,
"\tInput file = %s, output file = %s\n",
inName, outName
);
}
/*---------------------------------------------*/
static
void cleanUpAndFail ( Int32 ec )
{
IntNative retVal;
#if !defined(SPEC_CPU)
struct MY_STAT statBuf;
if ( srcMode == SM_F2F
&& opMode != OM_TEST
&& deleteOutputOnInterrupt ) {
/* Check whether input file still exists. Delete output file
only if input exists to avoid loss of data. Joerg Prante, 5
January 2002. (JRS 06-Jan-2002: other changes in 1.0.2 mean
this is less likely to happen. But to be ultra-paranoid, we
do the check anyway.) */
retVal = MY_STAT ( inName, &statBuf );
if (retVal == 0) {
if (noisy)
fprintf ( stderr,
"%s: Deleting output file %s, if it exists.\n",
progName, outName );
if (outputHandleJustInCase != NULL)
fclose ( outputHandleJustInCase );
retVal = remove ( outName );
if (retVal != 0)
fprintf ( stderr,
"%s: WARNING: deletion of output file "
"(apparently) failed.\n",
progName );
} else {
fprintf ( stderr,
"%s: WARNING: deletion of output file suppressed\n",
progName );
fprintf ( stderr,
"%s: since input file no longer exists. Output file\n",
progName );
fprintf ( stderr,
"%s: `%s' may be incomplete.\n",
progName, outName );
fprintf ( stderr,
"%s: I suggest doing an integrity test (bzip2 -tv)"
" of it.\n",
progName );
}
}
if (noisy && numFileNames > 0 && numFilesProcessed < numFileNames) {
fprintf ( stderr,
"%s: WARNING: some files have not been processed:\n"
"%s: %d specified on command line, %d not processed yet.\n\n",
progName, progName,
numFileNames, numFileNames - numFilesProcessed );
}
#endif /* !SPEC_CPU */
setExit(ec);
exit(exitValue);
}
/*---------------------------------------------*/
static
void panic ( Char* s )
{
fprintf ( stderr,
"\n%s: PANIC -- internal consistency error:\n"
"\t%s\n"
#if defined(SPEC_CPU)
"\tThis is probably a BUG, but it may be in your COMPILER. Please do not bother\n"
"\tthe original author.\n",
#else
"\tThis is a BUG. Please report it to me at:\n"
"\tjseward@bzip.org\n",
#endif
progName, s );
showFileNames();
cleanUpAndFail( 3 );
}
/*---------------------------------------------*/
static
void crcError ( void )
{
fprintf ( stderr,
"\n%s: Data integrity error when decompressing.\n",
progName );
showFileNames();
cadvise();
cleanUpAndFail( 2 );
}
/*---------------------------------------------*/
static
void compressedStreamEOF ( void )
{
if (noisy) {
fprintf ( stderr,
"\n%s: Compressed file ends unexpectedly;\n\t"
"perhaps it is corrupted? *Possible* reason follows.\n",
progName );
perror ( progName );
showFileNames();
cadvise();
}
cleanUpAndFail( 2 );
}
/*---------------------------------------------*/
static
void ioError ( void )
{
fprintf ( stderr,
"\n%s: I/O or other error, bailing out. "
"Possible reason follows.\n",
progName );
perror ( progName );
showFileNames();
cleanUpAndFail( 1 );
}
/*---------------------------------------------*/
static
void mySignalCatcher ( IntNative n )
{
fprintf ( stderr,
"\n%s: Control-C or similar caught, quitting.\n",
progName );
cleanUpAndFail(1);
}
/*---------------------------------------------*/
static
void mySIGSEGVorSIGBUScatcher ( IntNative n )
{
if (opMode == OM_Z)
fprintf (
stderr,
"\n%s: Caught a SIGSEGV or SIGBUS whilst compressing.\n"
"\n"
" Possible causes are (most likely first):\n"
" (1) This computer has unreliable memory or cache hardware\n"
" (a surprisingly common problem; try a different machine.)\n"
" (2) A bug in the compiler used to create this executable\n"
" (unlikely, if you didn't compile bzip2 yourself.)\n"
" (3) A real bug in bzip2 -- I hope this should never be the case.\n"
" The user's manual, Section 4.3, has more info on (1) and (2).\n"
#if !defined(SPEC_CPU)
" \n"
" If you suspect this is a bug in bzip2, or are unsure about (1)\n"
" or (2), feel free to report it to me at: jseward@bzip.org.\n"
" Section 4.3 of the user's manual describes the info a useful\n"
" bug report should have. If the manual is available on your\n"
" system, please try and read it before mailing me. If you don't\n"
" have the manual or can't be bothered to read it, mail me anyway.\n"
#endif /* !SPEC_CPU */
"\n",
progName );
else
fprintf (
stderr,
"\n%s: Caught a SIGSEGV or SIGBUS whilst decompressing.\n"
"\n"
" Possible causes are (most likely first):\n"
" (1) The compressed data is corrupted, and bzip2's usual checks\n"
" failed to detect this. Try bzip2 -tvv my_file.bz2.\n"
" (2) This computer has unreliable memory or cache hardware\n"
" (a surprisingly common problem; try a different machine.)\n"
" (3) A bug in the compiler used to create this executable\n"
" (unlikely, if you didn't compile bzip2 yourself.)\n"
" (4) A real bug in bzip2 -- I hope this should never be the case.\n"
" The user's manual, Section 4.3, has more info on (2) and (3).\n"
#if !defined(SPEC_CPU)
" \n"
" If you suspect this is a bug in bzip2, or are unsure about (2)\n"
" or (3), feel free to report it to me at: jseward@bzip.org.\n"
" Section 4.3 of the user's manual describes the info a useful\n"
" bug report should have. If the manual is available on your\n"
" system, please try and read it before mailing me. If you don't\n"
" have the manual or can't be bothered to read it, mail me anyway.\n"
#endif /* !SPEC_CPU */
"\n",
progName );
showFileNames();
if (opMode == OM_Z)
cleanUpAndFail( 3 ); else
{ cadvise(); cleanUpAndFail( 2 ); }
}
/*---------------------------------------------*/
static
void outOfMemory ( void )
{
fprintf ( stderr,
"\n%s: couldn't allocate enough memory\n",
progName );
showFileNames();
cleanUpAndFail(1);
}
/*---------------------------------------------*/
static
void configError ( void )
{
fprintf ( stderr,
"bzip2: I'm not configured correctly for this platform!\n"
"\tI require Int32, Int16 and Char to have sizes\n"
"\tof 4, 2 and 1 bytes to run properly, and they don't.\n"
"\tProbably you can fix this by defining them correctly,\n"
"\tand recompiling. Bye!\n" );
setExit(3);
exit(exitValue);
}
/*---------------------------------------------------*/
/*--- The main driver machinery ---*/
/*---------------------------------------------------*/
#if !defined(SPEC_CPU)
/* All rather crufty. The main problem is that input files
are stat()d multiple times before use. This should be
cleaned up.
*/
/*---------------------------------------------*/
static
void pad ( Char *s )
{
Int32 i;
if ( (Int32)strlen(s) >= longestFileName ) return;
for (i = 1; i <= longestFileName - (Int32)strlen(s); i++)
fprintf ( stderr, " " );
}
/*---------------------------------------------*/
static
void copyFileName ( Char* to, Char* from )
{
if ( strlen(from) > FILE_NAME_LEN-10 ) {
fprintf (
stderr,
"bzip2: file name\n`%s'\n"
"is suspiciously (more than %d chars) long.\n"
"Try using a reasonable file name instead. Sorry! :-)\n",
from, FILE_NAME_LEN-10
);
setExit(1);
exit(exitValue);
}
strncpy(to,from,FILE_NAME_LEN-10);
to[FILE_NAME_LEN-10]='\0';
}
/*---------------------------------------------*/
static
Bool fileExists ( Char* name )
{
FILE *tmp = fopen ( name, "rb" );
Bool exists = (tmp != NULL);
if (tmp != NULL) fclose ( tmp );
return exists;
}
/*---------------------------------------------*/
/* Open an output file safely with O_EXCL and good permissions.
This avoids a race condition in versions < 1.0.2, in which
the file was first opened and then had its interim permissions
set safely. We instead use open() to create the file with
the interim permissions required. (--- --- rw-).
For non-Unix platforms, if we are not worrying about
security issues, simple this simply behaves like fopen.
*/
FILE* fopen_output_safely ( Char* name, const char* mode )
{
# if BZ_UNIX
FILE* fp;
IntNative fh;
fh = open(name, O_WRONLY|O_CREAT|O_EXCL, S_IWUSR|S_IRUSR);
if (fh == -1) return NULL;
fp = fdopen(fh, mode);
if (fp == NULL) close(fh);
return fp;
# else
return fopen(name, mode);
# endif
}
/*---------------------------------------------*/
/*--
if in doubt, return True
--*/
static
Bool notAStandardFile ( Char* name )
{
IntNative i;
struct MY_STAT statBuf;
i = MY_LSTAT ( name, &statBuf );
if (i != 0) return True;
if (MY_S_ISREG(statBuf.st_mode)) return False;
return True;
}
/*---------------------------------------------*/
/*--
rac 11/21/98 see if file has hard links to it
--*/
static
Int32 countHardLinks ( Char* name )
{
IntNative i;
struct MY_STAT statBuf;
i = MY_LSTAT ( name, &statBuf );
if (i != 0) return 0;
return (statBuf.st_nlink - 1);
}
/*---------------------------------------------*/
/* Copy modification date, access date, permissions and owner from the
source to destination file. We have to copy this meta-info off
into fileMetaInfo before starting to compress / decompress it,
because doing it afterwards means we get the wrong access time.
To complicate matters, in compress() and decompress() below, the
sequence of tests preceding the call to saveInputFileMetaInfo()
involves calling fileExists(), which in turn establishes its result
by attempting to fopen() the file, and if successful, immediately
fclose()ing it again. So we have to assume that the fopen() call
does not cause the access time field to be updated.
Reading of the man page for stat() (man 2 stat) on RedHat 7.2 seems
to imply that merely doing open() will not affect the access time.
Therefore we merely need to hope that the C library only does
open() as a result of fopen(), and not any kind of read()-ahead
cleverness.
It sounds pretty fragile to me. Whether this carries across
robustly to arbitrary Unix-like platforms (or even works robustly
on this one, RedHat 7.2) is unknown to me. Nevertheless ...
*/
#if BZ_UNIX
static
struct MY_STAT fileMetaInfo;
#endif
static
void saveInputFileMetaInfo ( Char *srcName )
{
# if BZ_UNIX
IntNative retVal;
/* Note use of stat here, not lstat. */
retVal = MY_STAT( srcName, &fileMetaInfo );
ERROR_IF_NOT_ZERO ( retVal );
# endif
}
static
void applySavedMetaInfoToOutputFile ( Char *dstName )
{
# if BZ_UNIX
IntNative retVal;
struct utimbuf uTimBuf;
uTimBuf.actime = fileMetaInfo.st_atime;
uTimBuf.modtime = fileMetaInfo.st_mtime;
retVal = chmod ( dstName, fileMetaInfo.st_mode );
ERROR_IF_NOT_ZERO ( retVal );
retVal = utime ( dstName, &uTimBuf );
ERROR_IF_NOT_ZERO ( retVal );
retVal = chown ( dstName, fileMetaInfo.st_uid, fileMetaInfo.st_gid );
/* chown() will in many cases return with EPERM, which can
be safely ignored.
*/
# endif
}
/*---------------------------------------------*/
static
Bool containsDubiousChars ( Char* name )
{
# if BZ_UNIX
/* On unix, files can contain any characters and the file expansion
* is performed by the shell.
*/
return False;
# else /* ! BZ_UNIX */
/* On non-unix (Win* platforms), wildcard characters are not allowed in
* filenames.
*/
for (; *name != '\0'; name++)
if (*name == '?' || *name == '*') return True;
return False;
# endif /* BZ_UNIX */
}
/*---------------------------------------------*/
#define BZ_N_SUFFIX_PAIRS 4
Char* zSuffix[BZ_N_SUFFIX_PAIRS]
= { ".bz2", ".bz", ".tbz2", ".tbz" };
Char* unzSuffix[BZ_N_SUFFIX_PAIRS]
= { "", "", ".tar", ".tar" };
static
Bool hasSuffix ( Char* s, Char* suffix )
{
Int32 ns = strlen(s);
Int32 nx = strlen(suffix);
if (ns < nx) return False;
if (strcmp(s + ns - nx, suffix) == 0) return True;
return False;
}
static
Bool mapSuffix ( Char* name,
Char* oldSuffix, Char* newSuffix )
{
if (!hasSuffix(name,oldSuffix)) return False;
name[strlen(name)-strlen(oldSuffix)] = 0;
strcat ( name, newSuffix );
return True;
}
/*---------------------------------------------*/
static
void compress ( Char *name )
{
FILE *inStr;
FILE *outStr;
Int32 n, i;
struct MY_STAT statBuf;
deleteOutputOnInterrupt = False;
if (name == NULL && srcMode != SM_I2O)
panic ( "compress: bad modes\n" );
switch (srcMode) {
case SM_I2O:
copyFileName ( inName, "(stdin)" );
copyFileName ( outName, "(stdout)" );
break;
case SM_F2F:
copyFileName ( inName, name );
copyFileName ( outName, name );
strcat ( outName, ".bz2" );
break;
case SM_F2O:
copyFileName ( inName, name );
copyFileName ( outName, "(stdout)" );
break;
}
if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
if (noisy)
fprintf ( stderr, "%s: There are no files matching `%s'.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
}
for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++) {
if (hasSuffix(inName, zSuffix[i])) {
if (noisy)
fprintf ( stderr,
"%s: Input file %s already has %s suffix.\n",
progName, inName, zSuffix[i] );
setExit(1);
return;
}
}
if ( srcMode == SM_F2F || srcMode == SM_F2O ) {
MY_STAT(inName, &statBuf);
if ( MY_S_ISDIR(statBuf.st_mode) ) {
fprintf( stderr,
"%s: Input file %s is a directory.\n",
progName,inName);
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
if (noisy)
fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode == SM_F2F && fileExists ( outName ) ) {
if (forceOverwrite) {
remove(outName);
} else {
fprintf ( stderr, "%s: Output file %s already exists.\n",
progName, outName );
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite &&
(n=countHardLinks ( inName )) > 0) {
fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
progName, inName, n, n > 1 ? "s" : "" );
setExit(1);
return;
}
if ( srcMode == SM_F2F ) {
/* Save the file's meta-info before we open it. Doing it later
means we mess up the access times. */
saveInputFileMetaInfo ( inName );
}
switch ( srcMode ) {
case SM_I2O:
inStr = stdin;
outStr = stdout;
if ( isatty ( fileno ( stdout ) ) ) {
fprintf ( stderr,
"%s: I won't write compressed data to a terminal.\n",
progName );
fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
progName, progName );
setExit(1);
return;
};
break;
case SM_F2O:
inStr = fopen ( inName, "rb" );
outStr = stdout;
if ( isatty ( fileno ( stdout ) ) ) {
fprintf ( stderr,
"%s: I won't write compressed data to a terminal.\n",
progName );
fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
progName, progName );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
};
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
};
break;
case SM_F2F:
inStr = fopen ( inName, "rb" );
outStr = fopen_output_safely ( outName, "wb" );
if ( outStr == NULL) {
fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
progName, outName, strerror(errno) );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
}
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
if ( outStr != NULL ) fclose ( outStr );
setExit(1);
return;
};
break;
default:
panic ( "compress: bad srcMode" );
break;
}
if (verbosity >= 1) {
fprintf ( stderr, " %s: ", inName );
pad ( inName );
fflush ( stderr );
}
/*--- Now the input and output handles are sane. Do the Biz. ---*/
outputHandleJustInCase = outStr;
deleteOutputOnInterrupt = True;
compressStream ( inStr, outStr );
outputHandleJustInCase = NULL;
/*--- If there was an I/O error, we won't get here. ---*/
if ( srcMode == SM_F2F ) {
applySavedMetaInfoToOutputFile ( outName );
deleteOutputOnInterrupt = False;
if ( !keepInputFiles ) {
IntNative retVal = remove ( inName );
ERROR_IF_NOT_ZERO ( retVal );
}
}
deleteOutputOnInterrupt = False;
}
/*---------------------------------------------*/
static
void uncompress ( Char *name )
{
FILE *inStr;
FILE *outStr;
Int32 n, i;
Bool magicNumberOK;
Bool cantGuess;
struct MY_STAT statBuf;
deleteOutputOnInterrupt = False;
if (name == NULL && srcMode != SM_I2O)
panic ( "uncompress: bad modes\n" );
cantGuess = False;
switch (srcMode) {
case SM_I2O:
copyFileName ( inName, "(stdin)" );
copyFileName ( outName, "(stdout)" );
break;
case SM_F2F:
copyFileName ( inName, name );
copyFileName ( outName, name );
for (i = 0; i < BZ_N_SUFFIX_PAIRS; i++)
if (mapSuffix(outName,zSuffix[i],unzSuffix[i]))
goto zzz;
cantGuess = True;
strcat ( outName, ".out" );
break;
case SM_F2O:
copyFileName ( inName, name );
copyFileName ( outName, "(stdout)" );
break;
}
zzz:
if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
if (noisy)
fprintf ( stderr, "%s: There are no files matching `%s'.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode != SM_I2O && !fileExists ( inName ) ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
setExit(1);
return;
}
if ( srcMode == SM_F2F || srcMode == SM_F2O ) {
MY_STAT(inName, &statBuf);
if ( MY_S_ISDIR(statBuf.st_mode) ) {
fprintf( stderr,
"%s: Input file %s is a directory.\n",
progName,inName);
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite && notAStandardFile ( inName )) {
if (noisy)
fprintf ( stderr, "%s: Input file %s is not a normal file.\n",
progName, inName );
setExit(1);
return;
}
if ( /* srcMode == SM_F2F implied && */ cantGuess ) {
if (noisy)
fprintf ( stderr,
"%s: Can't guess original name for %s -- using %s\n",
progName, inName, outName );
/* just a warning, no return */
}
if ( srcMode == SM_F2F && fileExists ( outName ) ) {
if (forceOverwrite) {
remove(outName);
} else {
fprintf ( stderr, "%s: Output file %s already exists.\n",
progName, outName );
setExit(1);
return;
}
}
if ( srcMode == SM_F2F && !forceOverwrite &&
(n=countHardLinks ( inName ) ) > 0) {
fprintf ( stderr, "%s: Input file %s has %d other link%s.\n",
progName, inName, n, n > 1 ? "s" : "" );
setExit(1);
return;
}
if ( srcMode == SM_F2F ) {
/* Save the file's meta-info before we open it. Doing it later
means we mess up the access times. */
saveInputFileMetaInfo ( inName );
}
switch ( srcMode ) {
case SM_I2O:
inStr = stdin;
outStr = stdout;
if ( isatty ( fileno ( stdin ) ) ) {
fprintf ( stderr,
"%s: I won't read compressed data from a terminal.\n",
progName );
fprintf ( stderr, "%s: For help, type: `%s --help'.\n",
progName, progName );
setExit(1);
return;
};
break;
case SM_F2O:
inStr = fopen ( inName, "rb" );
outStr = stdout;
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s:%s.\n",
progName, inName, strerror(errno) );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
};
break;
case SM_F2F:
inStr = fopen ( inName, "rb" );
outStr = fopen_output_safely ( outName, "wb" );
if ( outStr == NULL) {
fprintf ( stderr, "%s: Can't create output file %s: %s.\n",
progName, outName, strerror(errno) );
if ( inStr != NULL ) fclose ( inStr );
setExit(1);
return;
}
if ( inStr == NULL ) {
fprintf ( stderr, "%s: Can't open input file %s: %s.\n",
progName, inName, strerror(errno) );
if ( outStr != NULL ) fclose ( outStr );
setExit(1);
return;
};
break;
default:
panic ( "uncompress: bad srcMode" );
break;
}
if (verbosity >= 1) {
fprintf ( stderr, " %s: ", inName );
pad ( inName );
fflush ( stderr );
}
/*--- Now the input and output handles are sane. Do the Biz. ---*/
outputHandleJustInCase = outStr;
deleteOutputOnInterrupt = True;
magicNumberOK = uncompressStream ( inStr, outStr );
outputHandleJustInCase = NULL;
/*--- If there was an I/O error, we won't get here. ---*/
if ( magicNumberOK ) {
if ( srcMode == SM_F2F ) {
applySavedMetaInfoToOutputFile ( outName );
deleteOutputOnInterrupt = False;
if ( !keepInputFiles ) {
IntNative retVal = remove ( inName );
ERROR_IF_NOT_ZERO ( retVal );
}
}
} else {
unzFailsExist = True;
deleteOutputOnInterrupt = False;
if ( srcMode == SM_F2F ) {
IntNative retVal = remove ( outName );
ERROR_IF_NOT_ZERO ( retVal );
}
}
deleteOutputOnInterrupt = False;
if ( magicNumberOK ) {
if (verbosity >= 1)
fprintf ( stderr, "done\n" );
} else {
setExit(2);
if (verbosity >= 1)
fprintf ( stderr, "not a bzip2 file.\n" ); else
fprintf ( stderr,
"%s: %s is not a bzip2 file.\n",
progName, inName );
}
}
/*---------------------------------------------*/
static
void testf ( Char *name )
{
FILE *inStr;
Bool allOK;
struct MY_STAT statBuf;
deleteOutputOnInterrupt = False;
if (name == NULL && srcMode != SM_I2O)
panic ( "testf: bad modes\n" );
copyFileName ( outName, "(none)" );
switch (srcMode) {
case SM_I2O: copyFileName ( inName, "(stdin)" ); break;
case SM_F2F: copyFileName ( inName, name ); break;
case SM_F2O: copyFileName ( inName, name ); break;
}
if ( srcMode != SM_I2O && containsDubiousChars ( inName ) ) {
if (noisy)
fprintf ( stderr, "%s: There are no files matching `%s'.\n",
progName, inName );
setExit(1);
return;
}
if ( srcMode != SM_I2O && !fil
gitextract_zpfbl9ua/
├── .gitignore
├── .hgignore
├── LICENSE
├── Makefile
├── README.md
├── common.mk
├── pass/
│ ├── IntrinsicLibcalls.h
│ ├── LowerIntrinsics.cpp
│ ├── Makefile
│ └── Stabilizer.cpp
├── platforms/
│ ├── Darwin.i386.mk
│ ├── Darwin.x86_64.mk
│ ├── Linux.i386.mk
│ ├── Linux.i686.mk
│ ├── Linux.ppc.mk
│ └── Linux.x86_64.mk
├── process.py
├── run.py
├── runtime/
│ ├── Arch.h
│ ├── Context.h
│ ├── Debug.cpp
│ ├── Debug.h
│ ├── Function.cpp
│ ├── Function.h
│ ├── FunctionLocation.h
│ ├── Heap.cpp
│ ├── Heap.h
│ ├── Intrinsics.cpp
│ ├── Jump.h
│ ├── MMapSource.h
│ ├── Makefile
│ ├── MemRange.h
│ ├── Trap.h
│ ├── Util.h
│ └── libstabilizer.cpp
├── szc
├── szchi.cfg
├── szclo.cfg
└── tests/
├── Context/
│ ├── Makefile
│ ├── hello.cpp
│ └── stub.asm
├── HelloWorld/
│ ├── Makefile
│ └── hello.cpp
├── LICENSE
├── Makefile
├── bzip2/
│ ├── Makefile
│ ├── blocksort.c
│ ├── bzip2.c
│ ├── bzlib.c
│ ├── bzlib.h
│ ├── bzlib_private.h
│ ├── compress.c
│ ├── crctable.c
│ ├── decompress.c
│ ├── huffman.c
│ ├── input.combined
│ ├── randtable.c
│ ├── spec.c
│ └── spec.h
├── libquantum/
│ ├── Makefile
│ ├── classic.c
│ ├── classic.h
│ ├── complex.c
│ ├── config.h
│ ├── decoherence.c
│ ├── decoherence.h
│ ├── defs.h
│ ├── expn.c
│ ├── gates.c
│ ├── gates.h
│ ├── lq_complex.h
│ ├── matrix.c
│ ├── matrix.h
│ ├── measure.c
│ ├── measure.h
│ ├── oaddn.c
│ ├── oaddn.h
│ ├── objcode.c
│ ├── objcode.h
│ ├── omuln.c
│ ├── omuln.h
│ ├── qec.c
│ ├── qec.h
│ ├── qft.c
│ ├── quantum.h
│ ├── qureg.c
│ ├── qureg.h
│ ├── shor.c
│ ├── specrand.c
│ ├── specrand.h
│ └── version.c
└── perlbench/
├── Base64.c
├── Cwd.c
├── Dumper.c
├── DynaLoader.c
├── EXTERN.h
├── HiRes.c
├── Hostname.c
├── INTERN.h
├── IO.c
├── MD5.c
├── Makefile
├── Opcode.c
├── Parser.c
├── Peek.c
├── Storable.c
├── WORDS
├── XSUB.h
├── attrs.c
├── av.c
├── av.h
├── config.h
├── const-c.inc
├── cop.h
├── cpu2006_mhonarc.rc
├── cv.h
├── deb.c
├── dictionary
├── doio.c
├── doop.c
├── dump.c
├── embed.h
├── embedvar.h
├── fakesdio.h
├── fakethr.h
├── form.h
├── globals.c
├── gv.c
├── gv.h
├── handy.h
├── hctype.h
├── hparser.c
├── hparser.h
├── hv.c
├── hv.h
├── input/
│ ├── checkspam.pl
│ ├── diffmail.in
│ ├── diffmail.pl
│ ├── perfect.in
│ ├── perfect.pl
│ ├── scrabbl.in
│ ├── scrabbl.pl
│ ├── splitmail.in
│ ├── splitmail.pl
│ └── suns.pl
├── intrpvar.h
├── iperlsys.h
├── keywords.h
├── lib/
│ ├── AutoLoader.pm
│ ├── Carp/
│ │ └── Heavy.pm
│ ├── Carp.pm
│ ├── Config.pm
│ ├── Cwd.pm
│ ├── DB_File.pm
│ ├── Date/
│ │ ├── Format.pm
│ │ ├── Language/
│ │ │ ├── Afar.pm
│ │ │ ├── Amharic.pm
│ │ │ ├── Austrian.pm
│ │ │ ├── Brazilian.pm
│ │ │ ├── Chinese_GB.pm
│ │ │ ├── Czech.pm
│ │ │ ├── Danish.pm
│ │ │ ├── Dutch.pm
│ │ │ ├── English.pm
│ │ │ ├── Finnish.pm
│ │ │ ├── French.pm
│ │ │ ├── Gedeo.pm
│ │ │ ├── German.pm
│ │ │ ├── Greek.pm
│ │ │ ├── Italian.pm
│ │ │ ├── Norwegian.pm
│ │ │ ├── Oromo.pm
│ │ │ ├── Sidama.pm
│ │ │ ├── Somali.pm
│ │ │ ├── Swedish.pm
│ │ │ ├── Tigrinya.pm
│ │ │ ├── TigrinyaEritrean.pm
│ │ │ └── TigrinyaEthiopian.pm
│ │ ├── Language.pm
│ │ └── Parse.pm
│ ├── Digest/
│ │ └── MD5.pm
│ ├── DynaLoader.pm
│ ├── Exporter/
│ │ └── Heavy.pm
│ ├── Exporter.pm
│ ├── Fcntl.pm
│ ├── File/
│ │ ├── Basename.pm
│ │ ├── CheckTree.pm
│ │ ├── Compare.pm
│ │ ├── Copy.pm
│ │ ├── DosGlob.pm
│ │ ├── Find.pm
│ │ ├── Path.pm
│ │ ├── Spec/
│ │ │ ├── Epoc.pm
│ │ │ ├── Functions.pm
│ │ │ ├── Mac.pm
│ │ │ ├── OS2.pm
│ │ │ ├── Unix.pm
│ │ │ ├── VMS.pm
│ │ │ └── Win32.pm
│ │ ├── Spec.pm
│ │ ├── Temp.pm
│ │ └── stat.pm
│ ├── FileCache.pm
│ ├── FileHandle.pm
│ ├── Getopt/
│ │ ├── Long.pm
│ │ └── Std.pm
│ ├── HTML/
│ │ ├── Entities.pm
│ │ ├── Filter.pm
│ │ ├── HeadParser.pm
│ │ ├── LinkExtor.pm
│ │ ├── Parser.pm
│ │ ├── PullParser.pm
│ │ └── TokeParser.pm
│ ├── IO/
│ │ ├── File.pm
│ │ ├── Scalar.pm
│ │ └── Socket/
│ │ ├── INET.pm
│ │ └── UNIX.pm
│ ├── MHonArc/
│ │ ├── Char/
│ │ │ ├── JP.pm
│ │ │ └── KR.pm
│ │ ├── Char.pm
│ │ ├── CharEnt/
│ │ │ ├── AppleArabic.pm
│ │ │ ├── AppleCenteuro.pm
│ │ │ ├── AppleCroatian.pm
│ │ │ ├── AppleCyrillic.pm
│ │ │ ├── AppleGreek.pm
│ │ │ ├── AppleHebrew.pm
│ │ │ ├── AppleIceland.pm
│ │ │ ├── AppleRoman.pm
│ │ │ ├── AppleRomanian.pm
│ │ │ ├── AppleThai.pm
│ │ │ ├── AppleTurkish.pm
│ │ │ ├── BIG5_ETEN.pm
│ │ │ ├── BIG5_HKSCS.pm
│ │ │ ├── CP1250.pm
│ │ │ ├── CP1251.pm
│ │ │ ├── CP1252.pm
│ │ │ ├── CP1253.pm
│ │ │ ├── CP1254.pm
│ │ │ ├── CP1255.pm
│ │ │ ├── CP1256.pm
│ │ │ ├── CP1257.pm
│ │ │ ├── CP1258.pm
│ │ │ ├── CP866.pm
│ │ │ ├── CP932.pm
│ │ │ ├── CP936.pm
│ │ │ ├── CP949.pm
│ │ │ ├── CP950.pm
│ │ │ ├── EUC_JP.pm
│ │ │ ├── GB2312.pm
│ │ │ ├── GOST19768_87.pm
│ │ │ ├── HP_ROMAN8.pm
│ │ │ ├── ISO8859_1.pm
│ │ │ ├── ISO8859_10.pm
│ │ │ ├── ISO8859_11.pm
│ │ │ ├── ISO8859_13.pm
│ │ │ ├── ISO8859_14.pm
│ │ │ ├── ISO8859_15.pm
│ │ │ ├── ISO8859_16.pm
│ │ │ ├── ISO8859_2.pm
│ │ │ ├── ISO8859_3.pm
│ │ │ ├── ISO8859_4.pm
│ │ │ ├── ISO8859_5.pm
│ │ │ ├── ISO8859_6.pm
│ │ │ ├── ISO8859_7.pm
│ │ │ ├── ISO8859_8.pm
│ │ │ ├── ISO8859_9.pm
│ │ │ ├── KOI8_A.pm
│ │ │ ├── KOI8_B.pm
│ │ │ ├── KOI8_E.pm
│ │ │ ├── KOI8_F.pm
│ │ │ ├── KOI8_R.pm
│ │ │ ├── KOI8_U.pm
│ │ │ ├── KOI_0.pm
│ │ │ ├── KOI_7.pm
│ │ │ └── VISCII.pm
│ │ ├── CharEnt.pm
│ │ ├── CharMaps.pm
│ │ ├── Encode.pm
│ │ ├── RFC822.pm
│ │ ├── UTF8/
│ │ │ ├── AppleArabic.pm
│ │ │ ├── AppleCenteuro.pm
│ │ │ ├── AppleCroatian.pm
│ │ │ ├── AppleCyrillic.pm
│ │ │ ├── AppleGreek.pm
│ │ │ ├── AppleHebrew.pm
│ │ │ ├── AppleIceland.pm
│ │ │ ├── AppleRoman.pm
│ │ │ ├── AppleRomanian.pm
│ │ │ ├── AppleThai.pm
│ │ │ ├── AppleTurkish.pm
│ │ │ ├── BIG5_ETEN.pm
│ │ │ ├── BIG5_HKSCS.pm
│ │ │ ├── CP1250.pm
│ │ │ ├── CP1251.pm
│ │ │ ├── CP1252.pm
│ │ │ ├── CP1253.pm
│ │ │ ├── CP1254.pm
│ │ │ ├── CP1255.pm
│ │ │ ├── CP1256.pm
│ │ │ ├── CP1257.pm
│ │ │ ├── CP1258.pm
│ │ │ ├── CP866.pm
│ │ │ ├── CP932.pm
│ │ │ ├── CP936.pm
│ │ │ ├── CP949.pm
│ │ │ ├── CP950.pm
│ │ │ ├── EUC_JP.pm
│ │ │ ├── Encode.pm
│ │ │ ├── GB2312.pm
│ │ │ ├── GOST19768_87.pm
│ │ │ ├── HP_ROMAN8.pm
│ │ │ ├── ISO8859_1.pm
│ │ │ ├── ISO8859_10.pm
│ │ │ ├── ISO8859_11.pm
│ │ │ ├── ISO8859_13.pm
│ │ │ ├── ISO8859_14.pm
│ │ │ ├── ISO8859_15.pm
│ │ │ ├── ISO8859_16.pm
│ │ │ ├── ISO8859_2.pm
│ │ │ ├── ISO8859_3.pm
│ │ │ ├── ISO8859_4.pm
│ │ │ ├── ISO8859_5.pm
│ │ │ ├── ISO8859_6.pm
│ │ │ ├── ISO8859_7.pm
│ │ │ ├── ISO8859_8.pm
│ │ │ ├── ISO8859_9.pm
│ │ │ ├── KOI8_A.pm
│ │ │ ├── KOI8_B.pm
│ │ │ ├── KOI8_E.pm
│ │ │ ├── KOI8_F.pm
│ │ │ ├── KOI8_R.pm
│ │ │ ├── KOI8_U.pm
│ │ │ ├── KOI_0.pm
│ │ │ ├── KOI_7.pm
│ │ │ ├── MapUTF8.pm
│ │ │ ├── MhaEncode.pm
│ │ │ └── VISCII.pm
│ │ └── UTF8.pm
│ ├── MIME/
│ │ ├── Base64.pm
│ │ └── QuotedPrint.pm
│ ├── Mail/
│ │ ├── Header.pm
│ │ ├── SpamAssassin/
│ │ │ ├── ArchiveIterator.pm
│ │ │ ├── AuditMessage.pm
│ │ │ ├── AutoWhitelist.pm
│ │ │ ├── Bayes.pm
│ │ │ ├── BayesStore.pm
│ │ │ ├── CmdLearn.pm
│ │ │ ├── Conf.pm
│ │ │ ├── DBBasedAddrList.pm
│ │ │ ├── Dns.pm
│ │ │ ├── EncappedMIME.pm
│ │ │ ├── EncappedMessage.pm
│ │ │ ├── EvalTests.pm
│ │ │ ├── HTML.pm
│ │ │ ├── Locales.pm
│ │ │ ├── Locker.pm
│ │ │ ├── MailingList.pm
│ │ │ ├── Message.pm
│ │ │ ├── NetSet.pm
│ │ │ ├── NoLocker.pm
│ │ │ ├── NoMailAudit.pm
│ │ │ ├── PerMsgLearner.pm
│ │ │ ├── PerMsgStatus.pm
│ │ │ ├── PersistentAddrList.pm
│ │ │ ├── PhraseFreqs.pm
│ │ │ ├── Received.pm
│ │ │ ├── Replier.pm
│ │ │ ├── Reporter.pm
│ │ │ ├── SHA1.pm
│ │ │ ├── TextCat.pm
│ │ │ └── Util.pm
│ │ ├── SpamAssassin.pm
│ │ └── Util.pm
│ ├── Math/
│ │ ├── BigFloat/
│ │ │ └── Trace.pm
│ │ ├── BigFloat.pm
│ │ ├── BigInt/
│ │ │ ├── Calc.pm
│ │ │ ├── CalcEmu.pm
│ │ │ ├── Scalar.pm
│ │ │ └── Trace.pm
│ │ ├── BigInt.pm
│ │ ├── BigRat.pm
│ │ ├── Complex.pm
│ │ └── Trig.pm
│ ├── Search/
│ │ ├── Dict.pm
│ │ └── Dict.t
│ ├── Storable.pm
│ ├── Symbol.pm
│ ├── Text/
│ │ ├── Tabs.pm
│ │ └── Wrap.pm
│ ├── Time/
│ │ ├── Local.pm
│ │ ├── Zone.pm
│ │ ├── gmtime.pm
│ │ ├── localtime.pm
│ │ └── tm.pm
│ ├── Unicode/
│ │ ├── Collate/
│ │ │ ├── Changes
│ │ │ ├── README
│ │ │ └── keys.txt
│ │ ├── Collate.pm
│ │ ├── Normalize.pm
│ │ ├── README
│ │ ├── UCD.pm
│ │ └── UCD.t
│ ├── abbrev.pl
│ ├── assert.pl
│ ├── attributes.pm
│ ├── auto/
│ │ └── Storable/
│ │ └── autosplit.ix
│ ├── autouse.pm
│ ├── base.pm
│ ├── base64.pl
│ ├── bigfloat.pl
│ ├── bigint.pl
│ ├── bigrat.pl
│ ├── blib.pm
│ ├── bytes.pm
│ ├── bytes_heavy.pl
│ ├── cacheout.pl
│ ├── charnames.pm
│ ├── chat2.pl
│ ├── compare.pm
│ ├── complete.pl
│ ├── constant.pm
│ ├── ctime.pl
│ ├── diagnostics.pm
│ ├── dotsh.pl
│ ├── dumpvar.pl
│ ├── ewhutil.pl
│ ├── exceptions.pl
│ ├── fastcwd.pl
│ ├── fields.pm
│ ├── filetest.pm
│ ├── find.pl
│ ├── finddepth.pl
│ ├── flush.pl
│ ├── ftp.pl
│ ├── getcwd.pl
│ ├── getopt.pl
│ ├── getopts.pl
│ ├── ham.pl
│ ├── hostname.pl
│ ├── importenv.pl
│ ├── integer.pm
│ ├── iso2022jp.pl
│ ├── iso8859.pl
│ ├── less.pm
│ ├── lib.pm
│ ├── locale.pm
│ ├── look.pl
│ ├── mailcomp.pm
│ ├── mhamain.pl
│ ├── mhdb.pl
│ ├── mhdysub.pl
│ ├── mhexternal.pl
│ ├── mhfile.pl
│ ├── mhidxrc.pl
│ ├── mhindex.pl
│ ├── mhinit.pl
│ ├── mhlock.pl
│ ├── mhmimetypes.pl
│ ├── mhmsgextbody.pl
│ ├── mhmsgfile.pl
│ ├── mhnote.pl
│ ├── mhnull.pl
│ ├── mhopt.pl
│ ├── mhrcfile.pl
│ ├── mhrcvars.pl
│ ├── mhrmm.pl
│ ├── mhscan.pl
│ ├── mhsingle.pl
│ ├── mhthread.pl
│ ├── mhtime.pl
│ ├── mhtxtenrich.pl
│ ├── mhtxthtml.pl
│ ├── mhtxtplain.pl
│ ├── mhtxttsv.pl
│ ├── mhusage.pl
│ ├── mhutil.pl
│ ├── mungewords
│ ├── newgetopt.pl
│ ├── open.pm
│ ├── open2.pl
│ ├── open3.pl
│ ├── osinit.pl
│ ├── overload.pm
│ ├── perl5db.pl
│ ├── pwd.pl
│ ├── qprint.pl
│ ├── re.pm
│ ├── readmail.pl
│ ├── shellwords.pl
│ ├── sigtrap.pm
│ ├── spam.pl
│ ├── specdiff.pm
│ ├── stat.pl
│ ├── strict.pm
│ ├── subs.pm
│ ├── syslog.pl
│ ├── tainted.pl
│ ├── termcap.pl
│ ├── timelocal.pl
│ ├── unicore/
│ │ ├── ArabLink.pl
│ │ ├── ArabLnkGrp.pl
│ │ ├── ArabicShaping.txt
│ │ ├── BidiMirroring.txt
│ │ ├── Bidirectional.pl
│ │ ├── Blocks.pl
│ │ ├── Blocks.txt
│ │ ├── Canonical.pl
│ │ ├── CaseFolding.txt
│ │ ├── Category.pl
│ │ ├── CombiningClass.pl
│ │ ├── CompositionExclusions.txt
│ │ ├── Decomposition.pl
│ │ ├── EastAsianWidth.txt
│ │ ├── Exact.pl
│ │ ├── HangulSyllableType.txt
│ │ ├── Index.txt
│ │ ├── Jamo.txt
│ │ ├── JamoShort.pl
│ │ ├── Lbrk.pl
│ │ ├── LineBreak.txt
│ │ ├── Makefile
│ │ ├── Name.pl
│ │ ├── NamesList.txt
│ │ ├── NormalizationCorrections.txt
│ │ ├── Number.pl
│ │ ├── PVA.pl
│ │ ├── PropList.txt
│ │ ├── PropValueAliases.txt
│ │ ├── Properties
│ │ ├── PropertyAliases.txt
│ │ ├── README.perl
│ │ ├── ReadMe.txt
│ │ ├── Scripts.pl
│ │ ├── Scripts.txt
│ │ ├── SpecialCasing.txt
│ │ ├── StandardizedVariants.txt
│ │ ├── To/
│ │ │ ├── Digit.pl
│ │ │ ├── Fold.pl
│ │ │ ├── Lower.pl
│ │ │ ├── Title.pl
│ │ │ └── Upper.pl
│ │ ├── UnicodeData.txt
│ │ ├── lib/
│ │ │ ├── ASCII.pl
│ │ │ ├── Alnum.pl
│ │ │ ├── Alpha.pl
│ │ │ ├── Alphabet.pl
│ │ │ ├── Any.pl
│ │ │ ├── Arabic.pl
│ │ │ ├── Armenian.pl
│ │ │ ├── AsciiHex.pl
│ │ │ ├── Assigned.pl
│ │ │ ├── Bengali.pl
│ │ │ ├── BidiAL.pl
│ │ │ ├── BidiAN.pl
│ │ │ ├── BidiB.pl
│ │ │ ├── BidiBN.pl
│ │ │ ├── BidiCS.pl
│ │ │ ├── BidiCont.pl
│ │ │ ├── BidiEN.pl
│ │ │ ├── BidiES.pl
│ │ │ ├── BidiET.pl
│ │ │ ├── BidiL.pl
│ │ │ ├── BidiLRE.pl
│ │ │ ├── BidiLRO.pl
│ │ │ ├── BidiNSM.pl
│ │ │ ├── BidiON.pl
│ │ │ ├── BidiPDF.pl
│ │ │ ├── BidiR.pl
│ │ │ ├── BidiRLE.pl
│ │ │ ├── BidiRLO.pl
│ │ │ ├── BidiS.pl
│ │ │ ├── BidiWS.pl
│ │ │ ├── Blank.pl
│ │ │ ├── Bopomofo.pl
│ │ │ ├── Braille.pl
│ │ │ ├── Buhid.pl
│ │ │ ├── C.pl
│ │ │ ├── Canadian.pl
│ │ │ ├── Canon.pl
│ │ │ ├── Cc.pl
│ │ │ ├── Cf.pl
│ │ │ ├── Cherokee.pl
│ │ │ ├── Cn.pl
│ │ │ ├── Cntrl.pl
│ │ │ ├── Co.pl
│ │ │ ├── Common.pl
│ │ │ ├── Compat.pl
│ │ │ ├── Cs.pl
│ │ │ ├── Cypriot.pl
│ │ │ ├── Cyrillic.pl
│ │ │ ├── DCcircle.pl
│ │ │ ├── DCcompat.pl
│ │ │ ├── DCfinal.pl
│ │ │ ├── DCfont.pl
│ │ │ ├── DCfracti.pl
│ │ │ ├── DCinitia.pl
│ │ │ ├── DCisolat.pl
│ │ │ ├── DCmedial.pl
│ │ │ ├── DCnarrow.pl
│ │ │ ├── DCnoBrea.pl
│ │ │ ├── DCsmall.pl
│ │ │ ├── DCsquare.pl
│ │ │ ├── DCsub.pl
│ │ │ ├── DCsuper.pl
│ │ │ ├── DCvertic.pl
│ │ │ ├── DCwide.pl
│ │ │ ├── Dash.pl
│ │ │ ├── Deprecat.pl
│ │ │ ├── Deseret.pl
│ │ │ ├── Devanaga.pl
│ │ │ ├── Diacriti.pl
│ │ │ ├── Digit.pl
│ │ │ ├── Ethiopic.pl
│ │ │ ├── Extender.pl
│ │ │ ├── Georgian.pl
│ │ │ ├── Gothic.pl
│ │ │ ├── Graph.pl
│ │ │ ├── Grapheme.pl
│ │ │ ├── Greek.pl
│ │ │ ├── Gujarati.pl
│ │ │ ├── Gurmukhi.pl
│ │ │ ├── Han.pl
│ │ │ ├── Hangul.pl
│ │ │ ├── Hanunoo.pl
│ │ │ ├── Hebrew.pl
│ │ │ ├── HexDigit.pl
│ │ │ ├── Hiragana.pl
│ │ │ ├── Hyphen.pl
│ │ │ ├── IdContin.pl
│ │ │ ├── IdStart.pl
│ │ │ ├── Ideograp.pl
│ │ │ ├── IdsBinar.pl
│ │ │ ├── IdsTrina.pl
│ │ │ ├── InAegean.pl
│ │ │ ├── InAlphab.pl
│ │ │ ├── InArabi2.pl
│ │ │ ├── InArabi3.pl
│ │ │ ├── InArabic.pl
│ │ │ ├── InArmeni.pl
│ │ │ ├── InArrows.pl
│ │ │ ├── InBasicL.pl
│ │ │ ├── InBengal.pl
│ │ │ ├── InBlockE.pl
│ │ │ ├── InBopom2.pl
│ │ │ ├── InBopomo.pl
│ │ │ ├── InBoxDra.pl
│ │ │ ├── InBraill.pl
│ │ │ ├── InBuhid.pl
│ │ │ ├── InByzant.pl
│ │ │ ├── InCherok.pl
│ │ │ ├── InCjkCo2.pl
│ │ │ ├── InCjkCo3.pl
│ │ │ ├── InCjkCo4.pl
│ │ │ ├── InCjkCom.pl
│ │ │ ├── InCjkRad.pl
│ │ │ ├── InCjkSym.pl
│ │ │ ├── InCjkUn2.pl
│ │ │ ├── InCjkUn3.pl
│ │ │ ├── InCjkUni.pl
│ │ │ ├── InCombi2.pl
│ │ │ ├── InCombi3.pl
│ │ │ ├── InCombin.pl
│ │ │ ├── InContro.pl
│ │ │ ├── InCurren.pl
│ │ │ ├── InCyprio.pl
│ │ │ ├── InCyril2.pl
│ │ │ ├── InCyrill.pl
│ │ │ ├── InDesere.pl
│ │ │ ├── InDevana.pl
│ │ │ ├── InDingba.pl
│ │ │ ├── InEnclo2.pl
│ │ │ ├── InEnclos.pl
│ │ │ ├── InEthiop.pl
│ │ │ ├── InGenera.pl
│ │ │ ├── InGeomet.pl
│ │ │ ├── InGeorgi.pl
│ │ │ ├── InGothic.pl
│ │ │ ├── InGreek.pl
│ │ │ ├── InGreekA.pl
│ │ │ ├── InGreekE.pl
│ │ │ ├── InGujara.pl
│ │ │ ├── InGurmuk.pl
│ │ │ ├── InHalfwi.pl
│ │ │ ├── InHangu2.pl
│ │ │ ├── InHangu3.pl
│ │ │ ├── InHangul.pl
│ │ │ ├── InHanuno.pl
│ │ │ ├── InHebrew.pl
│ │ │ ├── InHighPr.pl
│ │ │ ├── InHighSu.pl
│ │ │ ├── InHiraga.pl
│ │ │ ├── InIdeogr.pl
│ │ │ ├── InIpaExt.pl
│ │ │ ├── InKanbun.pl
│ │ │ ├── InKangxi.pl
│ │ │ ├── InKannad.pl
│ │ │ ├── InKatak2.pl
│ │ │ ├── InKataka.pl
│ │ │ ├── InKhmer.pl
│ │ │ ├── InKhmerS.pl
│ │ │ ├── InLao.pl
│ │ │ ├── InLatin1.pl
│ │ │ ├── InLatin2.pl
│ │ │ ├── InLatin3.pl
│ │ │ ├── InLatinE.pl
│ │ │ ├── InLetter.pl
│ │ │ ├── InLimbu.pl
│ │ │ ├── InLinea2.pl
│ │ │ ├── InLinear.pl
│ │ │ ├── InLowSur.pl
│ │ │ ├── InMalaya.pl
│ │ │ ├── InMathe2.pl
│ │ │ ├── InMathem.pl
│ │ │ ├── InMisce2.pl
│ │ │ ├── InMisce3.pl
│ │ │ ├── InMisce4.pl
│ │ │ ├── InMisce5.pl
│ │ │ ├── InMiscel.pl
│ │ │ ├── InMongol.pl
│ │ │ ├── InMusica.pl
│ │ │ ├── InMyanma.pl
│ │ │ ├── InNumber.pl
│ │ │ ├── InOgham.pl
│ │ │ ├── InOldIta.pl
│ │ │ ├── InOptica.pl
│ │ │ ├── InOriya.pl
│ │ │ ├── InOsmany.pl
│ │ │ ├── InPhonet.pl
│ │ │ ├── InPrivat.pl
│ │ │ ├── InRunic.pl
│ │ │ ├── InShavia.pl
│ │ │ ├── InSinhal.pl
│ │ │ ├── InSmallF.pl
│ │ │ ├── InSpacin.pl
│ │ │ ├── InSpecia.pl
│ │ │ ├── InSupers.pl
│ │ │ ├── InSuppl2.pl
│ │ │ ├── InSuppl3.pl
│ │ │ ├── InSuppl4.pl
│ │ │ ├── InSuppl5.pl
│ │ │ ├── InSupple.pl
│ │ │ ├── InSyriac.pl
│ │ │ ├── InTagalo.pl
│ │ │ ├── InTagban.pl
│ │ │ ├── InTags.pl
│ │ │ ├── InTaiLe.pl
│ │ │ ├── InTaiXua.pl
│ │ │ ├── InTamil.pl
│ │ │ ├── InTelugu.pl
│ │ │ ├── InThaana.pl
│ │ │ ├── InThai.pl
│ │ │ ├── InTibeta.pl
│ │ │ ├── InUgarit.pl
│ │ │ ├── InUnifie.pl
│ │ │ ├── InVaria2.pl
│ │ │ ├── InVariat.pl
│ │ │ ├── InYiRadi.pl
│ │ │ ├── InYiSyll.pl
│ │ │ ├── InYijing.pl
│ │ │ ├── Inherite.pl
│ │ │ ├── JoinCont.pl
│ │ │ ├── Kannada.pl
│ │ │ ├── Katakana.pl
│ │ │ ├── Khmer.pl
│ │ │ ├── L.pl
│ │ │ ├── L_.pl
│ │ │ ├── Lao.pl
│ │ │ ├── Latin.pl
│ │ │ ├── Limbu.pl
│ │ │ ├── LinearB.pl
│ │ │ ├── Ll.pl
│ │ │ ├── Lm.pl
│ │ │ ├── Lo.pl
│ │ │ ├── LogicalO.pl
│ │ │ ├── Lower.pl
│ │ │ ├── Lowercas.pl
│ │ │ ├── Lt.pl
│ │ │ ├── Lu.pl
│ │ │ ├── M.pl
│ │ │ ├── Malayala.pl
│ │ │ ├── Math.pl
│ │ │ ├── Mc.pl
│ │ │ ├── Me.pl
│ │ │ ├── Mirrored.pl
│ │ │ ├── Mn.pl
│ │ │ ├── Mongolia.pl
│ │ │ ├── Myanmar.pl
│ │ │ ├── N.pl
│ │ │ ├── Nd.pl
│ │ │ ├── Nl.pl
│ │ │ ├── No.pl
│ │ │ ├── Nonchara.pl
│ │ │ ├── Ogham.pl
│ │ │ ├── OldItali.pl
│ │ │ ├── Oriya.pl
│ │ │ ├── Osmanya.pl
│ │ │ ├── OtherAlp.pl
│ │ │ ├── OtherDef.pl
│ │ │ ├── OtherGra.pl
│ │ │ ├── OtherIdS.pl
│ │ │ ├── OtherLow.pl
│ │ │ ├── OtherMat.pl
│ │ │ ├── OtherUpp.pl
│ │ │ ├── P.pl
│ │ │ ├── Pc.pl
│ │ │ ├── Pd.pl
│ │ │ ├── Pe.pl
│ │ │ ├── Pf.pl
│ │ │ ├── Pi.pl
│ │ │ ├── Po.pl
│ │ │ ├── Print.pl
│ │ │ ├── Ps.pl
│ │ │ ├── Punct.pl
│ │ │ ├── Quotatio.pl
│ │ │ ├── Radical.pl
│ │ │ ├── Runic.pl
│ │ │ ├── S.pl
│ │ │ ├── Sc.pl
│ │ │ ├── Shavian.pl
│ │ │ ├── Sinhala.pl
│ │ │ ├── Sk.pl
│ │ │ ├── Sm.pl
│ │ │ ├── So.pl
│ │ │ ├── SoftDott.pl
│ │ │ ├── Space.pl
│ │ │ ├── SpacePer.pl
│ │ │ ├── Syriac.pl
│ │ │ ├── Tagalog.pl
│ │ │ ├── Tagbanwa.pl
│ │ │ ├── TaiLe.pl
│ │ │ ├── Tamil.pl
│ │ │ ├── Telugu.pl
│ │ │ ├── Terminal.pl
│ │ │ ├── Thaana.pl
│ │ │ ├── Thai.pl
│ │ │ ├── Tibetan.pl
│ │ │ ├── Title.pl
│ │ │ ├── Ugaritic.pl
│ │ │ ├── UnifiedI.pl
│ │ │ ├── Upper.pl
│ │ │ ├── Uppercas.pl
│ │ │ ├── WhiteSpa.pl
│ │ │ ├── Word.pl
│ │ │ ├── XDigit.pl
│ │ │ ├── Yi.pl
│ │ │ ├── Z.pl
│ │ │ ├── Zl.pl
│ │ │ ├── Zp.pl
│ │ │ ├── Zs.pl
│ │ │ ├── _CanonDC.pl
│ │ │ ├── _CaseIgn.pl
│ │ │ ├── _CombAbo.pl
│ │ │ ├── bc/
│ │ │ │ ├── AL.pl
│ │ │ │ ├── AN.pl
│ │ │ │ ├── B.pl
│ │ │ │ ├── BN.pl
│ │ │ │ ├── CS.pl
│ │ │ │ ├── EN.pl
│ │ │ │ ├── ES.pl
│ │ │ │ ├── ET.pl
│ │ │ │ ├── L.pl
│ │ │ │ ├── LRE.pl
│ │ │ │ ├── LRO.pl
│ │ │ │ ├── NSM.pl
│ │ │ │ ├── ON.pl
│ │ │ │ ├── PDF.pl
│ │ │ │ ├── R.pl
│ │ │ │ ├── RLE.pl
│ │ │ │ ├── RLO.pl
│ │ │ │ ├── S.pl
│ │ │ │ └── WS.pl
│ │ │ ├── ccc/
│ │ │ │ ├── A.pl
│ │ │ │ ├── AL.pl
│ │ │ │ ├── AR.pl
│ │ │ │ ├── ATAR.pl
│ │ │ │ ├── ATB.pl
│ │ │ │ ├── ATBL.pl
│ │ │ │ ├── B.pl
│ │ │ │ ├── BL.pl
│ │ │ │ ├── BR.pl
│ │ │ │ ├── DA.pl
│ │ │ │ ├── DB.pl
│ │ │ │ ├── IS.pl
│ │ │ │ ├── KV.pl
│ │ │ │ ├── L.pl
│ │ │ │ ├── NK.pl
│ │ │ │ ├── NR.pl
│ │ │ │ ├── OV.pl
│ │ │ │ ├── R.pl
│ │ │ │ └── VR.pl
│ │ │ ├── dt/
│ │ │ │ ├── can.pl
│ │ │ │ ├── com.pl
│ │ │ │ ├── enc.pl
│ │ │ │ ├── fin.pl
│ │ │ │ ├── font.pl
│ │ │ │ ├── fra.pl
│ │ │ │ ├── init.pl
│ │ │ │ ├── iso.pl
│ │ │ │ ├── med.pl
│ │ │ │ ├── nar.pl
│ │ │ │ ├── nb.pl
│ │ │ │ ├── sml.pl
│ │ │ │ ├── sqr.pl
│ │ │ │ ├── sub.pl
│ │ │ │ ├── sup.pl
│ │ │ │ ├── vert.pl
│ │ │ │ └── wide.pl
│ │ │ ├── ea/
│ │ │ │ ├── A.pl
│ │ │ │ ├── F.pl
│ │ │ │ ├── H.pl
│ │ │ │ ├── N.pl
│ │ │ │ ├── Na.pl
│ │ │ │ └── W.pl
│ │ │ ├── gc_sc/
│ │ │ │ ├── AHex.pl
│ │ │ │ ├── ASCII.pl
│ │ │ │ ├── Alnum.pl
│ │ │ │ ├── Alpha.pl
│ │ │ │ ├── Alphabet.pl
│ │ │ │ ├── Any.pl
│ │ │ │ ├── Arab.pl
│ │ │ │ ├── Armn.pl
│ │ │ │ ├── AsciiHex.pl
│ │ │ │ ├── Assigned.pl
│ │ │ │ ├── Beng.pl
│ │ │ │ ├── BidiC.pl
│ │ │ │ ├── BidiCont.pl
│ │ │ │ ├── Blank.pl
│ │ │ │ ├── Bopo.pl
│ │ │ │ ├── Brai.pl
│ │ │ │ ├── Buhd.pl
│ │ │ │ ├── C.pl
│ │ │ │ ├── Canadian.pl
│ │ │ │ ├── Cc.pl
│ │ │ │ ├── Cf.pl
│ │ │ │ ├── Cher.pl
│ │ │ │ ├── Cn.pl
│ │ │ │ ├── Cntrl.pl
│ │ │ │ ├── Co.pl
│ │ │ │ ├── Cprt.pl
│ │ │ │ ├── Cs.pl
│ │ │ │ ├── Cyrl.pl
│ │ │ │ ├── Dash.pl
│ │ │ │ ├── Dash2.pl
│ │ │ │ ├── Dep.pl
│ │ │ │ ├── Deprecat.pl
│ │ │ │ ├── Deva.pl
│ │ │ │ ├── Dia.pl
│ │ │ │ ├── Diacriti.pl
│ │ │ │ ├── Digit.pl
│ │ │ │ ├── Dsrt.pl
│ │ │ │ ├── Ethi.pl
│ │ │ │ ├── Ext.pl
│ │ │ │ ├── Extender.pl
│ │ │ │ ├── Geor.pl
│ │ │ │ ├── Goth.pl
│ │ │ │ ├── GrLink.pl
│ │ │ │ ├── Graph.pl
│ │ │ │ ├── Grapheme.pl
│ │ │ │ ├── Grek.pl
│ │ │ │ ├── Gujr.pl
│ │ │ │ ├── Guru.pl
│ │ │ │ ├── Hang.pl
│ │ │ │ ├── Hani.pl
│ │ │ │ ├── Hano.pl
│ │ │ │ ├── Hebr.pl
│ │ │ │ ├── Hex.pl
│ │ │ │ ├── HexDigit.pl
│ │ │ │ ├── Hira.pl
│ │ │ │ ├── Hyphen.pl
│ │ │ │ ├── Hyphen2.pl
│ │ │ │ ├── IDSB.pl
│ │ │ │ ├── IDST.pl
│ │ │ │ ├── IdContin.pl
│ │ │ │ ├── IdStart.pl
│ │ │ │ ├── Ideo.pl
│ │ │ │ ├── Ideograp.pl
│ │ │ │ ├── IdsBinar.pl
│ │ │ │ ├── IdsTrina.pl
│ │ │ │ ├── InAegean.pl
│ │ │ │ ├── InAlphab.pl
│ │ │ │ ├── InArabi2.pl
│ │ │ │ ├── InArabi3.pl
│ │ │ │ ├── InArabic.pl
│ │ │ │ ├── InArmeni.pl
│ │ │ │ ├── InArrows.pl
│ │ │ │ ├── InBasicL.pl
│ │ │ │ ├── InBengal.pl
│ │ │ │ ├── InBlockE.pl
│ │ │ │ ├── InBopom2.pl
│ │ │ │ ├── InBopomo.pl
│ │ │ │ ├── InBoxDra.pl
│ │ │ │ ├── InBraill.pl
│ │ │ │ ├── InBuhid.pl
│ │ │ │ ├── InByzant.pl
│ │ │ │ ├── InCherok.pl
│ │ │ │ ├── InCjkCo2.pl
│ │ │ │ ├── InCjkCo3.pl
│ │ │ │ ├── InCjkCo4.pl
│ │ │ │ ├── InCjkCom.pl
│ │ │ │ ├── InCjkRad.pl
│ │ │ │ ├── InCjkSym.pl
│ │ │ │ ├── InCjkUn2.pl
│ │ │ │ ├── InCjkUn3.pl
│ │ │ │ ├── InCjkUni.pl
│ │ │ │ ├── InCombi2.pl
│ │ │ │ ├── InCombi3.pl
│ │ │ │ ├── InCombin.pl
│ │ │ │ ├── InContro.pl
│ │ │ │ ├── InCurren.pl
│ │ │ │ ├── InCyprio.pl
│ │ │ │ ├── InCyril2.pl
│ │ │ │ ├── InCyrill.pl
│ │ │ │ ├── InDesere.pl
│ │ │ │ ├── InDevana.pl
│ │ │ │ ├── InDingba.pl
│ │ │ │ ├── InEnclo2.pl
│ │ │ │ ├── InEnclos.pl
│ │ │ │ ├── InEthiop.pl
│ │ │ │ ├── InGenera.pl
│ │ │ │ ├── InGeomet.pl
│ │ │ │ ├── InGeorgi.pl
│ │ │ │ ├── InGothic.pl
│ │ │ │ ├── InGreekA.pl
│ │ │ │ ├── InGreekE.pl
│ │ │ │ ├── InGujara.pl
│ │ │ │ ├── InGurmuk.pl
│ │ │ │ ├── InHalfwi.pl
│ │ │ │ ├── InHangu2.pl
│ │ │ │ ├── InHangu3.pl
│ │ │ │ ├── InHangul.pl
│ │ │ │ ├── InHanuno.pl
│ │ │ │ ├── InHebrew.pl
│ │ │ │ ├── InHighPr.pl
│ │ │ │ ├── InHighSu.pl
│ │ │ │ ├── InHiraga.pl
│ │ │ │ ├── InIdeogr.pl
│ │ │ │ ├── InIpaExt.pl
│ │ │ │ ├── InKanbun.pl
│ │ │ │ ├── InKangxi.pl
│ │ │ │ ├── InKannad.pl
│ │ │ │ ├── InKatak2.pl
│ │ │ │ ├── InKataka.pl
│ │ │ │ ├── InKhmer.pl
│ │ │ │ ├── InKhmerS.pl
│ │ │ │ ├── InLao.pl
│ │ │ │ ├── InLatin1.pl
│ │ │ │ ├── InLatin2.pl
│ │ │ │ ├── InLatin3.pl
│ │ │ │ ├── InLatinE.pl
│ │ │ │ ├── InLetter.pl
│ │ │ │ ├── InLimbu.pl
│ │ │ │ ├── InLinea2.pl
│ │ │ │ ├── InLinear.pl
│ │ │ │ ├── InLowSur.pl
│ │ │ │ ├── InMalaya.pl
│ │ │ │ ├── InMathe2.pl
│ │ │ │ ├── InMathem.pl
│ │ │ │ ├── InMisce2.pl
│ │ │ │ ├── InMisce3.pl
│ │ │ │ ├── InMisce4.pl
│ │ │ │ ├── InMisce5.pl
│ │ │ │ ├── InMiscel.pl
│ │ │ │ ├── InMongol.pl
│ │ │ │ ├── InMusica.pl
│ │ │ │ ├── InMyanma.pl
│ │ │ │ ├── InNumber.pl
│ │ │ │ ├── InOgham.pl
│ │ │ │ ├── InOldIta.pl
│ │ │ │ ├── InOptica.pl
│ │ │ │ ├── InOriya.pl
│ │ │ │ ├── InOsmany.pl
│ │ │ │ ├── InPhonet.pl
│ │ │ │ ├── InPrivat.pl
│ │ │ │ ├── InRunic.pl
│ │ │ │ ├── InShavia.pl
│ │ │ │ ├── InSinhal.pl
│ │ │ │ ├── InSmallF.pl
│ │ │ │ ├── InSpacin.pl
│ │ │ │ ├── InSpecia.pl
│ │ │ │ ├── InSupers.pl
│ │ │ │ ├── InSuppl2.pl
│ │ │ │ ├── InSuppl3.pl
│ │ │ │ ├── InSuppl4.pl
│ │ │ │ ├── InSuppl5.pl
│ │ │ │ ├── InSupple.pl
│ │ │ │ ├── InSyriac.pl
│ │ │ │ ├── InTagalo.pl
│ │ │ │ ├── InTagban.pl
│ │ │ │ ├── InTags.pl
│ │ │ │ ├── InTaiLe.pl
│ │ │ │ ├── InTaiXua.pl
│ │ │ │ ├── InTamil.pl
│ │ │ │ ├── InTelugu.pl
│ │ │ │ ├── InThaana.pl
│ │ │ │ ├── InThai.pl
│ │ │ │ ├── InTibeta.pl
│ │ │ │ ├── InUgarit.pl
│ │ │ │ ├── InUnifie.pl
│ │ │ │ ├── InVaria2.pl
│ │ │ │ ├── InVariat.pl
│ │ │ │ ├── InYiRadi.pl
│ │ │ │ ├── InYiSyll.pl
│ │ │ │ ├── InYijing.pl
│ │ │ │ ├── JoinC.pl
│ │ │ │ ├── JoinCont.pl
│ │ │ │ ├── Kana.pl
│ │ │ │ ├── Katakana.pl
│ │ │ │ ├── Khmr.pl
│ │ │ │ ├── Knda.pl
│ │ │ │ ├── L.pl
│ │ │ │ ├── LC.pl
│ │ │ │ ├── LOE.pl
│ │ │ │ ├── Laoo.pl
│ │ │ │ ├── Latn.pl
│ │ │ │ ├── Limb.pl
│ │ │ │ ├── LinearB.pl
│ │ │ │ ├── Ll.pl
│ │ │ │ ├── Lm.pl
│ │ │ │ ├── Lo.pl
│ │ │ │ ├── LogicalO.pl
│ │ │ │ ├── Lower.pl
│ │ │ │ ├── Lowercas.pl
│ │ │ │ ├── Lt.pl
│ │ │ │ ├── Lu.pl
│ │ │ │ ├── M.pl
│ │ │ │ ├── Math.pl
│ │ │ │ ├── Mc.pl
│ │ │ │ ├── Me.pl
│ │ │ │ ├── Mlym.pl
│ │ │ │ ├── Mn.pl
│ │ │ │ ├── Mong.pl
│ │ │ │ ├── Mymr.pl
│ │ │ │ ├── N.pl
│ │ │ │ ├── NChar.pl
│ │ │ │ ├── Nd.pl
│ │ │ │ ├── Nl.pl
│ │ │ │ ├── No.pl
│ │ │ │ ├── Nonchara.pl
│ │ │ │ ├── OAlpha.pl
│ │ │ │ ├── ODI.pl
│ │ │ │ ├── OGrExt.pl
│ │ │ │ ├── OIDS.pl
│ │ │ │ ├── OLower.pl
│ │ │ │ ├── OMath.pl
│ │ │ │ ├── OUpper.pl
│ │ │ │ ├── Ogam.pl
│ │ │ │ ├── OldItali.pl
│ │ │ │ ├── Orya.pl
│ │ │ │ ├── Osma.pl
│ │ │ │ ├── OtherAlp.pl
│ │ │ │ ├── OtherDef.pl
│ │ │ │ ├── OtherGra.pl
│ │ │ │ ├── OtherIdS.pl
│ │ │ │ ├── OtherLow.pl
│ │ │ │ ├── OtherMat.pl
│ │ │ │ ├── OtherUpp.pl
│ │ │ │ ├── P.pl
│ │ │ │ ├── Pc.pl
│ │ │ │ ├── Pd.pl
│ │ │ │ ├── Pe.pl
│ │ │ │ ├── Pf.pl
│ │ │ │ ├── Pi.pl
│ │ │ │ ├── Po.pl
│ │ │ │ ├── Print.pl
│ │ │ │ ├── Ps.pl
│ │ │ │ ├── Punct.pl
│ │ │ │ ├── QMark.pl
│ │ │ │ ├── Qaai.pl
│ │ │ │ ├── Quotatio.pl
│ │ │ │ ├── Radical.pl
│ │ │ │ ├── Radical2.pl
│ │ │ │ ├── Runr.pl
│ │ │ │ ├── S.pl
│ │ │ │ ├── SD.pl
│ │ │ │ ├── STerm.pl
│ │ │ │ ├── Sc.pl
│ │ │ │ ├── Shaw.pl
│ │ │ │ ├── Sinh.pl
│ │ │ │ ├── Sk.pl
│ │ │ │ ├── Sm.pl
│ │ │ │ ├── So.pl
│ │ │ │ ├── SoftDott.pl
│ │ │ │ ├── Space.pl
│ │ │ │ ├── SpacePer.pl
│ │ │ │ ├── Sterm2.pl
│ │ │ │ ├── Syrc.pl
│ │ │ │ ├── Tagb.pl
│ │ │ │ ├── TaiLe.pl
│ │ │ │ ├── Taml.pl
│ │ │ │ ├── Telu.pl
│ │ │ │ ├── Term.pl
│ │ │ │ ├── Terminal.pl
│ │ │ │ ├── Tglg.pl
│ │ │ │ ├── Thaa.pl
│ │ │ │ ├── Thai.pl
│ │ │ │ ├── Tibt.pl
│ │ │ │ ├── Title.pl
│ │ │ │ ├── UIdeo.pl
│ │ │ │ ├── Ugar.pl
│ │ │ │ ├── UnifiedI.pl
│ │ │ │ ├── Upper.pl
│ │ │ │ ├── Uppercas.pl
│ │ │ │ ├── VS.pl
│ │ │ │ ├── Variatio.pl
│ │ │ │ ├── WSpace.pl
│ │ │ │ ├── WhiteSpa.pl
│ │ │ │ ├── Word.pl
│ │ │ │ ├── XDigit.pl
│ │ │ │ ├── Yiii.pl
│ │ │ │ ├── Z.pl
│ │ │ │ ├── Zl.pl
│ │ │ │ ├── Zp.pl
│ │ │ │ ├── Zs.pl
│ │ │ │ ├── Zyyy.pl
│ │ │ │ ├── _CanonDC.pl
│ │ │ │ ├── _CaseIgn.pl
│ │ │ │ └── _CombAbo.pl
│ │ │ ├── hst/
│ │ │ │ ├── L.pl
│ │ │ │ ├── LV.pl
│ │ │ │ ├── LVT.pl
│ │ │ │ ├── T.pl
│ │ │ │ └── V.pl
│ │ │ ├── jt/
│ │ │ │ ├── C.pl
│ │ │ │ ├── D.pl
│ │ │ │ ├── R.pl
│ │ │ │ └── U.pl
│ │ │ ├── lb/
│ │ │ │ ├── AI.pl
│ │ │ │ ├── AL.pl
│ │ │ │ ├── B2.pl
│ │ │ │ ├── BA.pl
│ │ │ │ ├── BB.pl
│ │ │ │ ├── BK.pl
│ │ │ │ ├── CB.pl
│ │ │ │ ├── CL.pl
│ │ │ │ ├── CM.pl
│ │ │ │ ├── CR.pl
│ │ │ │ ├── EX.pl
│ │ │ │ ├── GL.pl
│ │ │ │ ├── HY.pl
│ │ │ │ ├── ID.pl
│ │ │ │ ├── IN.pl
│ │ │ │ ├── IS.pl
│ │ │ │ ├── LF.pl
│ │ │ │ ├── NL.pl
│ │ │ │ ├── NS.pl
│ │ │ │ ├── NU.pl
│ │ │ │ ├── OP.pl
│ │ │ │ ├── PO.pl
│ │ │ │ ├── PR.pl
│ │ │ │ ├── QU.pl
│ │ │ │ ├── SA.pl
│ │ │ │ ├── SG.pl
│ │ │ │ ├── SP.pl
│ │ │ │ ├── SY.pl
│ │ │ │ ├── WJ.pl
│ │ │ │ ├── XX.pl
│ │ │ │ └── ZW.pl
│ │ │ └── nt/
│ │ │ ├── De.pl
│ │ │ ├── Di.pl
│ │ │ └── Nu.pl
│ │ ├── mktables
│ │ └── version
│ ├── utf8.pm
│ ├── utf8_heavy.pl
│ ├── util.pm
│ ├── validate.pl
│ ├── vars.pm
│ ├── warnings/
│ │ └── register.pm
│ └── warnings.pm
├── locale.c
├── mg.c
├── mg.h
├── nostdio.h
├── numeric.c
├── op.c
├── op.h
├── opcode.h
├── opnames.h
├── out.txt
├── pad.c
├── pad.h
├── parser-util.c
├── patchlevel.h
├── perl.c
├── perl.h
├── perlapi.c
├── perlapi.h
├── perlio.c
├── perlio.h
├── perliol.h
├── perlmain.c
├── perlsdio.h
├── perlsfio.h
├── perlvars.h
├── perly.c
├── perly.h
├── pfunc.h
├── poll.c
├── poll.h
├── pp.c
├── pp.h
├── pp_ctl.c
├── pp_hot.c
├── pp_pack.c
├── pp_proto.h
├── pp_sort.c
├── pp_sys.c
├── ppport.h
├── proto.h
├── reentr.h
├── reentr.inc
├── regcomp.c
├── regcomp.h
├── regexec.c
├── regexp.h
├── regnodes.h
├── run.c
├── scope.c
├── scope.h
├── spec_config.h
├── specrand.c
├── specrand.h
├── stdio.c
├── sv.c
├── sv.h
├── taint.c
├── thrdvar.h
├── thread.h
├── toke.c
├── tokenpos.h
├── universal.c
├── utf8.c
├── utf8.h
├── utfebcdic.h
├── util.c
├── util.h
├── warnings.h
├── win32/
│ ├── dirent.h
│ ├── netdb.h
│ ├── perlhost.h
│ ├── perllib.c
│ ├── sys/
│ │ └── socket.h
│ ├── vdir.h
│ ├── vmem.h
│ ├── win32.c
│ ├── win32.h
│ ├── win32io.c
│ ├── win32iop.h
│ ├── win32sck.c
│ ├── win32thread.c
│ └── win32thread.h
└── xsutils.c
SYMBOL INDEX (3421 symbols across 142 files)
FILE: pass/IntrinsicLibcalls.h
function InitLibcalls (line 21) | void InitLibcalls() {
function isAlwaysInlined (line 113) | bool isAlwaysInlined(StringRef intrinsic) {
function StringRef (line 117) | StringRef GetLibcall(StringRef intrinsic) {
FILE: pass/LowerIntrinsics.cpp
type LowerIntrinsics (line 17) | struct LowerIntrinsics: public ModulePass {
method LowerIntrinsics (line 20) | LowerIntrinsics() : ModulePass(ID) {
method runOnModule (line 23) | virtual bool runOnModule(Module &m) {
FILE: pass/Stabilizer.cpp
type StabilizerPass (line 33) | struct StabilizerPass : public ModulePass {
method StabilizerPass (line 40) | StabilizerPass() : ModulePass(ID) {}
type Platform (line 42) | enum Platform {
method Platform (line 54) | Platform getPlatform(Module& m) {
method Type (line 83) | Type* getIntptrType(Module& m) {
method getIntptrSize (line 91) | size_t getIntptrSize(Module& m) {
method Constant (line 99) | Constant* getInt(Module& m, size_t bits, uint64_t value, bool is_signe...
method Constant (line 103) | Constant* getIntptr(Module& m, uint64_t value, bool is_signed) {
method isDataPCRelative (line 112) | bool isDataPCRelative(Module& m) {
method runOnModule (line 131) | virtual bool runOnModule(Module &m) {
method getConstructors (line 234) | vector<Value*> getConstructors(Module& m) {
method Function (line 268) | Function* makeConstructor(Module& m, StringRef name) {
method randomizeStack (line 340) | void randomizeStack(Module& m, llvm::Function& f, GlobalVariable* stac...
method randomizeCode (line 403) | vector<Value*> randomizeCode(Module& m, Function& f) {
method containsGlobal (line 577) | bool containsGlobal(Value* v) {
method findPCRelativeUsesIn (line 609) | map<Constant*, set<Use*> > findPCRelativeUsesIn(Function& f) {
method extractFloatOperations (line 663) | void extractFloatOperations(Function& f) {
method containsConstantFloat (line 729) | bool containsConstantFloat(Constant* c) {
method Function (line 759) | Function* getFloatConversion(Module& m, unsigned opcode, Type* in, Typ...
method randomizeHeap (line 847) | void randomizeHeap(Module& m) {
method declareRuntimeFunctions (line 902) | void declareRuntimeFunctions(Module& m) {
FILE: process.py
function where (line 58) | def where(results, key, *values):
function distinct (line 61) | def distinct(results, key):
function keymap (line 68) | def keymap(results, key, f):
function get (line 76) | def get(results, *keys):
function group (line 86) | def group(results, *keys):
function pad (line 108) | def pad(s, length=20):
FILE: run.py
function runspec (line 40) | def runspec(bench, size, tune, ext, n, rebuild=False):
FILE: runtime/Context.h
type Stack (line 22) | struct Stack {
function Stack (line 102) | inline Stack stack() {
FILE: runtime/Debug.cpp
function panic (line 12) | void panic() {
FILE: runtime/Function.cpp
function FunctionLocation (line 57) | FunctionLocation* Function::relocate() {
FILE: runtime/Function.h
type Function (line 13) | struct Function
type FunctionLocation (line 14) | struct FunctionLocation
function trap (line 16) | struct FunctionHeader {
function Function (line 36) | Function* getFunction() {
type Function (line 41) | struct Function {
function delete (line 80) | void operator delete(void* p) {
function setTrap (line 121) | inline void setTrap() {
function getCodeSize (line 129) | inline size_t getCodeSize() {
function getAllocationSize (line 133) | inline size_t getAllocationSize() {
function FunctionLocation (line 141) | inline FunctionLocation* getCurrentLocation() {
FILE: runtime/FunctionLocation.h
type FunctionLocation (line 11) | struct FunctionLocation {
function delete (line 67) | void operator delete(void* p) {
function activate (line 71) | void activate() {
function release (line 75) | void release() {
function mark (line 83) | static void mark(void* p) {
function sweep (line 90) | static void sweep() {
FILE: runtime/Heap.cpp
function DataHeapType (line 3) | DataHeapType* getDataHeap() {
function CodeHeapType (line 9) | CodeHeapType* getCodeHeap() {
FILE: runtime/Heap.h
type ANSIWrapper (line 25) | typedef ANSIWrapper<KingsleyHeap<ShuffleHeap<DataShuffle, DataSource>, D...
type ANSIWrapper (line 26) | typedef ANSIWrapper<KingsleyHeap<ShuffleHeap<CodeShuffle, CodeSource>, C...
FILE: runtime/Intrinsics.cpp
function powif (line 7) | float powif(float b, int e) {
function memset_i32 (line 11) | void memset_i32(void* p, uint8_t val, uint32_t len, uint32_t align, bool...
function memset_i64 (line 15) | void memset_i64(void* p, uint8_t val, uint64_t len, uint32_t align, bool...
FILE: runtime/Jump.h
type X86Jump32 (line 10) | struct X86Jump32 {
type X86Jump64 (line 21) | struct X86Jump64 {
function else (line 44) | struct X86_64Jump {
type X86Jump32 (line 98) | typedef X86Jump32 Jump;
type X86_64Jump (line 100) | typedef X86_64Jump Jump;
type PPCJump (line 102) | typedef PPCJump Jump;
FILE: runtime/MemRange.h
function MemRange (line 6) | struct MemRange {
function pageSize (line 35) | inline size_t pageSize() {
function size (line 43) | inline size_t size() {
function offsetOf (line 47) | inline size_t offsetOf(void* p) {
function contains (line 55) | inline bool contains(void* p) {
FILE: runtime/Trap.h
type X86Trap (line 8) | struct X86Trap {
type PPCTrap (line 20) | struct PPCTrap {
type X86Trap (line 33) | typedef X86Trap Trap;
type X86Trap (line 35) | typedef X86Trap Trap;
type PPCTrap (line 37) | typedef PPCTrap Trap;
FILE: runtime/Util.h
function flush_icache (line 26) | static void flush_icache(void* begin, size_t size) {
function getRandomByte (line 37) | static inline uint8_t getRandomByte() {
FILE: runtime/libstabilizer.cpp
function main (line 50) | int main(int argc, char **argv) {
function stabilizer_register_function (line 87) | void stabilizer_register_function(void* codeBase, void* codeLimit, void*...
function stabilizer_register_constructor (line 92) | void stabilizer_register_constructor(ctor_t ctor) {
function stabilizer_register_stack_pad (line 96) | void stabilizer_register_stack_pad(uint8_t* pad) {
function stabilizer_free (line 112) | void stabilizer_free(void *p) {
function reportDoubleFreeError (line 120) | void reportDoubleFreeError() {
function onTrap (line 125) | void onTrap(int sig, siginfo_t* info, void* p) {
function onTimer (line 171) | void onTimer(int sig, siginfo_t* info, void* p) {
function onFault (line 202) | void onFault(int sig, siginfo_t* info, void* p) {
function setTimer (line 207) | void setTimer(int msec) {
function setHandler (line 218) | void setHandler(int sig, void(*fn)(int, siginfo_t*, void*)) {
FILE: tests/Context/hello.cpp
function foo (line 18) | void foo(int x, int y, int z) {
function bar (line 23) | void bar(int x, int y, int z) {
function placeStub (line 28) | void placeStub(void* p) {
function placeTrap (line 53) | void placeTrap(void* p) {
function doStuff (line 75) | void doStuff(void* source, void* restore) {
function trap (line 103) | void trap(int sig, siginfo_t *info, void *c) {
function main (line 111) | int main(int argc, char** argv) {
FILE: tests/HelloWorld/hello.cpp
function ctor (line 5) | void ctor() {
function main (line 9) | int main(int argc, char** argv) {
FILE: tests/bzip2/blocksort.c
function fallbackSimpleSort (line 77) | static
function fallbackQSort3 (line 139) | static
function fallbackSort (line 258) | static
function Bool (line 392) | static
function mainSimpleSort (line 531) | static
function UChar (line 628) | static
function mainQSort3 (line 667) | static
function mainSort (line 797) | static
function BZ2_blockSort (line 1078) | void BZ2_blockSort ( EState* s )
FILE: tests/bzip2/bzip2.c
type Char (line 260) | typedef char Char;
type Bool (line 261) | typedef unsigned char Bool;
type UChar (line 262) | typedef unsigned char UChar;
type Int32 (line 263) | typedef int Int32;
type UInt32 (line 264) | typedef unsigned int UInt32;
type Int16 (line 265) | typedef short Int16;
type UInt16 (line 266) | typedef unsigned short UInt16;
type IntNative (line 275) | typedef int IntNative;
function cleanUpAndFail (line 321) | static void cleanUpAndFail ( Int32 ) NORETURN;
function uInt64_from_UInt32s (line 339) | static
function uInt64_to_double (line 353) | static
function Bool (line 367) | static
function Int32 (line 378) | static
function uInt64_toAscii (line 396) | static
function Bool (line 421) | Bool myfeof ( int f )
function Bool (line 674) | Bool testStream ( int zStream )
function setExit (line 777) | static
function cadvise (line 789) | static
function showFileNames (line 804) | static
function cleanUpAndFail (line 817) | static
function panic (line 878) | static
function crcError (line 898) | static
function compressedStreamEOF (line 911) | static
function ioError (line 928) | static
function mySignalCatcher (line 942) | static
function mySIGSEGVorSIGBUScatcher (line 953) | static
function outOfMemory (line 1013) | static
function configError (line 1025) | static
function pad (line 1050) | static
function copyFileName (line 1061) | static
function Bool (line 1082) | static
function FILE (line 1102) | FILE* fopen_output_safely ( Char* name, const char* mode )
function Bool (line 1122) | static
function Int32 (line 1139) | static
type MY_STAT (line 1176) | struct MY_STAT
function saveInputFileMetaInfo (line 1179) | static
function applySavedMetaInfoToOutputFile (line 1191) | static
function Bool (line 1216) | static
function Bool (line 1243) | static
function Bool (line 1253) | static
function compress (line 1265) | static
function uncompress (line 1446) | static
function testf (line 1644) | static
function license (line 1733) | static
function usage (line 1758) | static
function redundant (line 1802) | static
type Cell (line 1827) | typedef
function Cell (line 1848) | static
function Cell (line 1861) | static
function addFlagsFromEnvVar (line 1879) | static
function IntNative (line 1909) | IntNative main ( IntNative argc, Char *argv[] )
FILE: tests/bzip2/bzlib.c
function BZ2_bz__AssertH__fail (line 87) | void BZ2_bz__AssertH__fail ( int errcode )
function bz_config_ok (line 147) | static
function default_bzfree (line 165) | static
function prepare_new_block (line 173) | static
function init_RL (line 187) | static
function Bool (line 195) | static
function add_pair_to_block (line 272) | static
function flush_RL (line 308) | static
function Bool (line 345) | static
function Bool (line 390) | static
function Bool (line 417) | static
function Bool (line 592) | static
function Int32 (line 743) | __inline__ Int32 BZ2_indexIntoF ( Int32 indx, Int32 *cftab )
function Bool (line 761) | static
type bzFile (line 948) | typedef
function Bool (line 969) | static Bool myfeof ( FILE* f )
function BZFILE (line 1457) | static
function BZFILE (line 1551) | BZFILE * BZ_API(BZ2_bzopen)
function BZFILE (line 1560) | BZFILE * BZ_API(BZ2_bzdopen)
FILE: tests/bzip2/bzlib.h
type bz_stream (line 203) | typedef
type BZFILE (line 292) | typedef void BZFILE;
FILE: tests/bzip2/bzlib_private.h
type Char (line 81) | typedef char Char;
type Bool (line 82) | typedef unsigned char Bool;
type UChar (line 83) | typedef unsigned char UChar;
type Int32 (line 84) | typedef int Int32;
type UInt32 (line 85) | typedef unsigned int UInt32;
type Int16 (line 86) | typedef short Int16;
type UInt16 (line 87) | typedef unsigned short UInt16;
type EState (line 230) | typedef
type DState (line 381) | typedef
FILE: tests/bzip2/compress.c
function BZ2_bsInitWrite (line 81) | void BZ2_bsInitWrite ( EState* s )
function bsFinishWrite (line 89) | static
function bsW (line 115) | static
function bsPutUInt32 (line 126) | static
function bsPutUChar (line 137) | static
function makeMaps_e (line 149) | static
function generateMTFValues (line 163) | static
function sendMTFValues (line 282) | static
function BZ2_compressBlock (line 646) | void BZ2_compressBlock ( EState* s, Bool is_last_block )
FILE: tests/bzip2/decompress.c
function makeMaps_d (line 66) | static
function Int32 (line 146) | Int32 BZ2_decompress ( DState* s )
FILE: tests/bzip2/huffman.c
function BZ2_hbMakeCodeLengths (line 103) | void BZ2_hbMakeCodeLengths ( UChar *len,
function BZ2_hbAssignCodes (line 192) | void BZ2_hbAssignCodes ( Int32 *code,
function BZ2_hbCreateDecodeTables (line 210) | void BZ2_hbCreateDecodeTables ( Int32 *limit,
FILE: tests/bzip2/spec.c
type spec_fd_t (line 45) | struct spec_fd_t {
function spec_init (line 80) | int spec_init () {
function spec_random_load (line 103) | int spec_random_load (int fd) {
function spec_load (line 132) | int spec_load (int num, char *filename, int size) {
function spec_read (line 164) | int spec_read (int fd, unsigned char *buf, int size) {
function spec_fread (line 185) | int spec_fread (unsigned char *buf, int size, int num, int fd) {
function spec_getc (line 206) | int spec_getc (int fd) {
function spec_ungetc (line 221) | int spec_ungetc (unsigned char ch, int fd) {
function spec_rewind (line 239) | int spec_rewind(int fd) {
function spec_reset (line 243) | int spec_reset(int fd) {
function spec_write (line 249) | int spec_write(int fd, unsigned char *buf, int size) {
function spec_fwrite (line 261) | int spec_fwrite(unsigned char *buf, int size, int num, int fd) {
function spec_putc (line 273) | int spec_putc(unsigned char ch, int fd) {
function main (line 286) | int main (int argc, char *argv[]) {
function spec_initbufs (line 388) | void spec_initbufs() {
function spec_compress (line 396) | void spec_compress(int in, int out, int lev) {
function spec_uncompress (line 400) | void spec_uncompress(int in, int out, int lev) {
function debug_time (line 408) | int debug_time () {
FILE: tests/libquantum/classic.c
function quantum_ipow (line 36) | int
function quantum_gcd (line 50) | int
function quantum_frac_approx (line 66) | void
function quantum_getwidth (line 103) | int
function quantum_inverse_mod (line 115) | int
FILE: tests/libquantum/complex.c
function COMPLEX_FLOAT (line 34) | COMPLEX_FLOAT
function quantum_prob (line 47) | float
function COMPLEX_FLOAT (line 55) | COMPLEX_FLOAT quantum_cexp(float phi)
FILE: tests/libquantum/decoherence.c
function quantum_get_decoherence (line 47) | float
function quantum_set_decoherence (line 56) | void
function quantum_decohere (line 72) | void
FILE: tests/libquantum/expn.c
function quantum_exp_mod_n (line 36) | void
FILE: tests/libquantum/gates.c
function quantum_cnot (line 46) | void
function quantum_toffoli (line 74) | void
function quantum_unbounded_toffoli (line 111) | void
function quantum_sigma_x (line 155) | void
function quantum_sigma_y (line 182) | void
function quantum_sigma_z (line 208) | void
function quantum_swaptheleads (line 229) | void
function quantum_swaptheleads_omuln_controlled (line 280) | void
function quantum_gate1 (line 295) | void
function quantum_gate2 (line 482) | void
function quantum_hadamard (line 652) | void
function quantum_walsh (line 673) | void
function quantum_r_x (line 685) | void
function quantum_r_y (line 706) | void
function quantum_r_z (line 727) | void
function quantum_phase_scale (line 751) | void
function quantum_phase_kick (line 773) | void
function quantum_cond_phase (line 795) | void
function quantum_cond_phase_inv (line 819) | void
function quantum_cond_phase_kick (line 840) | void
function quantum_gate_counter (line 866) | int
FILE: tests/libquantum/lq_complex.h
function quantum_real (line 37) | static inline float
function quantum_imag (line 46) | static inline float
function quantum_prob_inline (line 55) | static inline float
FILE: tests/libquantum/matrix.c
function quantum_memman (line 33) | unsigned long quantum_memman(long change)
function quantum_matrix (line 47) | quantum_matrix
function quantum_delete_matrix (line 73) | void
function quantum_print_matrix (line 89) | void
FILE: tests/libquantum/matrix.h
type quantum_matrix_struct (line 32) | struct quantum_matrix_struct {
type quantum_matrix (line 38) | typedef struct quantum_matrix_struct quantum_matrix;
FILE: tests/libquantum/measure.c
function quantum_frand (line 49) | double
function MAX_UNSIGNED (line 61) | MAX_UNSIGNED
function quantum_bmeasure (line 98) | int
function quantum_bmeasure_bitpreserve (line 139) | int
FILE: tests/libquantum/oaddn.c
function test_sum (line 43) | void
function muxfa (line 120) | void muxfa(int a, int b_in, int c_in, int c_out, int xlt_l,int L, int t...
function muxfa_inv (line 161) | void muxfa_inv(int a,int b_in,int c_in,int c_out, int xlt_l,int L,int t...
function muxha (line 204) | void muxha(int a,int b_in,int c_in, int xlt_l, int L,int total,quantum_...
function muxha_inv (line 232) | void muxha_inv(int a,int b_in,int c_in, int xlt_l, int L, int total,qua...
function madd (line 259) | void madd(int a,int a_inv,int width,quantum_reg *reg){
function madd_inv (line 275) | void madd_inv(int a,int a_inv,int width,quantum_reg *reg){
function addn (line 293) | void addn(int N,int a,int width, quantum_reg *reg){//add a to register r...
function addn_inv (line 300) | void addn_inv(int N,int a,int width, quantum_reg *reg){//inverse of add ...
function add_mod_n (line 310) | void add_mod_n(int N,int a,int width, quantum_reg *reg){//add a to regis...
FILE: tests/libquantum/objcode.c
function quantum_mu2char (line 58) | void
function quantum_int2char (line 74) | void
function quantum_double2char (line 90) | void
function MAX_UNSIGNED (line 100) | MAX_UNSIGNED quantum_char2mu(unsigned char *buf)
function quantum_char2int (line 113) | int quantum_char2int(unsigned char *buf)
function quantum_char2double (line 126) | double quantum_char2double(unsigned char *buf)
function quantum_objcode_start (line 136) | void
function quantum_objcode_stop (line 152) | void
function quantum_objcode_put (line 164) | int
function quantum_objcode_write (line 267) | int
function quantum_objcode_file (line 295) | void
function quantum_objcode_exit (line 304) | void
function quantum_objcode_run (line 313) | void
FILE: tests/libquantum/omuln.c
function emul (line 30) | void emul(int a, int L, int width, quantum_reg *reg){
function muln (line 38) | void muln(int N, int a, int ctl, int width, quantum_reg *reg){//ctl tell...
function muln_inv (line 57) | void muln_inv(int N, int a, int ctl, int width, quantum_reg *reg){//ctl ...
function mul_mod_n (line 75) | void mul_mod_n(int N, int a, int ctl, int width, quantum_reg *reg)
FILE: tests/libquantum/qec.c
function quantum_qec_set_status (line 46) | void
function quantum_qec_get_status (line 55) | void
function quantum_qec_encode (line 67) | void
function quantum_qec_decode (line 105) | void
function quantum_qec_counter (line 151) | int
function quantum_sigma_x_ft (line 177) | void
function quantum_cnot_ft (line 203) | void
function quantum_toffoli_ft (line 230) | void
FILE: tests/libquantum/qft.c
function quantum_qft (line 31) | void quantum_qft(int width, quantum_reg *reg)
function quantum_qft_inv (line 46) | void quantum_qft_inv(int width, quantum_reg *reg)
FILE: tests/libquantum/quantum.h
type quantum_matrix_struct (line 34) | struct quantum_matrix_struct {
type quantum_matrix (line 40) | typedef struct quantum_matrix_struct quantum_matrix;
type quantum_reg_node_struct (line 42) | struct quantum_reg_node_struct
type quantum_reg_node (line 48) | typedef struct quantum_reg_node_struct quantum_reg_node;
type quantum_reg_struct (line 52) | struct quantum_reg_struct
type quantum_reg (line 61) | typedef struct quantum_reg_struct quantum_reg;
FILE: tests/libquantum/qureg.c
function quantum_reg (line 44) | quantum_reg
function quantum_reg (line 107) | quantum_reg
function quantum_matrix (line 162) | quantum_matrix
function quantum_destroy_hash (line 178) | void
function quantum_delete_qureg (line 188) | void
function quantum_delete_qureg_hashpreserve (line 199) | void
function quantum_print_qureg (line 209) | void
function quantum_print_expn (line 234) | void
function quantum_addscratch (line 248) | void
function quantum_print_hash (line 268) | void
function quantum_reg (line 284) | quantum_reg
function quantum_reg (line 334) | quantum_reg
function COMPLEX_FLOAT (line 403) | COMPLEX_FLOAT
FILE: tests/libquantum/qureg.h
type quantum_reg_node_struct (line 35) | struct quantum_reg_node_struct
type quantum_reg_node (line 41) | typedef struct quantum_reg_node_struct quantum_reg_node;
type quantum_reg_struct (line 45) | struct quantum_reg_struct
type quantum_reg (line 54) | typedef struct quantum_reg_struct quantum_reg;
function quantum_hash64 (line 79) | static inline unsigned int
function quantum_get_state (line 94) | static inline int
function quantum_add_hash (line 116) | static inline void
FILE: tests/libquantum/shor.c
function main (line 44) | int main(int argc, char **argv) {
FILE: tests/libquantum/specrand.c
function spec_srand (line 16) | void spec_srand(int seed) {
FILE: tests/perlbench/Base64.c
function XS (line 123) | XS(XS_MIME__Base64_encode_base64)
function XS (line 212) | XS(XS_MIME__Base64_decode_base64)
function XS (line 286) | XS(XS_MIME__QuotedPrint_encode_qp)
function XS (line 410) | XS(XS_MIME__QuotedPrint_decode_qp)
function XS (line 496) | XS(boot_MIME__Base64)
FILE: tests/perlbench/Cwd.c
type stat (line 141) | struct stat
function Perl_getcwd_sv (line 255) | int Perl_getcwd_sv(pTHX_ register SV *sv)
function XS (line 406) | XS(XS_Cwd_fastcwd)
function XS (line 430) | XS(XS_Cwd_abs_path)
function XS (line 475) | XS(XS_Cwd_getdcwd)
function XS (line 523) | XS(boot_Cwd)
FILE: tests/perlbench/Dumper.c
function UV (line 34) | UV
function I32 (line 60) | static I32
function I32 (line 87) | static I32
function I32 (line 105) | static I32
function I32 (line 125) | static I32
function SV (line 215) | static SV *
function I32 (line 246) | static I32
function XS (line 919) | XS(XS_Data__Dumper_Dumpxs)
function XS (line 1154) | XS(boot_Data__Dumper)
FILE: tests/perlbench/DynaLoader.c
function XS (line 21) | XS(XS_DynaLoader_dl_error)
function XS (line 41) | XS(boot_DynaLoader)
FILE: tests/perlbench/HiRes.c
type FT_t (line 82) | typedef union {
type my_cxt_t (line 89) | typedef struct {
function _gettimeofday (line 125) | static int
function sleep (line 167) | static unsigned int
type dsc$descriptor_s (line 220) | struct dsc$descriptor_s
type dsc$descriptor_s (line 222) | struct dsc$descriptor_s
function time_t (line 224) | static time_t toutc_dst(time_t loc) {
function time_t (line 233) | static time_t toloc_dst(time_t utc) {
function timezone_setup (line 252) | static int
type timeval (line 292) | struct timeval
function hrt_unanosleep (line 369) | void
function hrt_usleep (line 385) | void
function hrt_usleep (line 401) | void
function hrt_ualarm (line 415) | int
function us_to_VMS (line 441) | static void
function VMS_to_us (line 463) | static int
type word (line 475) | typedef unsigned short word;
type Alarm (line 476) | typedef struct _ualarm {
function vms_ualarm (line 493) | static int
function ualarm_AST (line 561) | static void
function myU2time (line 626) | static int
function NV (line 637) | static NV
function XS (line 656) | XS(XS_Time__HiRes_CLONE)
function XS (line 672) | XS(XS_Time__HiRes_constant)
function XS (line 778) | XS(XS_Time__HiRes_usleep)
function XS (line 823) | XS(XS_Time__HiRes_nanosleep)
function XS (line 863) | XS(XS_Time__HiRes_sleep)
function XS (line 915) | XS(XS_Time__HiRes_ualarm)
function XS (line 943) | XS(XS_Time__HiRes_alarm)
function XS (line 977) | XS(XS_Time__HiRes_gettimeofday)
function XS (line 1010) | XS(XS_Time__HiRes_time)
function XS (line 1037) | XS(XS_Time__HiRes_gettimeofday)
function XS (line 1066) | XS(XS_Time__HiRes_time)
function XS (line 1094) | XS(XS_Time__HiRes_setitimer)
function XS (line 1138) | XS(XS_Time__HiRes_getitimer)
function XS (line 1169) | XS(boot_Time__HiRes)
FILE: tests/perlbench/Hostname.c
function XS (line 36) | XS(XS_Sys__Hostname_ghname)
function XS (line 105) | XS(boot_Sys__Hostname)
FILE: tests/perlbench/IO.c
type SysRet (line 45) | typedef int SysRet;
type PerlIO (line 46) | typedef PerlIO * InputStream;
type PerlIO (line 47) | typedef PerlIO * OutputStream;
type SysRet (line 50) | typedef int SysRet;
type FILE (line 51) | typedef FILE * InputStream;
type FILE (line 52) | typedef FILE * OutputStream;
function not_here (line 61) | static int
function io_blocking (line 73) | static int
function XS (line 131) | XS(XS_IO__Seekable_getpos)
function XS (line 163) | XS(XS_IO__Seekable_setpos)
function XS (line 205) | XS(XS_IO__File_new_tmpfile)
function XS (line 245) | XS(XS_IO__Poll__poll)
function XS (line 286) | XS(XS_IO__Handle_blocking)
function XS (line 314) | XS(XS_IO__Handle_ungetc)
function XS (line 342) | XS(XS_IO__Handle_error)
function XS (line 369) | XS(XS_IO__Handle_clearerr)
function XS (line 398) | XS(XS_IO__Handle_untaint)
function XS (line 429) | XS(XS_IO__Handle_flush)
function XS (line 461) | XS(XS_IO__Handle_setbuf)
function XS (line 485) | XS(XS_IO__Handle_setvbuf)
function XS (line 531) | XS(XS_IO__Handle_sync)
function XS (line 563) | XS(XS_IO__Socket_sockatmark)
function XS (line 612) | XS(boot_IO)
FILE: tests/perlbench/MD5.c
function u2s (line 133) | static void u2s(U32 u, U8* s)
type MD5_CTX (line 151) | typedef struct {
function MD5Init (line 233) | static void
function MD5Transform (line 247) | static void
function MD5Update (line 397) | static void
function MD5Final (line 434) | static void
function MD5_CTX (line 478) | static MD5_CTX* get_md5_ctx(pTHX_ SV* sv)
function SV (line 539) | static SV* make_mortal_sv(pTHX_ const unsigned char *src, int type)
type PerlIO (line 568) | typedef PerlIO* InputStream;
function XS (line 572) | XS(XS_Digest__MD5_new)
function XS (line 604) | XS(XS_Digest__MD5_clone)
function XS (line 632) | XS(XS_Digest__MD5_DESTROY)
function XS (line 647) | XS(XS_Digest__MD5_add)
function XS (line 674) | XS(XS_Digest__MD5_addfile)
function XS (line 721) | XS(XS_Digest__MD5_digest)
function XS (line 745) | XS(XS_Digest__MD5_md5)
function XS (line 803) | XS(boot_Digest__MD5)
FILE: tests/perlbench/Opcode.c
type my_cxt_t (line 21) | typedef struct {
function op_names_init (line 50) | static void
function put_op_bitspec (line 86) | static void
function SV (line 109) | static SV *
function SV (line 134) | static SV *
function verify_opset (line 155) | static int
function set_opset_bits (line 171) | static void
function opmask_add (line 207) | static void
function opmask_addlocal (line 235) | static void
function XS (line 259) | XS(XS_Opcode__safe_pkg_prep)
function XS (line 287) | XS(XS_Opcode__safe_call_sv)
function XS (line 339) | XS(XS_Opcode_verify_opset)
function XS (line 364) | XS(XS_Opcode_invert_opset)
function XS (line 392) | XS(XS_Opcode_opset_to_ops)
function XS (line 431) | XS(XS_Opcode_opset)
function XS (line 466) | XS(XS_Opcode_permit_only)
function XS (line 510) | XS(XS_Opcode_opdesc)
function XS (line 558) | XS(XS_Opcode_define_optag)
function XS (line 578) | XS(XS_Opcode_empty_opset)
function XS (line 592) | XS(XS_Opcode_full_opset)
function XS (line 607) | XS(XS_Opcode_opmask_add)
function XS (line 626) | XS(XS_Opcode_opcodes)
function XS (line 648) | XS(XS_Opcode_opmask)
function XS (line 673) | XS(boot_Opcode)
FILE: tests/perlbench/Parser.c
function SV (line 58) | static SV *
function SV (line 132) | static SV*
function PSTATE (line 147) | static PSTATE*
function PSTATE (line 157) | static PSTATE*
function free_pstate (line 179) | static void
function magic_free_pstate (line 207) | static int
function XS (line 225) | XS(XS_HTML__Parser__alloc_pstate)
function XS (line 264) | XS(XS_HTML__Parser_parse)
function XS (line 327) | XS(XS_HTML__Parser_eof)
function XS (line 354) | XS(XS_HTML__Parser_strict_comment)
function XS (line 401) | XS(XS_HTML__Parser_boolean_attribute_value)
function XS (line 424) | XS(XS_HTML__Parser_ignore_tags)
function XS (line 487) | XS(XS_HTML__Parser_handler)
function XS (line 544) | XS(XS_HTML__Entities_decode_entities)
function XS (line 572) | XS(XS_HTML__Entities__decode_entities)
function XS (line 605) | XS(XS_HTML__Entities__probably_utf8_chunk)
function XS (line 633) | XS(XS_HTML__Entities_UNICODE_SUPPORT)
function XS (line 657) | XS(boot_HTML__Parser)
FILE: tests/perlbench/Peek.c
function _runops_debug (line 15) | bool
function SV (line 27) | SV *
type mstats_buffer (line 153) | struct mstats_buffer
function _fill_mstats (line 159) | void
function fill_mstats (line 171) | void
function _mstats_to_hv (line 185) | void
function mstats_fillhash (line 283) | void
function mstats2hash (line 293) | void
function fill_mstats (line 305) | void
function mstats_fillhash (line 310) | void
function mstats2hash (line 315) | void
function XS (line 328) | XS(XS_Devel__Peek_mstat)
function XS (line 348) | XS(XS_Devel__Peek_fill_mstats)
function XS (line 369) | XS(XS_Devel__Peek_mstats_fillhash)
function XS (line 390) | XS(XS_Devel__Peek_mstats2hash)
function XS (line 412) | XS(XS_Devel__Peek_Dump)
function XS (line 445) | XS(XS_Devel__Peek_DumpArray)
function XS (line 476) | XS(XS_Devel__Peek_DumpProg)
function XS (line 497) | XS(XS_Devel__Peek_SvREFCNT)
function XS (line 514) | XS(XS_Devel__Peek_SvREFCNT_inc)
function XS (line 535) | XS(XS_Devel__Peek_SvREFCNT_dec)
function XS (line 555) | XS(XS_Devel__Peek_DeadCode)
function XS (line 572) | XS(XS_Devel__Peek_CvGV)
function XS (line 589) | XS(XS_Devel__Peek_runops_debug)
function XS (line 615) | XS(boot_Devel__Peek)
FILE: tests/perlbench/Storable.c
type NV (line 88) | typedef double NV;
type extendable (line 220) | struct extendable {
type stag_t (line 243) | typedef unsigned long stag_t;
type stcxt_t (line 301) | typedef struct stcxt {
function init_perinterp (line 1164) | static void init_perinterp(pTHX)
function reset_context (line 1178) | static void reset_context(stcxt_t *cxt)
function init_store_context (line 1190) | static void init_store_context(
function clean_store_context (line 1286) | static void clean_store_context(pTHX_ stcxt_t *cxt)
function init_retrieve_context (line 1364) | static void init_retrieve_context(pTHX_ stcxt_t *cxt, int optype, int is...
function clean_retrieve_context (line 1411) | static void clean_retrieve_context(pTHX_ stcxt_t *cxt)
function clean_context (line 1462) | static void clean_context(pTHX_ stcxt_t *cxt)
function stcxt_t (line 1490) | static stcxt_t *allocate_context(pTHX_ stcxt_t *parent_cxt)
function free_context (line 1513) | static void free_context(pTHX_ stcxt_t *cxt)
function is_storing (line 1537) | int is_storing(pTHX)
function is_retrieving (line 1549) | int is_retrieving(pTHX)
function last_op_in_netorder (line 1564) | int last_op_in_netorder(pTHX)
function SV (line 1583) | static SV *pkg_fetchmeth(
function pkg_hide (line 1621) | static void pkg_hide(
function pkg_uncache (line 1636) | static void pkg_uncache(
function SV (line 1653) | static SV *pkg_can(
function SV (line 1695) | static SV *scalar_call(
function AV (line 1752) | static AV *array_call(
function known_class (line 1798) | static int known_class(
function store_ref (line 1843) | static int store_ref(pTHX_ stcxt_t *cxt, SV *sv)
function store_scalar (line 1877) | static int store_scalar(pTHX_ stcxt_t *cxt, SV *sv)
function store_array (line 2083) | static int store_array(pTHX_ stcxt_t *cxt, AV *av)
function sortcmp (line 2130) | static int
function store_hash (line 2163) | static int store_hash(pTHX_ stcxt_t *cxt, HV *hv)
function store_code (line 2490) | static int store_code(pTHX_ stcxt_t *cxt, CV *cv)
function store_tied (line 2594) | static int store_tied(pTHX_ stcxt_t *cxt, SV *sv)
function store_tied_item (line 2665) | static int store_tied_item(pTHX_ stcxt_t *cxt, SV *sv)
function store_hook (line 2756) | static int store_hook(
function store_blessed (line 3154) | static int store_blessed(
function store_other (line 3236) | static int store_other(pTHX_ stcxt_t *cxt, SV *sv)
function sv_type (line 3283) | static int sv_type(pTHX_ SV *sv)
function store (line 3343) | static int store(pTHX_ stcxt_t *cxt, SV *sv)
function magic_write (line 3458) | static int magic_write(pTHX_ stcxt_t *cxt)
function do_store (line 3554) | static int do_store(
function pstore (line 3672) | int pstore(pTHX_ PerlIO *f, SV *sv)
function net_pstore (line 3685) | int net_pstore(pTHX_ PerlIO *f, SV *sv)
function SV (line 3700) | static SV *mbuf2sv(pTHX)
function SV (line 3713) | SV *mstore(pTHX_ SV *sv)
function SV (line 3731) | SV *net_mstore(pTHX_ SV *sv)
function SV (line 3753) | static SV *retrieve_other(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 3778) | static SV *retrieve_idx_blessed(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 3819) | static SV *retrieve_blessed(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 3885) | static SV *retrieve_hook(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4261) | static SV *retrieve_ref(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4321) | static SV *retrieve_overloaded(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4390) | static SV *retrieve_tied_array(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4419) | static SV *retrieve_tied_hash(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4447) | static SV *retrieve_tied_scalar(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4483) | static SV *retrieve_tied_key(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4515) | static SV *retrieve_tied_idx(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4548) | static SV *retrieve_lscalar(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4594) | static SV *retrieve_scalar(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4653) | static SV *retrieve_utf8str(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4682) | static SV *retrieve_lutf8str(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4710) | static SV *retrieve_integer(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4733) | static SV *retrieve_netint(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4761) | static SV *retrieve_double(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4784) | static SV *retrieve_byte(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4809) | static SV *retrieve_undef(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4826) | static SV *retrieve_sv_undef(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4847) | static SV *retrieve_sv_yes(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4862) | static SV *retrieve_sv_no(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4881) | static SV *retrieve_array(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 4932) | static SV *retrieve_hash(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 5006) | static SV *retrieve_flag_hash(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 5142) | static SV *retrieve_code(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 5263) | static SV *old_retrieve_array(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 5323) | static SV *old_retrieve_hash(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 5420) | static SV *magic_check(pTHX_ stcxt_t *cxt)
function SV (line 5595) | static SV *retrieve(pTHX_ stcxt_t *cxt, char *cname)
function SV (line 5754) | static SV *do_retrieve(
function SV (line 5987) | SV *pretrieve(pTHX_ PerlIO *f)
function SV (line 5998) | SV *mretrieve(pTHX_ SV *sv)
function SV (line 6017) | SV *dclone(pTHX_ SV *sv)
function XS (line 6098) | XS(XS_Storable__Cxt_DESTROY)
function XS (line 6123) | XS(XS_Storable_init_perinterp)
function XS (line 6137) | XS(XS_Storable_pstore)
function XS (line 6156) | XS(XS_Storable_net_pstore)
function XS (line 6175) | XS(XS_Storable_mstore)
function XS (line 6193) | XS(XS_Storable_net_mstore)
function XS (line 6211) | XS(XS_Storable_pretrieve)
function XS (line 6229) | XS(XS_Storable_mretrieve)
function XS (line 6247) | XS(XS_Storable_dclone)
function XS (line 6265) | XS(XS_Storable_last_op_in_netorder)
function XS (line 6282) | XS(XS_Storable_is_storing)
function XS (line 6299) | XS(XS_Storable_is_retrieving)
function XS (line 6319) | XS(boot_Storable)
FILE: tests/perlbench/attrs.c
function cv_flags_t (line 15) | static cv_flags_t
function XS (line 28) | XS(XS_attrs_import)
function XS (line 65) | XS(XS_attrs_get)
function XS (line 100) | XS(boot_attrs)
FILE: tests/perlbench/av.c
function Perl_av_reify (line 24) | void
function Perl_av_extend (line 61) | void
function SV (line 187) | SV**
function SV (line 273) | SV**
function AV (line 355) | AV *
function AV (line 379) | AV *
function AV (line 405) | AV *
function Perl_av_clear (line 437) | void
function Perl_av_undef (line 489) | void
function Perl_av_push (line 526) | void
function SV (line 561) | SV *
function Perl_av_unshift (line 606) | void
function SV (line 677) | SV *
function I32 (line 725) | I32
function Perl_av_fill (line 739) | void
function SV (line 795) | SV *
function Perl_av_exists (line 882) | bool
function STATIC (line 943) | STATIC I32
function STATIC (line 952) | STATIC I32
function HV (line 966) | HV*
function SV (line 987) | SV**
function SV (line 993) | SV**
function SV (line 999) | SV *
function Perl_avhv_exists_ent (line 1015) | bool
function HE (line 1028) | HE *
function SV (line 1035) | SV *
FILE: tests/perlbench/av.h
type xpvav (line 11) | struct xpvav {
FILE: tests/perlbench/cop.h
type cop (line 16) | struct cop {
type block_sub (line 112) | struct block_sub {
type block_eval (line 211) | struct block_eval {
type block_loop (line 240) | struct block_loop {
type block (line 304) | struct block {
type subst (line 366) | struct subst {
type context (line 418) | struct context {
type stackinfo (line 524) | struct stackinfo {
type PERL_SI (line 537) | typedef struct stackinfo PERL_SI;
FILE: tests/perlbench/cv.h
type xpvcv (line 14) | struct xpvcv {
FILE: tests/perlbench/deb.c
function Perl_deb_nocontext (line 26) | void
function Perl_deb (line 39) | void
function Perl_vdeb (line 50) | void
function I32 (line 69) | I32
function STATIC (line 97) | STATIC void
function I32 (line 138) | I32
function Perl_deb_stack_all (line 177) | void
FILE: tests/perlbench/doio.c
function Perl_do_open (line 61) | bool
function Perl_do_open9 (line 69) | bool
function Perl_do_openn (line 78) | bool
function PerlIO (line 743) | PerlIO *
function Perl_do_pipe (line 960) | void
function Perl_do_close (line 1006) | bool
function Perl_io_close (line 1038) | bool
function Perl_do_eof (line 1077) | bool
function Off_t (line 1121) | Off_t
function Perl_do_seek (line 1140) | bool
function Off_t (line 1159) | Off_t
function Perl_mode_from_discipline (line 1173) | int
function Perl_do_binmode (line 1229) | int
function I32 (line 1244) | I32 my_chsize(fd, length)
function Perl_do_print (line 1299) | bool
function I32 (line 1364) | I32
function I32 (line 1418) | I32
function Perl_do_aexec (line 1455) | bool
function PERL_FPU_POST_EXEC (line 1493) | PERL_FPU_POST_EXEC
function Perl_do_exec3 (line 1530) | bool
function I32 (line 1661) | I32
function Perl_cando (line 1874) | bool
function Perl_ingroup (line 1928) | bool
function I32 (line 1957) | I32
function I32 (line 1989) | I32
function I32 (line 2112) | I32
function I32 (line 2134) | I32
function I32 (line 2171) | I32
function I32 (line 2224) | I32
function PerlIO (line 2295) | PerlIO *
FILE: tests/perlbench/doop.c
function STATIC (line 28) | STATIC I32
function STATIC (line 98) | STATIC I32
function STATIC (line 136) | STATIC I32
function STATIC (line 298) | STATIC I32
function STATIC (line 397) | STATIC I32
function STATIC (line 437) | STATIC I32
function I32 (line 599) | I32
function Perl_do_join (line 647) | void
function Perl_do_sprintf (line 703) | void
function UV (line 720) | UV
function Perl_do_vecset (line 858) | void
function Perl_do_chop (line 939) | void
function I32 (line 1008) | I32
function Perl_do_vop (line 1145) | void
function OP (line 1336) | OP *
FILE: tests/perlbench/dump.c
function Perl_dump_indent (line 28) | void
function Perl_dump_vindent (line 37) | void
function Perl_dump_all (line 44) | void
function Perl_dump_packsubs (line 53) | void
function Perl_dump_sub (line 78) | void
function Perl_dump_form (line 95) | void
function Perl_dump_eval (line 108) | void
function Perl_do_pmop_dump (line 334) | void
function Perl_pmop_dump (line 394) | void
function Perl_do_op_dump (line 400) | void
function Perl_op_dump (line 743) | void
function Perl_gv_dump (line 749) | void
function Perl_do_magic_dump (line 819) | void
function Perl_magic_dump (line 937) | void
function Perl_do_hv_dump (line 943) | void
function Perl_do_gv_dump (line 953) | void
function Perl_do_gvgv_dump (line 963) | void
function Perl_do_sv_dump (line 977) | void
function Perl_sv_dump (line 1416) | void
function Perl_runops_debug (line 1422) | int
function I32 (line 1458) | I32
function STATIC (line 1507) | STATIC CV*
function Perl_watch (line 1523) | void
function STATIC (line 1532) | STATIC void
function Perl_debprofdump (line 1542) | void
FILE: tests/perlbench/fakethr.h
type perl_mutex (line 10) | typedef int perl_mutex;
type perl_key (line 11) | typedef int perl_key;
type perl_thread (line 13) | struct perl_thread
type perl_wait_queue (line 17) | struct perl_wait_queue {
type perl_wait_queue (line 21) | struct perl_wait_queue
type thread_intern (line 25) | struct thread_intern {
FILE: tests/perlbench/globals.c
function Perl_fprintf_nocontext (line 37) | int
function Perl_printf_nocontext (line 46) | int
FILE: tests/perlbench/gv.c
function GV (line 37) | GV *
function GV (line 47) | GV *
function GV (line 57) | GV *
function GV (line 73) | GV *
function Perl_gv_init (line 105) | void
function STATIC (line 160) | STATIC void
function GV (line 197) | GV *
function GV (line 339) | GV *
function GV (line 378) | GV *
function GV (line 412) | GV *
function GV (line 487) | GV*
function STATIC (line 570) | STATIC void
function HV (line 601) | HV*
function HV (line 619) | HV*
function HV (line 657) | HV*
function GV (line 667) | GV *
function Perl_gv_fullname4 (line 1118) | void
function Perl_gv_fullname3 (line 1140) | void
function Perl_gv_efullname4 (line 1146) | void
function Perl_gv_efullname3 (line 1155) | void
function Perl_gv_fullname (line 1162) | void
function Perl_gv_efullname (line 1169) | void
function IO (line 1175) | IO *
function Perl_gv_check (line 1196) | void
function GV (line 1247) | GV *
function GP (line 1256) | GP*
function Perl_gp_free (line 1277) | void
function Perl_magic_freeovrld (line 1318) | int
function Perl_Gv_AMupdate (line 1337) | bool
function CV (line 1456) | CV*
function SV (line 1494) | SV*
function Perl_is_gv_magical (line 1853) | bool
FILE: tests/perlbench/gv.h
type gp (line 11) | struct gp {
FILE: tests/perlbench/handy.h
type bool (line 74) | enum bool { FALSE = 0, TRUE = 1 }
type I8TYPE (line 132) | typedef I8TYPE I8;
type U8TYPE (line 133) | typedef U8TYPE U8;
type I16TYPE (line 134) | typedef I16TYPE I16;
type U16TYPE (line 135) | typedef U16TYPE U16;
type I32TYPE (line 136) | typedef I32TYPE I32;
type U32TYPE (line 137) | typedef U32TYPE U32;
type I64TYPE (line 140) | typedef I64TYPE I64;
type U64TYPE (line 141) | typedef U64TYPE U64;
type U32 (line 521) | typedef U32 line_t;
FILE: tests/perlbench/hctype.h
type hctype_t (line 19) | typedef unsigned char hctype_t;
FILE: tests/perlbench/hparser.c
type literal_tag (line 19) | struct literal_tag {
type argcode (line 35) | enum argcode {
function report_event (line 112) | static void
function EXTERN (line 656) | EXTERN SV*
function flush_pending_text (line 775) | static void
function marked_section_update (line 940) | static void
function EXTERN (line 1692) | EXTERN void
FILE: tests/perlbench/hparser.h
type marked_section_t (line 18) | enum marked_section_t {
type event_id (line 31) | enum event_id {
type event_id_t (line 45) | typedef enum event_id event_id_t;
type p_handler (line 60) | struct p_handler {
type p_state (line 65) | struct p_state {
type PSTATE (line 128) | typedef struct p_state PSTATE;
FILE: tests/perlbench/hv.c
function STATIC (line 36) | STATIC HE*
function STATIC (line 49) | STATIC void
function STATIC (line 58) | STATIC void
function STATIC (line 90) | STATIC HEK *
function Perl_free_tied_hv_pool (line 113) | void
function HE (line 128) | HE *
function S_hv_notallowed (line 162) | static void
function SV (line 216) | SV**
function SV (line 235) | SV**
function HE (line 273) | HE *
function Perl_hv_exists (line 288) | bool
function SV (line 319) | SV**
function Perl_hv_exists_ent (line 349) | bool
function HE (line 375) | HE *
function STATIC (line 382) | STATIC HE *
function STATIC (line 796) | STATIC void
function SV (line 823) | SV *
function SV (line 855) | SV *
function SV (line 881) | SV *
function STATIC (line 887) | STATIC SV *
function STATIC (line 1062) | STATIC void
function Perl_hv_ksplit (line 1216) | void
function HV (line 1303) | HV *
function HV (line 1325) | HV *
function Perl_hv_free_ent (line 1403) | void
function Perl_hv_delayfree_ent (line 1425) | void
function Perl_hv_clear (line 1452) | void
function Perl_hv_clear_placeholders (line 1514) | void
function STATIC (line 1561) | STATIC void
function Perl_hv_undef (line 1609) | void
function I32 (line 1647) | I32
function HE (line 1682) | HE *
function HE (line 1703) | HE *
function SV (line 1840) | SV *
function SV (line 1887) | SV *
function SV (line 1911) | SV *
function Perl_hv_magic (line 1929) | void
function Perl_unsharepvn (line 1948) | void
function Perl_unshare_hek (line 1955) | void
function STATIC (line 1965) | STATIC void
function HEK (line 2050) | HEK *
function STATIC (line 2077) | STATIC HEK *
FILE: tests/perlbench/hv.h
type HE (line 12) | typedef struct he HE;
type HEK (line 13) | typedef struct hek HEK;
type he (line 16) | struct he {
type hek (line 23) | struct hek {
type xpvhv (line 34) | struct xpvhv {
FILE: tests/perlbench/iperlsys.h
type Signal_t (line 54) | typedef Signal_t (*Sighandler_t) (int);
type IPerlStdIO (line 60) | struct IPerlStdIO
type IPerlStdIOInfo (line 61) | struct IPerlStdIOInfo
type FILE (line 62) | typedef FILE* (*LPStdin)(struct IPerlStdIO*);
type FILE (line 63) | typedef FILE* (*LPStdout)(struct IPerlStdIO*);
type FILE (line 64) | typedef FILE* (*LPStderr)(struct IPerlStdIO*);
type FILE (line 65) | typedef FILE* (*LPOpen)(struct IPerlStdIO*, const char*,
type IPerlStdIO (line 67) | struct IPerlStdIO
type IPerlStdIO (line 68) | struct IPerlStdIO
type IPerlStdIO (line 69) | struct IPerlStdIO
type IPerlStdIO (line 70) | struct IPerlStdIO
type IPerlStdIO (line 71) | struct IPerlStdIO
type IPerlStdIO (line 72) | struct IPerlStdIO
type IPerlStdIO (line 73) | struct IPerlStdIO
type IPerlStdIO (line 74) | struct IPerlStdIO
type IPerlStdIO (line 75) | struct IPerlStdIO
type IPerlStdIO (line 76) | struct IPerlStdIO
type IPerlStdIO (line 77) | struct IPerlStdIO
type IPerlStdIO (line 78) | struct IPerlStdIO
type IPerlStdIO (line 79) | struct IPerlStdIO
type IPerlStdIO (line 80) | struct IPerlStdIO
type IPerlStdIO (line 81) | struct IPerlStdIO
type FILE (line 82) | typedef FILE* (*LPFdopen)(struct IPerlStdIO*, int, const char*);
type FILE (line 83) | typedef FILE* (*LPReopen)(struct IPerlStdIO*, const char*,
type SSize_t (line 85) | typedef SSize_t (*LPRead)(struct IPerlStdIO*, void*, Size_t, Size_t, FI...
type SSize_t (line 86) | typedef SSize_t (*LPWrite)(struct IPerlStdIO*, const void*, Size_t, Siz...
type IPerlStdIO (line 87) | struct IPerlStdIO
type IPerlStdIO (line 88) | struct IPerlStdIO
type IPerlStdIO (line 90) | struct IPerlStdIO
type IPerlStdIO (line 93) | struct IPerlStdIO
type IPerlStdIO (line 95) | struct IPerlStdIO
type IPerlStdIO (line 98) | struct IPerlStdIO
type IPerlStdIO (line 99) | struct IPerlStdIO
type IPerlStdIO (line 101) | struct IPerlStdIO
type Off_t (line 103) | typedef Off_t (*LPTell)(struct IPerlStdIO*, FILE*);
type IPerlStdIO (line 104) | struct IPerlStdIO
type IPerlStdIO (line 105) | struct IPerlStdIO
type FILE (line 106) | typedef FILE* (*LPTmpfile)(struct IPerlStdIO*);
type IPerlStdIO (line 107) | struct IPerlStdIO
type IPerlStdIO (line 108) | struct IPerlStdIO
type IPerlStdIO (line 110) | struct IPerlStdIO
type IPerlStdIO (line 111) | struct IPerlStdIO
type FILE (line 112) | typedef FILE* (*LPFdupopen)(struct IPerlStdIO*, FILE*);
type IPerlStdIO (line 114) | struct IPerlStdIO
type IPerlStdIOInfo (line 157) | struct IPerlStdIOInfo
type IPerlDir (line 363) | struct IPerlDir
type IPerlDirInfo (line 364) | struct IPerlDirInfo
type IPerlDir (line 365) | struct IPerlDir
type IPerlDir (line 366) | struct IPerlDir
type IPerlDir (line 367) | struct IPerlDir
type IPerlDir (line 368) | struct IPerlDir
type DIR (line 369) | typedef DIR* (*LPDirOpen)(struct IPerlDir*, char*);
type direct (line 370) | struct direct
type IPerlDir (line 370) | struct IPerlDir
type IPerlDir (line 371) | struct IPerlDir
type IPerlDir (line 372) | struct IPerlDir
type IPerlDir (line 373) | struct IPerlDir
type IPerlDir (line 375) | struct IPerlDir
type WCHAR (line 376) | typedef WCHAR* (*LPDirMapPathW)(struct IPerlDir*, const WCHAR*);
type IPerlDir (line 379) | struct IPerlDir
type IPerlDirInfo (line 396) | struct IPerlDirInfo
type IPerlEnv (line 456) | struct IPerlEnv
type IPerlEnvInfo (line 457) | struct IPerlEnvInfo
type IPerlEnv (line 458) | struct IPerlEnv
type IPerlEnv (line 459) | struct IPerlEnv
type IPerlEnv (line 460) | struct IPerlEnv
type IPerlEnv (line 462) | struct IPerlEnv
type utsname (line 462) | struct utsname
type IPerlEnv (line 463) | struct IPerlEnv
type IPerlEnv (line 464) | struct IPerlEnv
type IPerlEnv (line 465) | struct IPerlEnv
type IPerlEnv (line 466) | struct IPerlEnv
type IPerlEnv (line 467) | struct IPerlEnv
type IPerlEnv (line 469) | struct IPerlEnv
type IPerlEnv (line 470) | struct IPerlEnv
type IPerlEnv (line 474) | struct IPerlEnv
type IPerlEnv (line 475) | struct IPerlEnv
type IPerlEnv (line 476) | struct IPerlEnv
type IPerlEnv (line 477) | struct IPerlEnv
type IPerlEnv (line 478) | struct IPerlEnv
type IPerlEnv (line 481) | struct IPerlEnv
type IPerlEnvInfo (line 505) | struct IPerlEnvInfo
type IPerlLIO (line 595) | struct IPerlLIO
type IPerlLIOInfo (line 596) | struct IPerlLIOInfo
type IPerlLIO (line 597) | struct IPerlLIO
type IPerlLIO (line 598) | struct IPerlLIO
type IPerlLIO (line 599) | struct IPerlLIO
type IPerlLIO (line 601) | struct IPerlLIO
type IPerlLIO (line 602) | struct IPerlLIO
type IPerlLIO (line 603) | struct IPerlLIO
type IPerlLIO (line 604) | struct IPerlLIO
type IPerlLIO (line 605) | struct IPerlLIO
type IPerlLIO (line 606) | struct IPerlLIO
type IPerlLIO (line 607) | struct IPerlLIO
type IPerlLIO (line 609) | struct IPerlLIO
type IPerlLIO (line 610) | struct IPerlLIO
type Off_t (line 612) | typedef Off_t (*LPLIOLseek)(struct IPerlLIO*, int, Off_t, int);
type IPerlLIO (line 613) | struct IPerlLIO
type IPerlLIO (line 615) | struct IPerlLIO
type IPerlLIO (line 616) | struct IPerlLIO
type IPerlLIO (line 617) | struct IPerlLIO
type IPerlLIO (line 618) | struct IPerlLIO
type IPerlLIO (line 619) | struct IPerlLIO
type IPerlLIO (line 622) | struct IPerlLIO
type IPerlLIO (line 624) | struct IPerlLIO
type IPerlLIO (line 626) | struct IPerlLIO
type IPerlLIO (line 628) | struct IPerlLIO
type IPerlLIO (line 629) | struct IPerlLIO
type IPerlLIO (line 630) | struct IPerlLIO
type IPerlLIO (line 631) | struct IPerlLIO
type utimbuf (line 631) | struct utimbuf
type IPerlLIO (line 632) | struct IPerlLIO
type IPerlLIO (line 635) | struct IPerlLIO
type IPerlLIOInfo (line 665) | struct IPerlLIOInfo
type IPerlMem (line 773) | struct IPerlMem
type IPerlMemInfo (line 774) | struct IPerlMemInfo
type IPerlMem (line 775) | struct IPerlMem
type IPerlMem (line 776) | struct IPerlMem
type IPerlMem (line 777) | struct IPerlMem
type IPerlMem (line 778) | struct IPerlMem
type IPerlMem (line 779) | struct IPerlMem
type IPerlMem (line 780) | struct IPerlMem
type IPerlMem (line 781) | struct IPerlMem
type IPerlMem (line 783) | struct IPerlMem
type IPerlMemInfo (line 794) | struct IPerlMemInfo
type IPerlProc (line 913) | struct IPerlProc
type IPerlProcInfo (line 914) | struct IPerlProcInfo
type IPerlProc (line 915) | struct IPerlProc
type IPerlProc (line 916) | struct IPerlProc
type IPerlProc (line 918) | struct IPerlProc
type IPerlProc (line 919) | struct IPerlProc
type IPerlProc (line 920) | struct IPerlProc
type IPerlProc (line 923) | struct IPerlProc
type IPerlProc (line 925) | struct IPerlProc
type uid_t (line 927) | typedef uid_t (*LPProcGetuid)(struct IPerlProc*);
type uid_t (line 928) | typedef uid_t (*LPProcGeteuid)(struct IPerlProc*);
type gid_t (line 929) | typedef gid_t (*LPProcGetgid)(struct IPerlProc*);
type gid_t (line 930) | typedef gid_t (*LPProcGetegid)(struct IPerlProc*);
type IPerlProc (line 931) | struct IPerlProc
type IPerlProc (line 932) | struct IPerlProc
type IPerlProc (line 933) | struct IPerlProc
type IPerlProc (line 934) | struct IPerlProc
type PerlIO (line 935) | typedef PerlIO* (*LPProcPopen)(struct IPerlProc*, const char*,
type PerlIO (line 937) | typedef PerlIO* (*LPProcPopenList)(struct IPerlProc*, const char*,
type IPerlProc (line 939) | struct IPerlProc
type IPerlProc (line 940) | struct IPerlProc
type IPerlProc (line 941) | struct IPerlProc
type IPerlProc (line 942) | struct IPerlProc
type IPerlProc (line 943) | struct IPerlProc
type IPerlProc (line 944) | struct IPerlProc
type tms (line 944) | struct tms
type IPerlProc (line 945) | struct IPerlProc
type IPerlProc (line 946) | struct IPerlProc
type Sighandler_t (line 947) | typedef Sighandler_t (*LPProcSignal)(struct IPerlProc*, int, Sighandler_t);
type IPerlProc (line 948) | struct IPerlProc
type IPerlProc (line 949) | struct IPerlProc
type IPerlProc (line 951) | struct IPerlProc
type IPerlProc (line 952) | struct IPerlProc
type IPerlProc (line 954) | struct IPerlProc
type IPerlProc (line 957) | struct IPerlProc
type IPerlProc (line 958) | struct IPerlProc
type timeval (line 959) | struct timeval
type IPerlProc (line 961) | struct IPerlProc
type IPerlProcInfo (line 1000) | struct IPerlProcInfo
type IPerlSock (line 1132) | struct IPerlSock
type IPerlSockInfo (line 1133) | struct IPerlSockInfo
type u_long (line 1134) | typedef u_long (*LPHtonl)(struct IPerlSock*, u_long);
type u_short (line 1135) | typedef u_short (*LPHtons)(struct IPerlSock*, u_short);
type u_long (line 1136) | typedef u_long (*LPNtohl)(struct IPerlSock*, u_long);
type u_short (line 1137) | typedef u_short (*LPNtohs)(struct IPerlSock*, u_short);
type SOCKET (line 1138) | typedef SOCKET (*LPAccept)(struct IPerlSock*, SOCKET,
type IPerlSock (line 1140) | struct IPerlSock
type sockaddr (line 1141) | struct sockaddr
type IPerlSock (line 1142) | struct IPerlSock
type sockaddr (line 1143) | struct sockaddr
type IPerlSock (line 1144) | struct IPerlSock
type IPerlSock (line 1145) | struct IPerlSock
type IPerlSock (line 1146) | struct IPerlSock
type IPerlSock (line 1147) | struct IPerlSock
type IPerlSock (line 1148) | struct IPerlSock
type IPerlSock (line 1149) | struct IPerlSock
type sockaddr (line 1150) | struct sockaddr
type hostent (line 1151) | struct hostent
type IPerlSock (line 1151) | struct IPerlSock
type hostent (line 1153) | struct hostent
type IPerlSock (line 1153) | struct IPerlSock
type hostent (line 1154) | struct hostent
type IPerlSock (line 1154) | struct IPerlSock
type netent (line 1155) | struct netent
type IPerlSock (line 1155) | struct IPerlSock
type netent (line 1156) | struct netent
type IPerlSock (line 1156) | struct IPerlSock
type netent (line 1157) | struct netent
type IPerlSock (line 1157) | struct IPerlSock
type protoent (line 1158) | struct protoent
type IPerlSock (line 1158) | struct IPerlSock
type protoent (line 1159) | struct protoent
type IPerlSock (line 1159) | struct IPerlSock
type protoent (line 1160) | struct protoent
type IPerlSock (line 1160) | struct IPerlSock
type servent (line 1161) | struct servent
type IPerlSock (line 1161) | struct IPerlSock
type servent (line 1163) | struct servent
type IPerlSock (line 1163) | struct IPerlSock
type servent (line 1165) | struct servent
type IPerlSock (line 1165) | struct IPerlSock
type IPerlSock (line 1166) | struct IPerlSock
type sockaddr (line 1167) | struct sockaddr
type IPerlSock (line 1168) | struct IPerlSock
type IPerlSock (line 1170) | struct IPerlSock
type IPerlSock (line 1171) | struct IPerlSock
type in_addr (line 1171) | struct in_addr
type IPerlSock (line 1172) | struct IPerlSock
type IPerlSock (line 1173) | struct IPerlSock
type IPerlSock (line 1174) | struct IPerlSock
type sockaddr (line 1175) | struct sockaddr
type IPerlSock (line 1176) | struct IPerlSock
type timeval (line 1177) | struct timeval
type IPerlSock (line 1178) | struct IPerlSock
type IPerlSock (line 1180) | struct IPerlSock
type sockaddr (line 1181) | struct sockaddr
type IPerlSock (line 1182) | struct IPerlSock
type IPerlSock (line 1183) | struct IPerlSock
type IPerlSock (line 1184) | struct IPerlSock
type IPerlSock (line 1185) | struct IPerlSock
type IPerlSock (line 1186) | struct IPerlSock
type IPerlSock (line 1188) | struct IPerlSock
type SOCKET (line 1189) | typedef SOCKET (*LPSocket)(struct IPerlSock*, int, int, int);
type IPerlSock (line 1190) | struct IPerlSock
type IPerlSock (line 1193) | struct IPerlSock
type IPerlSock (line 1196) | struct IPerlSock
type IPerlSockInfo (line 1246) | struct IPerlSockInfo
FILE: tests/perlbench/locale.c
function STATIC (line 53) | STATIC char *
function Perl_set_numeric_radix (line 85) | void
function Perl_new_numeric (line 114) | void
function Perl_set_numeric_standard (line 141) | void
function Perl_set_numeric_local (line 156) | void
function Perl_new_ctype (line 174) | void
function Perl_new_collate (line 196) | void
function Perl_init_i18nl10n (line 241) | int
function Perl_init_i18nl14n (line 556) | int
FILE: tests/perlbench/mg.c
type magic_state (line 81) | struct magic_state {
function STATIC (line 88) | STATIC void
function Perl_mg_magical (line 114) | void
function Perl_mg_get (line 139) | int
function Perl_mg_set (line 219) | int
function U32 (line 252) | U32
function I32 (line 282) | I32
function Perl_mg_clear (line 323) | int
function MAGIC (line 352) | MAGIC*
function Perl_mg_copy (line 373) | int
function Perl_mg_free (line 403) | int
function U32 (line 429) | U32
function Perl_magic_regdatum_get (line 444) | int
function Perl_magic_regdatum_set (line 478) | int
function U32 (line 486) | U32
function Perl_magic_get (line 578) | int
function Perl_magic_getuvar (line 960) | int
function Perl_magic_setenv (line 970) | int
function Perl_magic_clearenv (line 1046) | int
function Perl_magic_set_all_env (line 1054) | int
function Perl_magic_clear_all_env (line 1075) | int
function restore_sigmask (line 1124) | static void
function Perl_magic_getsig (line 1131) | int
function Perl_magic_clearsig (line 1161) | int
function Perl_raise_signal (line 1229) | void
function Signal_t (line 1238) | Signal_t
function Perl_csighandler_init (line 1267) | void
function Perl_despatch_signals (line 1287) | void
function Perl_magic_setsig (line 1303) | int
function Perl_magic_setisa (line 1426) | int
function Perl_magic_setamagic (line 1433) | int
function Perl_magic_getnkeys (line 1442) | int
function Perl_magic_setnkeys (line 1462) | int
function STATIC (line 1472) | STATIC int
function STATIC (line 1499) | STATIC int
function Perl_magic_getpack (line 1518) | int
function Perl_magic_setpack (line 1527) | int
function Perl_magic_clearpack (line 1539) | int
function U32 (line 1546) | U32
function Perl_magic_wipepack (line 1565) | int
function Perl_magic_nextpack (line 1582) | int
function Perl_magic_existspack (line 1607) | int
function SV (line 1613) | SV *
function Perl_magic_setdbline (line 1648) | int
function Perl_magic_getarylen (line 1671) | int
function Perl_magic_setarylen (line 1678) | int
function Perl_magic_getpos (line 1685) | int
function Perl_magic_setpos (line 1704) | int
function Perl_magic_getglob (line 1756) | int
function Perl_magic_setglob (line 1769) | int
function Perl_magic_getsubstr (line 1790) | int
function Perl_magic_setsubstr (line 1811) | int
function Perl_magic_gettaint (line 1838) | int
function Perl_magic_settaint (line 1846) | int
function Perl_magic_getvec (line 1862) | int
function Perl_magic_setvec (line 1876) | int
function Perl_magic_getdefelem (line 1883) | int
function Perl_magic_setdefelem (line 1922) | int
function Perl_vivify_defelem (line 1934) | void
function Perl_magic_killbackrefs (line 1977) | int
function Perl_magic_setmglob (line 1999) | int
function Perl_magic_setbm (line 2007) | int
function Perl_magic_setfm (line 2015) | int
function Perl_magic_setuvar (line 2023) | int
function Perl_magic_setregexp (line 2033) | int
function Perl_magic_freeregexp (line 2040) | int
function Perl_magic_setcollxfrm (line 2049) | int
function Perl_magic_setutf8 (line 2066) | int
function Perl_magic_set (line 2075) | int
function Perl_magic_mutexfree (line 2532) | int
function I32 (line 2546) | I32
function Signal_t (line 2569) | Signal_t
function restore_magic (line 2687) | static void
function unwind_handler_stack (line 2728) | static void
FILE: tests/perlbench/mg.h
type mgvtbl (line 14) | struct mgvtbl {
type magic (line 26) | struct magic {
FILE: tests/perlbench/nostdio.h
type _FILE (line 24) | struct _FILE
FILE: tests/perlbench/numeric.c
function U32 (line 30) | U32
function I32 (line 48) | I32
function IV (line 66) | IV
function UV (line 85) | UV
function NV (line 109) | NV
function UV (line 146) | UV
function UV (line 262) | UV
function UV (line 377) | UV
function NV (line 473) | NV
function NV (line 484) | NV
function NV (line 495) | NV
function Perl_grok_numeric_radix (line 513) | bool
function Perl_grok_number (line 558) | int
function STATIC (line 749) | STATIC NV
function NV (line 817) | NV
function Perl_my_modfl (line 1005) | long double
function Perl_my_frexpl (line 1014) | long double
FILE: tests/perlbench/op.c
function Perl_Slab_Free (line 128) | void
function STATIC (line 161) | STATIC char*
function STATIC (line 170) | STATIC OP *
function STATIC (line 178) | STATIC OP *
function STATIC (line 185) | STATIC OP *
function STATIC (line 192) | STATIC void
function STATIC (line 199) | STATIC void
function PADOFFSET (line 209) | PADOFFSET
function PADOFFSET (line 269) | PADOFFSET
function Perl_op_free (line 336) | void
function Perl_op_clear (line 384) | void
function STATIC (line 521) | STATIC void
function Perl_op_null (line 542) | void
function Perl_op_refcnt_lock (line 553) | void
function Perl_op_refcnt_unlock (line 559) | void
function OP (line 569) | OP *
function OP (line 593) | OP *
function STATIC (line 604) | STATIC OP *
function OP (line 620) | OP *
function OP (line 690) | OP *
function OP (line 908) | OP *
function OP (line 919) | OP *
function OP (line 994) | OP *
function STATIC (line 1021) | STATIC OP *
function OP (line 1032) | OP *
function STATIC (line 1360) | STATIC bool
function STATIC (line 1407) | STATIC bool
function OP (line 1430) | OP *
function OP (line 1441) | OP *
function STATIC (line 1530) | STATIC OP *
function STATIC (line 1553) | STATIC void
function STATIC (line 1595) | STATIC void
function Perl_apply_attrs_string (line 1660) | void
function STATIC (line 1691) | STATIC OP *
function OP (line 1752) | OP *
function OP (line 1784) | OP *
function OP (line 1790) | OP *
function OP (line 1798) | OP *
function OP (line 1848) | OP *
function OP (line 1857) | OP *
function Perl_save_hints (line 1881) | void
function Perl_block_start (line 1887) | int
function OP (line 1910) | OP*
function STATIC (line 1925) | STATIC OP *
function Perl_newPROG (line 1937) | void
function OP (line 1982) | OP *
function OP (line 2034) | OP *
function OP (line 2050) | OP *
function OP (line 2129) | OP *
function OP (line 2160) | OP *
function OP (line 2184) | OP *
function OP (line 2209) | OP *
function OP (line 2233) | OP *
function OP (line 2266) | OP *
function OP (line 2272) | OP *
function OP (line 2281) | OP *
function OP (line 2315) | OP *
function OP (line 2333) | OP *
function OP (line 2356) | OP *
function uvcompare (line 2387) | static int
function OP (line 2401) | OP *
function OP (line 2708) | OP *
function OP (line 2752) | OP *
function OP (line 2903) | OP *
function OP (line 2920) | OP *
function OP (line 2941) | OP *
function OP (line 2953) | OP *
function Perl_package (line 2970) | void
function Perl_utilize (line 2996) | void
function Perl_load_module (line 3109) | void
function Perl_load_module_nocontext (line 3119) | void
function Perl_vload_module (line 3130) | void
function OP (line 3170) | OP *
function OP (line 3193) | OP *
function STATIC (line 3201) | STATIC I32
function OP (line 3240) | OP *
function OP (line 3422) | OP *
function OP (line 3486) | OP *
function STATIC (line 3492) | STATIC OP *
function OP (line 3605) | OP *
function OP (line 3660) | OP *
function OP (line 3706) | OP *
function OP (line 3765) | OP *
function OP (line 3858) | OP *
function OP (line 3957) | OP*
function Perl_cv_undef (line 3996) | void
function Perl_cv_ckproto (line 4053) | void
function SV (line 4094) | SV *
function SV (line 4102) | SV *
function Perl_newMYSUB (line 4153) | void
function CV (line 4167) | CV *
function CV (line 4173) | CV *
function CV (line 4534) | CV *
function CV (line 4575) | CV *
function Perl_newFORM (line 4677) | void
function OP (line 4724) | OP *
function OP (line 4731) | OP *
function OP (line 4738) | OP *
function OP (line 4744) | OP *
function OP (line 4752) | OP *
function OP (line 4775) | OP *
function OP (line 4800) | OP *
function OP (line 4816) | OP *
function OP (line 4824) | OP *
function OP (line 4840) | OP *
function OP (line 4848) | OP *
function OP (line 4854) | OP *
function OP (line 4872) | OP *
function OP (line 4880) | OP *
function OP (line 4913) | OP *
function OP (line 4923) | OP *
function OP (line 4948) | OP *
function OP (line 4976) | OP *
function OP (line 4985) | OP *
function OP (line 5000) | OP *
function OP (line 5042) | OP *
function OP (line 5057) | OP *
function OP (line 5072) | OP *
function OP (line 5096) | OP *
function OP (line 5106) | OP *
function OP (line 5216) | OP *
function OP (line 5250) | OP *
function OP (line 5507) | OP *
function OP (line 5561) | OP *
function OP (line 5614) | OP *
function OP (line 5627) | OP *
function OP (line 5634) | OP *
function OP (line 5641) | OP *
function OP (line 5679) | OP *
function OP (line 5686) | OP *
function OP (line 5716) | OP *
function OP (line 5759) | OP *
function OP (line 5766) | OP *
function OP (line 5788) | OP *
function OP (line 5794) | OP *
function OP (line 5843) | OP *
function OP (line 5855) | OP *
function OP (line 5901) | OP *
function OP (line 5913) | OP *
function OP (line 5922) | OP *
function OP (line 5942) | OP *
function OP (line 5970) | OP *
function STATIC (line 6033) | STATIC void
function OP (line 6102) | OP *
function OP (line 6157) | OP *
function OP (line 6174) | OP *
function OP (line 6389) | OP *
function OP (line 6396) | OP *
function OP (line 6414) | OP *
function Perl_peep (line 6434) | void
function const_sv_xsub (line 7059) | static void
FILE: tests/perlbench/op.h
type unop (line 230) | struct unop {
type binop (line 235) | struct binop {
type logop (line 241) | struct logop {
type listop (line 247) | struct listop {
type pmop (line 253) | struct pmop {
type svop (line 332) | struct svop {
type padop (line 337) | struct padop {
type pvop (line 342) | struct pvop {
type loop (line 347) | struct loop {
FILE: tests/perlbench/opnames.h
type opcode (line 15) | typedef enum opcode {
FILE: tests/perlbench/pad.c
function PADLIST (line 124) | PADLIST *
function Perl_pad_undef (line 225) | void
function PADOFFSET (line 330) | PADOFFSET
function PADOFFSET (line 397) | PADOFFSET
function PADOFFSET (line 453) | PADOFFSET
function Perl_pad_check_dup (line 496) | void
function PADOFFSET (line 563) | PADOFFSET
function STATIC (line 640) | STATIC PADOFFSET
function SV (line 828) | SV *
function Perl_pad_setsv (line 855) | void
function Perl_pad_block_start (line 884) | void
function U32 (line 912) | U32
function Perl_pad_leavemy (line 954) | void
function Perl_pad_swipe (line 1000) | void
function Perl_pad_reset (line 1041) | void
function Perl_pad_tidy (line 1085) | void
function Perl_pad_free (line 1154) | void
function Perl_do_dump_pad (line 1193) | void
function STATIC (line 1262) | STATIC void
function CV (line 1303) | CV *
function STATIC (line 1319) | STATIC CV *
function Perl_pad_fixup_inner_anons (line 1466) | void
function Perl_pad_push (line 1501) | void
FILE: tests/perlbench/pad.h
type AV (line 19) | typedef AV PADLIST;
type AV (line 20) | typedef AV PAD;
type U32TYPE (line 26) | typedef U32TYPE PADOFFSET;
type U64TYPE (line 29) | typedef U64TYPE PADOFFSET;
type padtidy_type (line 43) | typedef enum {
FILE: tests/perlbench/parser-util.c
function EXTERN (line 14) | EXTERN SV*
function EXTERN (line 24) | EXTERN int
function grow_gap (line 42) | static void
function EXTERN (line 65) | EXTERN SV*
function has_hibit (line 274) | static bool
function EXTERN (line 287) | EXTERN bool
FILE: tests/perlbench/perl.c
function PerlInterpreter (line 162) | PerlInterpreter *
function PerlInterpreter (line 198) | PerlInterpreter *
function perl_construct (line 222) | void
function Perl_nothreadhook (line 404) | int
function perl_destruct (line 418) | int
function perl_free (line 1081) | void
function perl_fini (line 1121) | static void __attribute__((destructor))
function Perl_call_atexit (line 1132) | void
function perl_parse (line 1149) | int
function STATIC (line 1341) | STATIC void *
function perl_run (line 1906) | int
function STATIC (line 1969) | STATIC void *
function STATIC (line 1979) | STATIC void *
function SV (line 2037) | SV*
function AV (line 2066) | AV*
function HV (line 2089) | HV*
function CV (line 2113) | CV*
function I32 (line 2144) | I32
function I32 (line 2171) | I32
function I32 (line 2188) | I32
function I32 (line 2206) | I32
function STATIC (line 2360) | STATIC void *
function STATIC (line 2371) | STATIC void
function I32 (line 2394) | I32
function SV (line 2498) | SV*
function Perl_require_pv (line 2532) | void
function Perl_magicname (line 2548) | void
function STATIC (line 2557) | STATIC void
function Perl_get_debug_opts (line 2610) | int
function Perl_get_debug_opts_flags (line 2616) | int
function Perl_my_unexec (line 3089) | void
function STATIC (line 3119) | STATIC void
function STATIC (line 3163) | STATIC void
function STATIC (line 3197) | STATIC void
function STATIC (line 3374) | STATIC int
function STATIC (line 3501) | STATIC void
function STATIC (line 3898) | STATIC void
function STATIC (line 4531) | STATIC SV *
function STATIC (line 4543) | STATIC void
function perl_thread (line 4662) | perl_thread *
function Perl_call_list (line 4741) | void
function STATIC (line 4836) | STATIC void *
function STATIC (line 4844) | STATIC void *
function Perl_my_exit (line 4852) | void
function Perl_my_failure_exit (line 4871) | void
function STATIC (line 4900) | STATIC void
function I32 (line 4923) | static I32
FILE: tests/perlbench/perl.h
type perl_thread (line 105) | struct perl_thread
type op (line 225) | struct op
type IVTYPE (line 1323) | typedef IVTYPE IV;
type UVTYPE (line 1324) | typedef UVTYPE UV;
type NVTYPE (line 1523) | typedef NVTYPE NV;
type RExC_state_t (line 2001) | struct RExC_state_t
type MEM_SIZE (line 2003) | typedef MEM_SIZE STRLEN;
type OP (line 2005) | typedef struct op OP;
type COP (line 2006) | typedef struct cop COP;
type UNOP (line 2007) | typedef struct unop UNOP;
type BINOP (line 2008) | typedef struct binop BINOP;
type LISTOP (line 2009) | typedef struct listop LISTOP;
type LOGOP (line 2010) | typedef struct logop LOGOP;
type PMOP (line 2011) | typedef struct pmop PMOP;
type SVOP (line 2012) | typedef struct svop SVOP;
type PADOP (line 2013) | typedef struct padop PADOP;
type PVOP (line 2014) | typedef struct pvop PVOP;
type LOOP (line 2015) | typedef struct loop LOOP;
type PerlInterpreter (line 2017) | typedef struct interpreter PerlInterpreter;
type SV (line 2026) | typedef struct STRUCT_SV SV;
type AV (line 2027) | typedef struct av AV;
type HV (line 2028) | typedef struct hv HV;
type CV (line 2029) | typedef struct cv CV;
type REGEXP (line 2030) | typedef struct regexp REGEXP;
type GP (line 2031) | typedef struct gp GP;
type GV (line 2032) | typedef struct gv GV;
type IO (line 2033) | typedef struct io IO;
type PERL_CONTEXT (line 2034) | typedef struct context PERL_CONTEXT;
type BLOCK (line 2035) | typedef struct block BLOCK;
type MAGIC (line 2037) | typedef struct magic MAGIC;
type XRV (line 2038) | typedef struct xrv XRV;
type XPV (line 2039) | typedef struct xpv XPV;
type XPVIV (line 2040) | typedef struct xpviv XPVIV;
type XPVUV (line 2041) | typedef struct xpvuv XPVUV;
type XPVNV (line 2042) | typedef struct xpvnv XPVNV;
type XPVMG (line 2043) | typedef struct xpvmg XPVMG;
type XPVLV (line 2044) | typedef struct xpvlv XPVLV;
type XPVAV (line 2045) | typedef struct xpvav XPVAV;
type XPVHV (line 2046) | typedef struct xpvhv XPVHV;
type XPVGV (line 2047) | typedef struct xpvgv XPVGV;
type XPVCV (line 2048) | typedef struct xpvcv XPVCV;
type XPVBM (line 2049) | typedef struct xpvbm XPVBM;
type XPVFM (line 2050) | typedef struct xpvfm XPVFM;
type XPVIO (line 2051) | typedef struct xpvio XPVIO;
type MGVTBL (line 2052) | typedef struct mgvtbl MGVTBL;
type ANY (line 2053) | typedef union any ANY;
type PTR_TBL_ENT_t (line 2054) | typedef struct ptr_tbl_ent PTR_TBL_ENT_t;
type PTR_TBL_t (line 2055) | typedef struct ptr_tbl PTR_TBL_t;
type CLONE_PARAMS (line 2056) | typedef struct clone_params CLONE_PARAMS;
type cthread_t (line 2322) | typedef cthread_t perl_os_thread;
type mutex_t (line 2323) | typedef mutex_t perl_mutex;
type condition_t (line 2324) | typedef condition_t perl_cond;
type pthread_t (line 2330) | typedef pthread_t perl_os_thread;
type pthread_mutex_t (line 2331) | typedef pthread_mutex_t perl_mutex;
type pthread_cond_t (line 2332) | typedef pthread_cond_t perl_cond;
type pthread_key_t (line 2333) | typedef pthread_key_t perl_key;
type I32 (line 2562) | typedef I32 (*filter_t) (pTHX_ int, SV *, int);
type CRYPTD (line 2572) | typedef struct crypt_data { /* straight from /usr/include/cry...
type CURCUR (line 2616) | typedef struct curcur CURCUR;
type curcur (line 2617) | struct curcur {
type SUBLEXINFO (line 2629) | typedef struct _sublex_info SUBLEXINFO;
type _sublex_info (line 2630) | struct _sublex_info {
type MGS (line 2638) | typedef struct magic_state MGS;
type scan_data_t (line 2640) | struct scan_data_t
type regnode_charclass_class (line 2641) | struct regnode_charclass_class
type I32 (line 2643) | typedef I32 CHECKPOINT;
type ptr_tbl_ent (line 2645) | struct ptr_tbl_ent {
type ptr_tbl (line 2651) | struct ptr_tbl {
type ufuncs (line 3048) | struct ufuncs {
type tm (line 3087) | struct tm
type Sigsave_t (line 3224) | typedef struct sigaction Sigsave_t;
type Sighandler_t (line 3226) | typedef Sighandler_t Sigsave_t;
type OP (line 3268) | typedef OP* (CPERLscope(*PPADDR_t)[]) (pTHX);
type expectation (line 3581) | typedef enum {
type perl_debug_pad (line 3673) | struct perl_debug_pad {
type regexp (line 3682) | typedef regexp*(CPERLscope(*regcomp_t)) (pTHX_ char* exp, char* xend, PM...
type re_scream_pos_data_s (line 3689) | struct re_scream_pos_data_s
type SV (line 3690) | typedef SV* (CPERLscope(*re_intuit_string_t)) (pTHX_ regexp *prog);
type I32 (line 3696) | typedef I32 (*SVCOMPARE_t) (pTHX_ SV*, SV*);
type PerlExitListEntry (line 3708) | typedef struct exitlistentry {
type perl_vars (line 3714) | struct perl_vars {
type perl_vars (line 3725) | struct perl_vars
type interpreter (line 3738) | struct interpreter {
type interpreter (line 3751) | struct interpreter {
type perl_thread (line 3762) | struct perl_thread {
type perl_thread (line 3766) | struct perl_thread
type howlen_t (line 3779) | typedef enum {
type tempsym_t (line 3785) | typedef struct {
function END_EXTERN_C (line 4103) | END_EXTERN_C
type am_table_short (line 4112) | struct am_table_short {
type AMT (line 4117) | typedef struct am_table AMT;
type AMTS (line 4118) | typedef struct am_table_short AMTS;
type semid_ds (line 4379) | struct semid_ds
type semid_ds (line 4387) | struct semid_ds
FILE: tests/perlbench/perlio.c
function PerlIO_intmode2str (line 172) | int
function PerlIO_apply_layers (line 218) | int
function PerlIO_destruct (line 235) | void
function PerlIO_binmode (line 240) | int
function PerlIO (line 250) | PerlIO *
function PerlIO (line 290) | PerlIO *
function XS (line 321) | XS(XS_PerlIO__Layer__find)
function Perl_boot_core_PerlIO (line 335) | void
function PerlIO_init (line 346) | void
function PerlIO (line 358) | PerlIO *
function PerlIO (line 377) | PerlIO *
function PerlIO_init (line 383) | void
function PerlIO (line 401) | PerlIO *
function FILE (line 411) | FILE *
function PerlIO_debug (line 450) | void
function PerlIO (line 510) | PerlIO *
function PerlIO (line 537) | PerlIO *
function PerlIO_cleantable (line 555) | void
function PerlIO_list_t (line 574) | PerlIO_list_t *
function PerlIO_list_free (line 583) | void
function PerlIO_list_push (line 601) | void
function PerlIO_list_t (line 619) | PerlIO_list_t *
function PerlIO_clone (line 636) | void
function PerlIO_destruct (line 660) | void
function PerlIO_pop (line 689) | void
function AV (line 715) | AV *
function PerlIO_funcs (line 743) | PerlIO_funcs *
function perlio_mg_set (line 787) | static int
function perlio_mg_get (line 799) | static int
function perlio_mg_clear (line 811) | static int
function perlio_mg_free (line 818) | static int
function XS (line 833) | XS(XS_io_MODIFY_SCALAR_ATTRIBUTES)
function SV (line 865) | SV *
function XS (line 873) | XS(XS_PerlIO__Layer__NoWarnings)
function XS (line 884) | XS(XS_PerlIO__Layer__find)
function PerlIO_define_layer (line 901) | void
function PerlIO_parse_layers (line 910) | int
function PerlIO_default_buffer (line 1004) | void
function SV (line 1019) | SV *
function PerlIO_funcs (line 1025) | PerlIO_funcs *
function IV (line 1038) | IV
function PerlIO_list_t (line 1078) | PerlIO_list_t *
function Perl_boot_core_PerlIO (line 1122) | void
function PerlIO_funcs (line 1133) | PerlIO_funcs *
function PerlIO_stdstreams (line 1145) | void
function PerlIO (line 1156) | PerlIO *
function IV (line 1196) | IV
function IV (line 1214) | IV
function PerlIO_apply_layera (line 1252) | int
function PerlIO_apply_layers (line 1270) | int
function PerlIO_binmode (line 1291) | int
function PerlIO__close (line 1346) | int
function Perl_PerlIO_close (line 1362) | int
function Perl_PerlIO_fileno (line 1372) | int
function PerlIO_funcs (line 1404) | static PerlIO_funcs *
function PerlIO_list_t (line 1429) | PerlIO_list_t *
function PerlIO (line 1487) | PerlIO *
function SSize_t (line 1573) | SSize_t
function SSize_t (line 1579) | SSize_t
function SSize_t (line 1585) | SSize_t
function Perl_PerlIO_seek (line 1591) | int
function Off_t (line 1597) | Off_t
function Perl_PerlIO_flush (line 1603) | int
function PerlIOBase_flush_linebuf (line 1644) | void
function Perl_PerlIO_fill (line 1663) | int
function PerlIO_isutf8 (line 1669) | int
function Perl_PerlIO_eof (line 1680) | int
function Perl_PerlIO_error (line 1686) | int
function Perl_PerlIO_clearerr (line 1692) | void
function Perl_PerlIO_setlinebuf (line 1698) | void
function PerlIO_has_base (line 1704) | int
function PerlIO_fast_gets (line 1720) | int
function PerlIO_has_cntptr (line 1736) | int
function PerlIO_canset_cnt (line 1752) | int
function STDCHAR (line 1768) | STDCHAR *
function Perl_PerlIO_get_bufsiz (line 1774) | int
function STDCHAR (line 1780) | STDCHAR *
function Perl_PerlIO_get_cnt (line 1786) | int
function Perl_PerlIO_set_cnt (line 1792) | void
function Perl_PerlIO_set_ptrcnt (line 1798) | void
function IV (line 1810) | IV
function PerlIO (line 1881) | PerlIO *
function IV (line 1928) | IV
function IV (line 1967) | IV
function IV (line 2028) | IV
function SSize_t (line 2034) | SSize_t
function SSize_t (line 2048) | SSize_t
function IV (line 2080) | IV
function IV (line 2086) | IV
function IV (line 2092) | IV
function IV (line 2121) | IV
function IV (line 2130) | IV
function PerlIOBase_clearerr (line 2139) | void
function PerlIOBase_setlinebuf (line 2150) | void
function SV (line 2158) | SV *
function PerlIO (line 2175) | PerlIO *
function PerlIO_init (line 2211) | void
function PerlIOUnix_refcnt_inc (line 2220) | void
function PerlIOUnix_refcnt_dec (line 2235) | int
function PerlIO_cleanup (line 2252) | void
type PerlIOUnix (line 2286) | typedef struct {
function PerlIOUnix_oflags (line 2292) | int
function IV (line 2348) | IV
function PerlIOUnix_setfd (line 2354) | static void
function IV (line 2375) | IV
function IV (line 2395) | IV
function PerlIO (line 2417) | PerlIO *
function PerlIO (line 2465) | PerlIO *
function SSize_t (line 2485) | SSize_t
function SSize_t (line 2511) | SSize_t
function Off_t (line 2529) | Off_t
function IV (line 2536) | IV
type PerlIOStdio (line 2608) | typedef struct {
function IV (line 2613) | IV
function IV (line 2640) | IV
function PerlIO (line 2669) | PerlIO *
function PerlIO (line 2707) | PerlIO *
function PerlIO (line 2803) | PerlIO *
function PerlIOStdio_invalidate_fileno (line 2833) | static int
function IV (line 2934) | IV
function SSize_t (line 3007) | SSize_t
function SSize_t (line 3037) | SSize_t
function SSize_t (line 3095) | SSize_t
function IV (line 3110) | IV
function Off_t (line 3117) | Off_t
function IV (line 3124) | IV
function IV (line 3150) | IV
function IV (line 3156) | IV
function PerlIOStdio_clearerr (line 3162) | void
function PerlIOStdio_setlinebuf (line 3168) | void
function STDCHAR (line 3179) | STDCHAR *
function Size_t (line 3186) | Size_t
function STDCHAR (line 3195) | STDCHAR *
function SSize_t (line 3202) | SSize_t
function PerlIOStdio_set_ptrcnt (line 3209) | void
function IV (line 3252) | IV
function FILE (line 3363) | FILE *
function FILE (line 3396) | FILE *
function PerlIO_releaseFILE (line 3412) | void
function IV (line 3435) | IV
function PerlIO (line 3452) | PerlIO *
function IV (line 3519) | IV
function IV (line 3576) | IV
function SSize_t (line 3642) | SSize_t
function SSize_t (line 3654) | SSize_t
function SSize_t (line 3714) | SSize_t
function IV (line 3759) | IV
function Off_t (line 3774) | Off_t
function IV (line 3804) | IV
function IV (line 3818) | IV
function STDCHAR (line 3832) | STDCHAR *
function SSize_t (line 3841) | SSize_t
function STDCHAR (line 3852) | STDCHAR *
function Size_t (line 3871) | Size_t
function PerlIOBuf_set_ptrcnt (line 3880) | void
function PerlIO (line 3894) | PerlIO *
function IV (line 3938) | IV
function IV (line 3948) | IV
function IV (line 3958) | IV
function IV (line 3969) | IV
function PerlIOPending_set_ptrcnt (line 3981) | void
function IV (line 3992) | IV
function SSize_t (line 4007) | SSize_t
type PerlIOCrlf (line 4065) | typedef struct {
function IV (line 4071) | IV
function SSize_t (line 4103) | SSize_t
function SSize_t (line 4152) | SSize_t
function PerlIOCrlf_set_ptrcnt (line 4224) | void
function SSize_t (line 4278) | SSize_t
function IV (line 4329) | IV
function IV (line 4340) | IV
type PerlIOMmap (line 4394) | typedef struct {
function IV (line 4403) | IV
function IV (line 4497) | IV
function STDCHAR (line 4518) | STDCHAR *
function SSize_t (line 4551) | SSize_t
function SSize_t (line 4582) | SSize_t
function IV (line 4608) | IV
function IV (line 4636) | IV
function IV (line 4650) | IV
function PerlIO (line 4666) | PerlIO *
function PerlIO (line 4706) | PerlIO *
function PerlIO (line 4715) | PerlIO *
function PerlIO (line 4724) | PerlIO *
function PerlIO (line 4765) | PerlIO *
function PerlIO (line 4773) | PerlIO *
function PerlIO (line 4782) | PerlIO *
function PerlIO_getc (line 4791) | int
function PerlIO_ungetc (line 4804) | int
function PerlIO_putc (line 4817) | int
function PerlIO_puts (line 4826) | int
function PerlIO_rewind (line 4835) | void
function PerlIO_vprintf (line 4844) | int
function PerlIO_printf (line 4866) | int
function PerlIO_stdoutf (line 4878) | int
function PerlIO (line 4891) | PerlIO *
function PerlIO_setpos (line 4947) | int
function PerlIO_setpos (line 4962) | int
function PerlIO_getpos (line 4984) | int
function PerlIO_getpos (line 4994) | int
function vprintf (line 5012) | int
function vfprintf (line 5020) | int
function PerlIO_vsprintf (line 5031) | int
function PerlIO_sprintf (line 5048) | int
FILE: tests/perlbench/perlio.h
type PerlIOl (line 99) | typedef struct _PerlIO PerlIOl;
type PerlIO_funcs (line 100) | typedef struct _PerlIO_funcs PerlIO_funcs;
type PerlIOl (line 101) | typedef PerlIOl *PerlIO;
type PerlIO_list_t (line 373) | typedef struct PerlIO_list_s PerlIO_list_t;
FILE: tests/perlbench/perliol.h
type PerlIO_pair_t (line 4) | typedef struct {
type PerlIO_list_s (line 9) | struct PerlIO_list_s {
type _PerlIO_funcs (line 16) | struct _PerlIO_funcs {
type _PerlIO (line 66) | struct _PerlIO {
type PerlIOBuf (line 151) | typedef struct {
FILE: tests/perlbench/perlmain.c
function main (line 47) | int
function xs_init (line 128) | static void
FILE: tests/perlbench/perly.c
type ysv (line 23) | struct ysv {
type YYSTYPE (line 39) | typedef union {
function yyparse (line 1412) | int
function yydestruct (line 2533) | static void
FILE: tests/perlbench/perly.h
type YYSTYPE (line 65) | typedef union {
FILE: tests/perlbench/poll.c
function poll (line 45) | int
FILE: tests/perlbench/poll.h
type pollfd_t (line 28) | typedef struct pollfd {
type pollfd (line 49) | struct pollfd
FILE: tests/perlbench/pp.c
function PP (line 44) | PP(pp_stub)
function PP (line 52) | PP(pp_scalar)
function PP (line 59) | PP(pp_padav)
function PP (line 100) | PP(pp_padhv)
function PP (line 126) | PP(pp_padany)
function PP (line 133) | PP(pp_rv2gv)
function PP (line 227) | PP(pp_rv2sv)
function PP (line 299) | PP(pp_av2arylen)
function PP (line 313) | PP(pp_pos)
function PP (line 349) | PP(pp_rv2cv)
function PP (line 374) | PP(pp_prototype)
function PP (line 444) | PP(pp_anoncode)
function PP (line 455) | PP(pp_srefgen)
function PP (line 462) | PP(pp_refgen)
function STATIC (line 480) | STATIC SV*
function PP (line 512) | PP(pp_ref)
function PP (line 532) | PP(pp_bless)
function PP (line 557) | PP(pp_gelem)
function PP (line 633) | PP(pp_study)
function PP (line 696) | PP(pp_trans)
function PP (line 714) | PP(pp_schop)
function PP (line 722) | PP(pp_chop)
function PP (line 732) | PP(pp_schomp)
function PP (line 739) | PP(pp_chomp)
function PP (line 750) | PP(pp_defined)
function PP (line 782) | PP(pp_undef)
function PP (line 849) | PP(pp_predec)
function PP (line 866) | PP(pp_postinc)
function PP (line 888) | PP(pp_postdec)
function PP (line 909) | PP(pp_pow)
function PP (line 1042) | PP(pp_multiply)
function PP (line 1160) | PP(pp_divide)
function PP (line 1275) | PP(pp_modulo)
function PP (line 1403) | PP(pp_repeat)
function PP (line 1531) | PP(pp_subtract)
function PP (line 1648) | PP(pp_left_shift)
function PP (line 1665) | PP(pp_right_shift)
function PP (line 1682) | PP(pp_lt)
function PP (line 1760) | PP(pp_gt)
function PP (line 1838) | PP(pp_le)
function PP (line 1916) | PP(pp_ge)
function PP (line 1994) | PP(pp_ne)
function PP (line 2063) | PP(pp_ncmp)
function PP (line 2173) | PP(pp_slt)
function PP (line 2186) | PP(pp_sgt)
function PP (line 2199) | PP(pp_sle)
function PP (line 2212) | PP(pp_sge)
function PP (line 2225) | PP(pp_seq)
function PP (line 2235) | PP(pp_sne)
function PP (line 2245) | PP(pp_scmp)
function PP (line 2258) | PP(pp_bit_and)
function PP (line 2281) | PP(pp_bit_xor)
function PP (line 2304) | PP(pp_bit_or)
function PP (line 2327) | PP(pp_negate)
function PP (line 2398) | PP(pp_not)
function PP (line 2405) | PP(pp_complement)
function PP (line 2501) | PP(pp_i_multiply)
function PP (line 2511) | PP(pp_i_divide)
function STATIC (line 2524) | STATIC
function STATIC (line 2539) | STATIC
function PP (line 2556) | PP(pp_i_modulo)
function PP (line 2596) | PP(pp_i_add)
function PP (line 2606) | PP(pp_i_subtract)
function PP (line 2616) | PP(pp_i_lt)
function PP (line 2626) | PP(pp_i_gt)
function PP (line 2636) | PP(pp_i_le)
function PP (line 2646) | PP(pp_i_ge)
function PP (line 2656) | PP(pp_i_eq)
function PP (line 2666) | PP(pp_i_ne)
function PP (line 2676) | PP(pp_i_ncmp)
function PP (line 2694) | PP(pp_i_negate)
function PP (line 2703) | PP(pp_atan2)
function PP (line 2713) | PP(pp_sin)
function PP (line 2725) | PP(pp_cos)
function PP (line 2752) | PP(pp_rand)
function PP (line 2771) | PP(pp_srand)
function PP (line 2785) | PP(pp_exp)
function PP (line 2797) | PP(pp_log)
function PP (line 2813) | PP(pp_sqrt)
function PP (line 2829) | PP(pp_int)
function PP (line 2869) | PP(pp_abs)
function PP (line 2906) | PP(pp_hex)
function PP (line 2936) | PP(pp_oct)
function PP (line 2978) | PP(pp_length)
function PP (line 2990) | PP(pp_substr)
function PP (line 3159) | PP(pp_vec)
function PP (line 3190) | PP(pp_index)
function PP (line 3253) | PP(pp_rindex)
function PP (line 3322) | PP(pp_sprintf)
function PP (line 3334) | PP(pp_ord)
function PP (line 3355) | PP(pp_chr)
function PP (line 3398) | PP(pp_crypt)
function PP (line 3448) | PP(pp_ucfirst)
function PP (line 3510) | PP(pp_lcfirst)
function PP (line 3566) | PP(pp_uc)
function PP (line 3649) | PP(pp_lc)
function PP (line 3752) | PP(pp_quotemeta)
function PP (line 3805) | PP(pp_aslice)
function PP (line 3850) | PP(pp_each)
function PP (line 3883) | PP(pp_values)
function PP (line 3888) | PP(pp_keys)
function PP (line 3893) | PP(pp_delete)
function PP (line 3960) | PP(pp_exists)
function PP (line 3997) | PP(pp_hslice)
function PP (line 4070) | PP(pp_list)
function PP (line 4083) | PP(pp_lslice)
function PP (line 4138) | PP(pp_anonlist)
function PP (line 4148) | PP(pp_anonhash)
function PP (line 4167) | PP(pp_splice)
function PP (line 4374) | PP(pp_push)
function PP (line 4404) | PP(pp_pop)
function PP (line 4415) | PP(pp_shift)
function PP (line 4429) | PP(pp_unshift)
function PP (line 4458) | PP(pp_reverse)
function PP (line 4526) | PP(pp_split)
function Perl_unlock_condpair (line 4832) | void
function PP (line 4850) | PP(pp_lock)
function PP (line 4864) | PP(pp_threadsv)
FILE: tests/perlbench/pp_ctl.c
function PP (line 43) | PP(pp_wantarray)
function PP (line 63) | PP(pp_regcmaybe)
function PP (line 68) | PP(pp_regcreset)
function PP (line 77) | PP(pp_regcomp)
function PP (line 162) | PP(pp_substcont)
function Perl_rxres_save (line 273) | void
function Perl_rxres_restore (line 301) | void
function Perl_rxres_free (line 322) | void
function PP (line 334) | PP(pp_formline)
function PP (line 837) | PP(pp_grepstart)
function PP (line 869) | PP(pp_mapstart)
function PP (line 874) | PP(pp_mapwhile)
function PP (line 975) | PP(pp_range)
function PP (line 985) | PP(pp_flip)
function PP (line 1038) | PP(pp_flop)
function STATIC (line 1128) | STATIC I32
function I32 (line 1162) | I32
function I32 (line 1169) | I32
function I32 (line 1192) | I32
function STATIC (line 1206) | STATIC I32
function STATIC (line 1212) | STATIC I32
function STATIC (line 1232) | STATIC I32
function STATIC (line 1250) | STATIC I32
function Perl_dounwind (line 1277) | void
function Perl_qerror (line 1313) | void
function OP (line 1325) | OP *
function PP (line 1416) | PP(pp_xor)
function PP (line 1425) | PP(pp_andassign)
function PP (line 1434) | PP(pp_orassign)
function PP (line 1443) | PP(pp_caller)
function PP (line 1610) | PP(pp_reset)
function PP (line 1625) | PP(pp_lineseq)
function PP (line 1632) | PP(pp_dbstate)
function PP (line 1678) | PP(pp_scope)
function PP (line 1683) | PP(pp_enteriter)
function PP (line 1773) | PP(pp_enterloop)
function PP (line 1789) | PP(pp_leaveloop)
function PP (line 1829) | PP(pp_return)
function PP (line 1940) | PP(pp_last)
function PP (line 2028) | PP(pp_next)
function PP (line 2056) | PP(pp_redo)
function STATIC (line 2082) | STATIC OP *
function PP (line 2129) | PP(pp_dump)
function PP (line 2135) | PP(pp_goto)
function PP (line 2507) | PP(pp_exit)
function PP (line 2529) | PP(pp_nswitch)
function PP (line 2548) | PP(pp_cswitch)
function STATIC (line 2571) | STATIC void
function STATIC (line 2596) | STATIC void *
function STATIC (line 2603) | STATIC void *
function STATIC (line 2610) | STATIC OP *
function OP (line 2667) | OP *
function CV (line 2767) | CV*
function STATIC (line 2803) | STATIC OP *
function STATIC (line 2956) | STATIC PerlIO *
function PP (line 3364) | PP(pp_dofile)
function PP (line 3369) | PP(pp_entereval)
function PP (line 3461) | PP(pp_leaveeval)
function PP (line 3529) | PP(pp_entertry)
function PP (line 3548) | PP(pp_leavetry)
function STATIC (line 3596) | STATIC OP *
function STATIC (line 3818) | STATIC bool
function I32 (line 3845) | static I32
function S_path_is_absolute (line 3917) | static bool
FILE: tests/perlbench/pp_hot.c
function PP (line 42) | PP(pp_const)
function PP (line 49) | PP(pp_nextstate)
function PP (line 58) | PP(pp_gvsv)
function PP (line 69) | PP(pp_null)
function PP (line 74) | PP(pp_setstate)
function PP (line 80) | PP(pp_pushmark)
function PP (line 86) | PP(pp_stringify)
function PP (line 94) | PP(pp_gv)
function PP (line 101) | PP(pp_and)
function PP (line 112) | PP(pp_sassign)
function PP (line 127) | PP(pp_cond_expr)
function PP (line 136) | PP(pp_unstack)
function PP (line 147) | PP(pp_concat)
function PP (line 213) | PP(pp_padsv)
function PP (line 229) | PP(pp_readline)
function PP (line 247) | PP(pp_eq)
function PP (line 314) | PP(pp_preinc)
function PP (line 331) | PP(pp_or)
function PP (line 342) | PP(pp_add)
function PP (line 504) | PP(pp_aelemfast)
function PP (line 519) | PP(pp_join)
function PP (line 529) | PP(pp_pushre)
function PP (line 550) | PP(pp_print)
function PP (line 651) | PP(pp_rv2av)
function PP (line 781) | PP(pp_rv2hv)
function STATIC (line 901) | STATIC int
function STATIC (line 946) | STATIC void
function PP (line 987) | PP(pp_aassign)
function PP (line 1220) | PP(pp_qr)
function PP (line 1232) | PP(pp_match)
function OP (line 1485) | OP *
function PP (line 1687) | PP(pp_enter)
function PP (line 1708) | PP(pp_helem)
function PP (line 1798) | PP(pp_leave)
function PP (line 1854) | PP(pp_iter)
function PP (line 1992) | PP(pp_subst)
function PP (line 2299) | PP(pp_grepwhile)
function PP (line 2340) | PP(pp_leavesub)
function PP (line 2400) | PP(pp_leavesublv)
function STATIC (line 2557) | STATIC CV *
function PP (line 2594) | PP(pp_entersub)
function Perl_sub_crush_depth (line 2998) | void
function PP (line 3011) | PP(pp_aelem)
function Perl_vivify_ref (line 3068) | void
function PP (line 3099) | PP(pp_method)
function PP (line 3116) | PP(pp_method_named)
function STATIC (line 3126) | STATIC SV *
function unset_cvowner (line 3273) | static void
FILE: tests/perlbench/pp_pack.c
function STATIC (line 98) | STATIC SV *
type packsize_t (line 279) | struct packsize_t {
type packsize_t (line 381) | struct packsize_t
type packsize_t (line 480) | struct packsize_t
function STATIC (line 488) | STATIC I32
function STATIC (line 606) | STATIC char *
function STATIC (line 635) | STATIC char *
function STATIC (line 651) | STATIC bool
function I32 (line 832) | I32
function I32 (line 852) | I32
function STATIC (line 863) | STATIC
function PP (line 1771) | PP(pp_unpack)
function STATIC (line 1802) | STATIC void
function STATIC (line 1830) | STATIC SV *
function STATIC (line 1880) | STATIC int
function Perl_pack_cat (line 1917) | void
function Perl_packlist (line 1937) | void
function STATIC (line 1949) | STATIC
function PP (line 2741) | PP(pp_pack)
FILE: tests/perlbench/pp_sort.c
type SV (line 77) | typedef SV * gptr;
function IV (line 195) | static IV
type off_runs (line 348) | typedef struct {
function I32 (line 354) | static I32
function STATIC (line 360) | STATIC void
type partition_stack_entry (line 664) | struct partition_stack_entry {
function break_here (line 722) | static void
function doqsort_all_asserts (line 730) | static void
function STATIC (line 768) | STATIC void /* the standard unstable (u) quicksort (qsort) */
function I32 (line 1324) | static I32
function I32 (line 1336) | static I32
function STATIC (line 1351) | STATIC void
function Perl_sortsv (line 1444) | void
function S_sortsv_desc (line 1470) | void
function PP (line 1495) | PP(pp_sort)
function I32 (line 1724) | static I32
function I32 (line 1747) | static I32
function I32 (line 1792) | static I32
function I32 (line 1821) | static I32
function I32 (line 1829) | static I32
function I32 (line 1847) | static I32
function I32 (line 1869) | static I32
function I32 (line 1891) | static I32
function I32 (line 1913) | static I32
FILE: tests/perlbench/pp_sys.c
type passwd (line 86) | struct passwd
type passwd (line 87) | struct passwd
type passwd (line 92) | struct passwd
type passwd (line 94) | struct passwd
type group (line 103) | struct group
type group (line 104) | struct group
type group (line 108) | struct group
function STATIC (line 239) | STATIC int
function STATIC (line 307) | STATIC int
function PP (line 316) | PP(pp_backtick)
function PP (line 386) | PP(pp_glob)
function PP (line 424) | PP(pp_rcatline)
function PP (line 430) | PP(pp_warn)
function PP (line 461) | PP(pp_die)
function PP (line 523) | PP(pp_open)
function PP (line 574) | PP(pp_close)
function PP (line 603) | PP(pp_pipe_op)
function PP (line 659) | PP(pp_fileno)
function PP (line 697) | PP(pp_umask)
function PP (line 722) | PP(pp_binmode)
function PP (line 782) | PP(pp_tie)
function PP (line 872) | PP(pp_untie)
function PP (line 911) | PP(pp_tied)
function PP (line 932) | PP(pp_dbmopen)
function PP (line 989) | PP(pp_dbmclose)
function PP (line 994) | PP(pp_sselect)
function Perl_setdefout (line 1149) | void
function PP (line 1159) | PP(pp_select)
function PP (line 1193) | PP(pp_getc)
function PP (line 1244) | PP(pp_read)
function STATIC (line 1249) | STATIC OP *
function PP (line 1267) | PP(pp_enterwrite)
function PP (line 1311) | PP(pp_leavewrite)
function PP (line 1439) | PP(pp_prtf)
function PP (line 1513) | PP(pp_sysopen)
function PP (line 1543) | PP(pp_sysread)
function PP (line 1797) | PP(pp_syswrite)
function PP (line 1811) | PP(pp_send)
function PP (line 1948) | PP(pp_recv)
function PP (line 1953) | PP(pp_eof)
function PP (line 2000) | PP(pp_tell)
function PP (line 2033) | PP(pp_seek)
function PP (line 2038) | PP(pp_sysseek)
function PP (line 2092) | PP(pp_truncate)
function PP (line 2187) | PP(pp_fcntl)
function PP (line 2192) | PP(pp_ioctl)
function PP (line 2267) | PP(pp_flock)
function PP (line 2307) | PP(pp_socket)
function PP (line 2360) | PP(pp_sockpair)
function PP (line 2425) | PP(pp_bind)
function PP (line 2484) | PP(pp_connect)
function PP (line 2514) | PP(pp_listen)
function PP (line 2540) | PP(pp_accept)
function PP (line 2611) | PP(pp_shutdown)
function PP (line 2635) | PP(pp_gsockopt)
function PP (line 2644) | PP(pp_ssockopt)
function PP (line 2716) | PP(pp_getsockname)
function PP (line 2725) | PP(pp_getpeername)
function PP (line 2791) | PP(pp_lstat)
function PP (line 2796) | PP(pp_stat)
function PP (line 2917) | PP(pp_ftrread)
function PP (line 2944) | PP(pp_ftrwrite)
function PP (line 2971) | PP(pp_ftrexec)
function PP (line 2998) | PP(pp_fteread)
function PP (line 3025) | PP(pp_ftewrite)
function PP (line 3052) | PP(pp_fteexec)
function PP (line 3079) | PP(pp_ftis)
function PP (line 3088) | PP(pp_fteowned)
function PP (line 3093) | PP(pp_ftrowned)
function PP (line 3105) | PP(pp_ftzero)
function PP (line 3116) | PP(pp_ftsize)
function PP (line 3130) | PP(pp_ftmtime)
function PP (line 3140) | PP(pp_ftatime)
function PP (line 3150) | PP(pp_ftctime)
function PP (line 3160) | PP(pp_ftsock)
function PP (line 3171) | PP(pp_ftchr)
function PP (line 3182) | PP(pp_ftblk)
function PP (line 3193) | PP(pp_ftfile)
function PP (line 3204) | PP(pp_ftdir)
function PP (line 3215) | PP(pp_ftpipe)
function PP (line 3226) | PP(pp_ftlink)
function PP (line 3237) | PP(pp_ftsuid)
function PP (line 3251) | PP(pp_ftsgid)
function PP (line 3265) | PP(pp_ftsvtx)
function PP (line 3279) | PP(pp_fttty)
function PP (line 3315) | PP(pp_fttext)
function PP (line 3469) | PP(pp_ftbinary)
function PP (line 3476) | PP(pp_chdir)
function PP (line 3517) | PP(pp_chown)
function PP (line 3531) | PP(pp_chroot)
function PP (line 3545) | PP(pp_unlink)
function PP (line 3555) | PP(pp_chmod)
function PP (line 3565) | PP(pp_utime)
function PP (line 3575) | PP(pp_rename)
function PP (line 3602) | PP(pp_link)
function PP (line 3617) | PP(pp_symlink)
function PP (line 3632) | PP(pp_readlink)
function STATIC (line 3659) | STATIC int
function PP (line 3765) | PP(pp_mkdir)
function PP (line 3797) | PP(pp_rmdir)
function PP (line 3818) | PP(pp_open_dir)
function PP (line 3845) | PP(pp_readdir)
function PP (line 3896) | PP(pp_telldir)
function PP (line 3924) | PP(pp_seekdir)
function PP (line 3947) | PP(pp_rewinddir)
function PP (line 3968) | PP(pp_closedir)
function PP (line 4000) | PP(pp_fork)
function PP (line 4044) | PP(pp_wait)
function PP (line 4072) | PP(pp_waitpid)
function PP (line 4104) | PP(pp_system)
function PP (line 4238) | PP(pp_exec)
function PP (line 4290) | PP(pp_kill)
function PP (line 4304) | PP(pp_getppid)
function PP (line 4319) | PP(pp_getpgrp)
function PP (line 4344) | PP(pp_setpgrp)
function PP (line 4376) | PP(pp_getpriority)
function PP (line 4389) | PP(pp_setpriority)
function PP (line 4406) | PP(pp_time)
function PP (line 4417) | PP(pp_tms)
function PP (line 4454) | PP(pp_localtime)
function PP (line 4459) | PP(pp_gmtime)
function PP (line 4514) | PP(pp_alarm)
function PP (line 4531) | PP(pp_sleep)
function PP (line 4552) | PP(pp_shmget)
function PP (line 4557) | PP(pp_shmctl)
function PP (line 4562) | PP(pp_shmread)
function PP (line 4567) | PP(pp_shmwrite)
function PP (line 4582) | PP(pp_msgget)
function PP (line 4587) | PP(pp_msgctl)
function PP (line 4592) | PP(pp_msgsnd)
function PP (line 4605) | PP(pp_msgrcv)
function PP (line 4620) | PP(pp_semget)
function PP (line 4635) | PP(pp_semctl)
function PP (line 4655) | PP(pp_semop)
function PP (line 4670) | PP(pp_ghbyname)
function PP (line 4679) | PP(pp_ghbyaddr)
function PP (line 4688) | PP(pp_ghostent)
function PP (line 4787) | PP(pp_gnbyname)
function PP (line 4796) | PP(pp_gnbyaddr)
function PP (line 4805) | PP(pp_gnetent)
function PP (line 4888) | PP(pp_gpbyname)
function PP (line 4897) | PP(pp_gpbynumber)
function PP (line 4906) | PP(pp_gprotoent)
function PP (line 4975) | PP(pp_gsbyname)
function PP (line 4984) | PP(pp_gsbyport)
function PP (line 4993) | PP(pp_gservent)
function PP (line 5086) | PP(pp_shostent)
function PP (line 5097) | PP(pp_snetent)
function PP (line 5108) | PP(pp_sprotoent)
function PP (line 5119) | PP(pp_sservent)
function PP (line 5130) | PP(pp_ehostent)
function PP (line 5142) | PP(pp_enetent)
function PP (line 5154) | PP(pp_eprotoent)
function PP (line 5166) | PP(pp_eservent)
function PP (line 5178) | PP(pp_gpwnam)
function PP (line 5187) | PP(pp_gpwuid)
function PP (line 5196) | PP(pp_gpwent)
function PP (line 5433) | PP(pp_spwent)
function PP (line 5444) | PP(pp_epwent)
function PP (line 5455) | PP(pp_ggrnam)
function PP (line 5464) | PP(pp_ggrgid)
function PP (line 5473) | PP(pp_ggrent)
function PP (line 5546) | PP(pp_sgrent)
function PP (line 5557) | PP(pp_egrent)
function PP (line 5568) | PP(pp_getlogin)
function PP (line 5585) | PP(pp_syscall)
function fcntl_emulate_flock (line 5688) | static int
function lockf_emulate_flock (line 5745) | static int
FILE: tests/perlbench/ppport.h
type NVTYPE (line 3058) | typedef NVTYPE NV;
function SV (line 3342) | SV*
function SV (line 3383) | SV *
function SV (line 3711) | SV *
type lconv (line 4341) | struct lconv
function UV (line 4594) | UV
function UV (line 4696) | UV
function UV (line 4798) | UV
FILE: tests/perlbench/proto.h
type IPerlMem (line 21) | struct IPerlMem
type IPerlMem (line 21) | struct IPerlMem
type IPerlMem (line 21) | struct IPerlMem
type IPerlEnv (line 21) | struct IPerlEnv
type IPerlStdIO (line 21) | struct IPerlStdIO
type IPerlLIO (line 21) | struct IPerlLIO
type IPerlDir (line 21) | struct IPerlDir
type IPerlSock (line 21) | struct IPerlSock
type IPerlProc (line 21) | struct IPerlProc
type IPerlMem (line 33) | struct IPerlMem
type IPerlMem (line 33) | struct IPerlMem
type IPerlMem (line 33) | struct IPerlMem
type IPerlEnv (line 33) | struct IPerlEnv
type IPerlStdIO (line 33) | struct IPerlStdIO
type IPerlLIO (line 33) | struct IPerlLIO
type IPerlDir (line 33) | struct IPerlDir
type IPerlSock (line 33) | struct IPerlSock
type IPerlProc (line 33) | struct IPerlProc
type re_scream_pos_data_s (line 598) | struct re_scream_pos_data_s
type interp_intern (line 921) | struct interp_intern
type scan_data_t (line 1116) | struct scan_data_t
type regnode_charclass_class (line 1117) | struct regnode_charclass_class
type regnode_charclass_class (line 1119) | struct regnode_charclass_class
type regnode_charclass_class (line 1120) | struct regnode_charclass_class
type regnode_charclass_class (line 1121) | struct regnode_charclass_class
type regnode_charclass_class (line 1122) | struct regnode_charclass_class
type regnode_charclass_class (line 1122) | struct regnode_charclass_class
type scan_data_t (line 1123) | struct scan_data_t
FILE: tests/perlbench/reentr.h
type REENTR (line 602) | typedef struct {
FILE: tests/perlbench/regcomp.c
type RExC_state_t (line 121) | typedef struct RExC_state_t {
type scan_data_t (line 184) | typedef struct scan_data_t {
function FAIL2 (line 282) | int)len, RExC_precomp, ellipses); \
function STATIC (line 478) | STATIC void
function STATIC (line 521) | STATIC void
function STATIC (line 532) | STATIC int
function STATIC (line 548) | STATIC void
function STATIC (line 556) | STATIC void
function STATIC (line 568) | STATIC void
function STATIC (line 605) | STATIC void
function STATIC (line 682) | STATIC I32
function STATIC (line 1686) | STATIC I32
function Perl_reginitcolors (line 1706) | void
function regexp (line 1746) | regexp *
function STATIC (line 2145) | STATIC regnode *
function STATIC (line 2556) | STATIC regnode *
function STATIC (line 2623) | STATIC regnode *
function STATIC (line 2800) | STATIC regnode *
function STATIC (line 3359) | STATIC char *
function STATIC (line 3386) | STATIC I32
function STATIC (line 3545) | STATIC void
function STATIC (line 3572) | STATIC regnode *
function STATIC (line 4348) | STATIC char*
function STATIC (line 4382) | STATIC regnode * /* Location. */
function STATIC (line 4418) | STATIC regnode * /* Location. */
function STATIC (line 4455) | STATIC void
function STATIC (line 4466) | STATIC void
function STATIC (line 4524) | STATIC void
function STATIC (line 4553) | STATIC void
function STATIC (line 4572) | STATIC I32
function STATIC (line 4593) | STATIC regnode *
function Perl_regdump (line 4669) | void
function STATIC (line 4767) | STATIC void
function Perl_regprop (line 4783) | void
function SV (line 4966) | SV *
function Perl_pregfree (line 4988) | void
function regnode (line 5088) | regnode *
function STATIC (line 5103) | STATIC void
function Perl_save_re_context (line 5139) | void
function clear_re (line 5209) | static void
FILE: tests/perlbench/regcomp.h
type OP (line 11) | typedef OP OP_4tree;
type regnode_string (line 75) | struct regnode_string {
type regnode_1 (line 82) | struct regnode_1 {
type regnode_2 (line 89) | struct regnode_2 {
type regnode_charclass (line 100) | struct regnode_charclass {
type regnode_charclass_class (line 108) | struct regnode_charclass_class { /* has [[:blah:]] classes */
type re_scream_pos_data_s (line 363) | struct re_scream_pos_data_s
type reg_data (line 381) | struct reg_data {
type reg_substr_datum (line 387) | struct reg_substr_datum {
type reg_substr_data (line 394) | struct reg_substr_data {
FILE: tests/perlbench/regexec.c
function STATIC (line 174) | STATIC CHECKPOINT
function STATIC (line 218) | STATIC char *
function STATIC (line 280) | STATIC char *
type re_cc_state (line 291) | typedef struct re_cc_state
function I32 (line 325) | I32
function STATIC (line 338) | STATIC void
function STATIC (line 960) | STATIC char *
function I32 (line 1615) | I32
function STATIC (line 2077) | STATIC I32 /* 0 failure, 1 success */
type re_unwind_generic_t (line 2209) | typedef struct { /* XX: makes sense to enlarge it... */
type re_unwind_branch_t (line 2215) | typedef struct {
type re_unwind_t (line 2228) | typedef union re_unwind_t {
function STATIC (line 2295) | STATIC I32 /* 0 failure, 1 success */
function STATIC (line 4042) | STATIC I32
function STATIC (line 4285) | STATIC I32
function SV (line 4335) | SV *
function STATIC (line 4387) | STATIC bool
function STATIC (line 4506) | STATIC U8 *
function STATIC (line 4512) | STATIC U8 *
function STATIC (line 4536) | STATIC U8 *
function STATIC (line 4542) | STATIC U8 *
function restore_pos (line 4572) | static void
function STATIC (line 4587) | STATIC void
function STATIC (line 4609) | STATIC void
FILE: tests/perlbench/regexp.h
type regnode (line 19) | struct regnode {
type regnode (line 25) | typedef struct regnode regnode;
type reg_substr_data (line 27) | struct reg_substr_data
type reg_data (line 29) | struct reg_data
type regexp (line 31) | typedef struct regexp {
type re_scream_pos_data_s (line 129) | struct re_scream_pos_data_s
FILE: tests/perlbench/run.c
function Perl_runops_standard (line 34) | int
FILE: tests/perlbench/scope.c
function SV (line 58) | SV**
function PERL_SI (line 76) | PERL_SI *
function I32 (line 98) | I32
function Perl_push_return (line 110) | void
function OP (line 120) | OP *
function Perl_push_scope (line 129) | void
function Perl_pop_scope (line 140) | void
function Perl_markstack_grow (line 147) | void
function Perl_savestack_grow (line 158) | void
function Perl_savestack_grow_cnt (line 165) | void
function Perl_tmps_grow (line 174) | void
function Perl_free_tmps (line 186) | void
function STATIC (line 201) | STATIC SV *
function SV (line 235) | SV *
function SV (line 246) | SV*
function Perl_save_generic_svref (line 258) | void
function Perl_save_generic_pvref (line 270) | void
function Perl_save_shared_pvref (line 282) | void
function Perl_save_gp (line 291) | void
function AV (line 327) | AV *
function HV (line 354) | HV *
function Perl_save_item (line 378) | void
function Perl_save_int (line 389) | void
function Perl_save_long (line 398) | void
function Perl_save_bool (line 407) | void
function Perl_save_I32 (line 416) | void
function Perl_save_I16 (line 425) | void
function Perl_save_I8 (line 434) | void
function Perl_save_iv (line 443) | void
function Perl_save_pptr (line 455) | void
function Perl_save_vptr (line 464) | void
function Perl_save_sptr (line 473) | void
function Perl_save_padsv (line 482) | void
function SV (line 493) | SV **
function Perl_save_nogv (line 508) | void
function Perl_save_hptr (line 516) | void
function Perl_save_aptr (line 525) | void
function Perl_save_freesv (line 534) | void
function Perl_save_mortalizesv (line 542) | void
function Perl_save_freeop (line 550) | void
function Perl_save_freepv (line 558) | void
function Perl_save_clearsv (line 566) | void
function Perl_save_delete (line 575) | void
function Perl_save_list (line 585) | void
function Perl_save_destructor (line 601) | void
function Perl_save_destructor_x (line 610) | void
function Perl_save_aelem (line 619) | void
function Perl_save_helem (line 641) | void
function Perl_save_op (line 660) | void
function I32 (line 668) | I32
function Perl_leave_scope (line 685) | void
function Perl_cx_dump (line 1063) | void
FILE: tests/perlbench/scope.h
type jmpenv (line 230) | struct jmpenv {
type JMPENV (line 253) | typedef struct jmpenv JMPENV;
FILE: tests/perlbench/specrand.c
function spec_srand (line 16) | void spec_srand(int seed) {
FILE: tests/perlbench/stdio.c
function FILE (line 14) | FILE * xsfopen ( const char * path ) {
function xsfclose (line 20) | int xsfclose ( FILE * stream ) {
function xsfprintf (line 25) | int xsfprintf ( FILE * stream, const char * text ) {
FILE: tests/perlbench/sv.c
function STATIC (line 182) | STATIC SV*
function STATIC (line 230) | STATIC void
function Perl_sv_add_arena (line 273) | void
function STATIC (line 303) | STATIC SV*
function STATIC (line 325) | STATIC I32
function do_report_used (line 352) | static void
function Perl_sv_report_used (line 370) | void
function do_clean_objs (line 380) | static void
function do_clean_named_objs (line 404) | static void
function Perl_sv_clean_objs (line 430) | void
function do_clean_all (line 444) | static void
function I32 (line 462) | I32
function Perl_sv_free_arenas (line 481) | void
function Perl_report_uninit (line 616) | void
function STATIC (line 628) | STATIC XPVIV*
function STATIC (line 646) | STATIC void
function STATIC (line 658) | STATIC void
function STATIC (line 681) | STATIC XPVNV*
function STATIC (line 696) | STATIC void
function STATIC (line 708) | STATIC void
function STATIC (line 731) | STATIC XRV*
function STATIC (line 746) | STATIC void
function STATIC (line 757) | STATIC void
function STATIC (line 780) | STATIC XPV*
function STATIC (line 795) | STATIC void
function STATIC (line 806) | STATIC void
function STATIC (line 826) | STATIC XPVIV*
function STATIC (line 841) | STATIC void
function STATIC (line 852) | STATIC void
function STATIC (line 872) | STATIC XPVNV*
function STATIC (line 887) | STATIC void
function STATIC (line 898) | STATIC void
function STATIC (line 918) | STATIC XPVCV*
function STATIC (line 933) | STATIC void
function STATIC (line 944) | STATIC void
function STATIC (line 964) | STATIC XPVAV*
function STATIC (line 979) | STATIC void
function STATIC (line 990) | STATIC void
function STATIC (line 1010) | STATIC XPVHV*
function STATIC (line 1025) | STATIC void
function STATIC (line 1036) | STATIC void
function STATIC (line 1056) | STATIC XPVMG*
function STATIC (line 1071) | STATIC void
function STATIC (line 1082) | STATIC void
function STATIC (line 1102) | STATIC XPVLV*
function STATIC (line 1117) | STATIC void
function STATIC (line 1128) | STATIC void
function STATIC (line 1148) | STATIC XPVBM*
function STATIC (line 1163) | STATIC void
function STATIC (line 1174) | STATIC void
function Perl_sv_upgrade (line 1292) | bool
function Perl_sv_backoff (line 1553) | int
function Perl_sv_setiv (line 1649) | void
function Perl_sv_setiv_mg (line 1687) | void
function Perl_sv_setuv (line 1703) | void
function Perl_sv_setuv_mg (line 1731) | void
function Perl_sv_setnv (line 1761) | void
function Perl_sv_setnv_mg (line 1798) | void
function STATIC (line 1809) | STATIC void
function I32 (line 1888) | I32
function STATIC (line 1989) | STATIC int
function IV (line 2045) | IV
function UV (line 2343) | UV
function NV (line 2623) | NV
function STATIC (line 2825) | STATIC IV
function STATIC (line 2852) | STATIC UV
function Perl_sv_copypv (line 3252) | void
function Perl_sv_2bool (line 3347) | bool
function STRLEN (line 3389) | STRLEN
function STRLEN (line 3421) | STRLEN
function Perl_sv_utf8_downgrade (line 3494) | bool
function Perl_sv_utf8_encode (line 3532) | void
function Perl_sv_utf8_decode (line 3557) | bool
function Perl_sv_setsv (line 3592) | void
function Perl_sv_setsv_flags (line 3633) | void
function Perl_sv_setsv_mg (line 4090) | void
function Perl_sv_setpvn (line 4107) | void
function Perl_sv_setpvn_mg (line 4142) | void
function Perl_sv_setpv (line 4158) | void
function Perl_sv_setpv_mg (line 4186) | void
function Perl_sv_usepvn (line 4207) | void
function Perl_sv_usepvn_mg (line 4236) | void
function Perl_sv_force_normal_flags (line 4254) | void
function Perl_sv_force_normal (line 4288) | void
function Perl_sv_chop (line 4307) | void
function Perl_sv_catpvn (line 4343) | void
function Perl_sv_catpvn_flags (line 4369) | void
function Perl_sv_catpvn_mg (line 4394) | void
function Perl_sv_catsv (line 4405) | void
function Perl_sv_catsv_flags (line 4427) | void
function Perl_sv_catsv_mg (line 4472) | void
function Perl_sv_catpv (line 4488) | void
function Perl_sv_catpv_mg (line 4516) | void
function SV (line 4533) | SV *
function MAGIC (line 4564) | MAGIC *
function Perl_sv_magic (line 4648) | void
function Perl_sv_unmagic (line 4817) | int
function SV (line 4865) | SV *
function STATIC (line 4889) | STATIC void
function STATIC (line 4920) | STATIC void
function Perl_sv_insert (line 4945) | void
function Perl_sv_replace (line 5043) | void
function Perl_sv_clear (line 5084) | void
function SV (line 5295) | SV *
function Perl_sv_free (line 5314) | void
function STRLEN (line 5370) | STRLEN
function STRLEN (line 5401) | STRLEN
function STATIC (line 5445) | STATIC bool
function STATIC (line 5478) | STATIC bool
function Perl_sv_pos_u2b (line 5608) | void
function Perl_sv_pos_b2u (line 5684) | void
function I32 (line 5808) | I32
function I32 (line 5902) | I32
function I32 (line 5984) | I32
function Perl_sv_inc (line 6468) | void
function Perl_sv_dec (line 6625) | void
function SV (line 6742) | SV *
function SV (line 6766) | SV *
function SV (line 6790) | SV *
function SV (line 6813) | SV *
function SV (line 6836) | SV *
function SV (line 6860) | SV *
function SV (line 6896) | SV *
function SV (line 6918) | SV *
function SV (line 6931) | SV *
function SV (line 6949) | SV *
function SV (line 6968) | SV *
function SV (line 6987) | SV *
function SV (line 7006) | SV *
function SV (line 7023) | SV *
function SV (line 7038) | SV *
function Perl_sv_reset (line 7067) | void
function IO (line 7157) | IO*
function CV (line 7200) | CV *
function I32 (line 7283) | I32
function IV (line 7318) | IV
function UV (line 7338) | UV
function NV (line 7358) | NV
function Perl_sv_isobject (line 7642) | int
function Perl_sv_isa (line 7667) | int
function SV (line 7696) | SV*
function SV (line 7753) | SV*
function SV (line 7777) | SV*
function SV (line 7796) | SV*
function SV (line 7815) | SV*
function SV (line 7837) | SV*
function SV (line 7854) | SV*
function STATIC (line 7893) | STATIC void
function Perl_sv_unref_flags (line 7934) | void
function Perl_sv_unref (line 7966) | void
function Perl_sv_taint (line 7979) | void
function Perl_sv_untaint (line 7992) | void
function Perl_sv_tainted (line 8009) | bool
function Perl_sv_setpviv (line 8029) | void
function Perl_sv_setpviv_mg (line 8047) | void
function Perl_sv_setpvf_nocontext (line 8065) | void
function Perl_sv_setpvf_mg_nocontext (line 8080) | void
function Perl_sv_setpvf (line 8100) | void
function Perl_sv_vsetpvf (line 8120) | void
function Perl_sv_setpvf_mg (line 8134) | void
function Perl_sv_vsetpvf_mg (line 8153) | void
function Perl_sv_catpvf_nocontext (line 8167) | void
function Perl_sv_catpvf_mg_nocontext (line 8182) | void
function Perl_sv_catpvf (line 8206) | void
function Perl_sv_vcatpvf (line 8226) | void
function Perl_sv_catpvf_mg (line 8240) | void
function Perl_sv_vcatpvf_mg (line 8259) | void
function Perl_sv_vsetpvfn (line 8277) | void
function STATIC (line 8286) | STATIC I32
function Perl_sv_vcatpvfn (line 8342) | void
function REGEXP (line 9397) | REGEXP *
function PerlIO (line 9498) | PerlIO *
function DIR (line 9518) | DIR *
function GP (line 9529) | GP *
function MAGIC (line 9562) | MAGIC *
function PTR_TBL_t (line 9633) | PTR_TBL_t *
function STATIC (line 9652) | STATIC void
function ptr_tbl_ent (line 9672) | ptr_tbl_ent*
function STATIC (line 9683) | STATIC void
function Perl_ptr_table_store (line 9708) | void
function Perl_ptr_table_split (line 9738) | void
function Perl_ptr_table_clear (line 9770) | void
function Perl_ptr_table_free (line 9806) | void
function STATIC (line 9823) | STATIC SV *
function Perl_rvpv_dup (line 9880) | void
function SV (line 9925) | SV *
function PERL_CONTEXT (line 10250) | PERL_CONTEXT *
function PERL_SI (line 10338) | PERL_SI *
function ANY (line 10416) | ANY *
function do_mark_cloneable_stash (line 10681) | static void
function PerlInterpreter (line 10774) | PerlInterpreter *
function Perl_sv_cat_decode (line 11658) | bool
FILE: tests/perlbench/sv.h
type svtype (line 46) | typedef enum {
type STRUCT_SV (line 67) | struct STRUCT_SV { /* struct sv { */
type gv (line 73) | struct gv {
type cv (line 79) | struct cv {
type av (line 85) | struct av {
type hv (line 91) | struct hv {
type io (line 97) | struct io {
type xrv (line 245) | struct xrv {
type xpv (line 249) | struct xpv {
type xpviv (line 255) | struct xpviv {
type xpvuv (line 262) | struct xpvuv {
type xpvnv (line 269) | struct xpvnv {
type xpvmg (line 278) | struct xpvmg {
type xpvlv (line 288) | struct xpvlv {
type xpvgv (line 304) | struct xpvgv {
type xpvbm (line 320) | struct xpvbm {
type U16 (line 336) | typedef U16 cv_flags_t;
type xpvfm (line 338) | struct xpvfm {
type xpvio (line 368) | struct xpvio {
type clone_params (line 1261) | struct clone_params {
FILE: tests/perlbench/taint.c
function Perl_taint_proper (line 24) | void
function Perl_taint_env (line 72) | void
FILE: tests/perlbench/thread.h
type condpair_t (line 408) | typedef struct condpair {
FILE: tests/perlbench/toke.c
function STATIC (line 188) | STATIC void
function STATIC (line 215) | STATIC int
function STATIC (line 242) | STATIC void
function STATIC (line 283) | STATIC void
function Perl_deprecate (line 318) | void
function Perl_deprecate_old (line 325) | void
function STATIC (line 346) | STATIC void
function strip_return (line 358) | static void
function STATIC (line 380) | STATIC I32
function Perl_lex_start (line 396) | void
function Perl_lex_end (line 474) | void
function STATIC (line 490) | STATIC void
function STATIC (line 547) | STATIC char *
function STATIC (line 668) | STATIC void
function STATIC (line 706) | STATIC I32
function STATIC (line 736) | STATIC void
function STATIC (line 764) | STATIC char *
function STATIC (line 805) | STATIC void
function NV (line 827) | NV
function STATIC (line 860) | STATIC char *
function STATIC (line 904) | STATIC SV *
function STATIC (line 977) | STATIC I32
function STATIC (line 1031) | STATIC I32
function STATIC (line 1089) | STATIC I32
function STATIC (line 1216) | STATIC char *
function STATIC (line 1733) | STATIC int
function STATIC (line 1887) | STATIC int
function STATIC (line 1958) | STATIC char*
function SV (line 1990) | SV *
function Perl_filter_del (line 2013) | void
function I32 (line 2036) | I32
function STATIC (line 2092) | STATIC char *
function STATIC (line 2112) | STATIC HV *
function Perl_yylex_r (line 2171) | int
function S_pending_ident (line 5284) | static int
function I32 (line 5420) | I32
function STATIC (line 8710) | STATIC void
function STATIC (line 8760) | STATIC SV *
function STATIC (line 8856) | STATIC char *
function STATIC (line 8893) | STATIC char *
function Perl_pmflag (line 9050) | void
function STATIC (line 9069) | STATIC char *
function STATIC (line 9104) | STATIC char *
function STATIC (line 9174) | STATIC char *
function STATIC (line 9231) | STATIC char *
function STATIC (line 9450) | STATIC char *
function STATIC (line 9637) | STATIC char *
function STATIC (line 10315) | STATIC char *
function STATIC (line 10410) | STATIC void
function I32 (line 10419) | I32
function Perl_yywarn (line 10452) | int
function else (line 10507) | else if (yychar == -2) {
function STATIC (line 10562) | STATIC char*
function restore_rsfp (line 10662) | static void
function I32 (line 10675) | static I32
function I32 (line 10696) | static I32
FILE: tests/perlbench/tokenpos.h
type token_pos (line 1) | struct token_pos
type token_pos_t (line 6) | typedef struct token_pos token_pos_t;
function tokens_grow (line 29) | static void
FILE: tests/perlbench/universal.c
function STATIC (line 34) | STATIC SV *
function Perl_sv_derived_from (line 137) | bool
function Perl_boot_core_UNIVERSAL (line 191) | void
function XS (line 220) | XS(XS_UNIVERSAL_isa)
function XS (line 245) | XS(XS_UNIVERSAL_can)
function XS (line 288) | XS(XS_UNIVERSAL_VERSION)
function XS (line 383) | XS(XS_utf8_is_utf8)
function XS (line 400) | XS(XS_utf8_valid)
function XS (line 419) | XS(XS_utf8_encode)
function XS (line 432) | XS(XS_utf8_decode)
function XS (line 448) | XS(XS_utf8_upgrade)
function XS (line 464) | XS(XS_utf8_downgrade)
function XS (line 487) | XS(XS_utf8_native_to_unicode)
function XS (line 499) | XS(XS_utf8_unicode_to_native)
function XS (line 511) | XS(XS_Internals_SvREADONLY) /* This is dangerous stuff. */
function XS (line 535) | XS(XS_Internals_SvREFCNT) /* This is dangerous stuff. */
function XS (line 549) | XS(XS_Internals_hv_clear_placehold)
function XS (line 559) | XS(XS_Regexp_DESTROY)
function XS (line 564) | XS(XS_PerlIO_get_layers)
function XS (line 689) | XS(XS_Internals_hash_seed)
function XS (line 697) | XS(XS_Internals_rehash_seed)
function XS (line 705) | XS(XS_Internals_HvREHASH) /* Subject to change */
FILE: tests/perlbench/utf8.c
function U8 (line 169) | U8 *
function STRLEN (line 185) | STRLEN
function Perl_is_utf8_string (line 235) | bool
function Perl_is_utf8_string_loc (line 275) | bool
function UV (line 339) | UV
function UV (line 552) | UV
function UV (line 575) | UV
function STRLEN (line 593) | STRLEN
function IV (line 644) | IV
function U8 (line 706) | U8 *
function U8 (line 738) | U8 *
function U8 (line 781) | U8 *
function U8 (line 835) | U8*
function U8 (line 866) | U8*
function U8 (line 922) | U8*
function Perl_is_uni_alnum (line 938) | bool
function Perl_is_uni_alnumc (line 946) | bool
function Perl_is_uni_idfirst (line 954) | bool
function Perl_is_uni_alpha (line 962) | bool
function Perl_is_uni_ascii (line 970) | bool
function Perl_is_uni_space (line 978) | bool
function Perl_is_uni_digit (line 986) | bool
function Perl_is_uni_upper (line 994) | bool
function Perl_is_uni_lower (line 1002) | bool
function Perl_is_uni_cntrl (line 1010) | bool
function Perl_is_uni_graph (line 1018) | bool
function Perl_is_uni_print (line 1026) | bool
function Perl_is_uni_punct (line 1034) | bool
function Perl_is_uni_xdigit (line 1042) | bool
function UV (line 1050) | UV
function UV (line 1057) | UV
function UV (line 1064) | UV
function UV (line 1071) | UV
function Perl_is_uni_alnum_lc (line 1080) | bool
function Perl_is_uni_alnumc_lc (line 1086) | bool
function Perl_is_uni_idfirst_lc (line 1092) | bool
function Perl_is_uni_alpha_lc (line 1098) | bool
function Perl_is_uni_ascii_lc (line 1104) | bool
function Perl_is_uni_space_lc (line 1110) | bool
function Perl_is_uni_digit_lc (line 1116) | bool
function Perl_is_uni_upper_lc (line 1122) | bool
function Perl_is_uni_lower_lc (line 1128) | bool
function Perl_is_uni_cntrl_lc (line 1134) | bool
function Perl_is_uni_graph_lc (line 1140) | bool
function Perl_is_uni_print_lc (line 1146) | bool
function Perl_is_uni_punct_lc (line 1152) | bool
function Perl_is_uni_xdigit_lc (line 1158) | bool
function U32 (line 1164) | U32
function U32 (line 1174) | U32
function U32 (line 1184) | U32
function Perl_is_utf8_alnum (line 1194) | bool
function Perl_is_utf8_alnumc (line 1214) | bool
function Perl_is_utf8_idfirst (line 1231) | bool
function Perl_is_utf8_idcont (line 1243) | bool
function Perl_is_utf8_alpha (line 1255) | bool
function Perl_is_utf8_ascii (line 1265) | bool
function Perl_is_utf8_space (line 1275) | bool
function Perl_is_utf8_digit (line 1285) | bool
function Perl_is_utf8_upper (line 1295) | bool
function Perl_is_utf8_lower (line 1305) | bool
function Perl_is_utf8_cntrl (line 1315) | bool
function Perl_is_utf8_graph (line 1325) | bool
function Perl_is_utf8_print (line 1335) | bool
function Perl_is_utf8_punct (line 1345) | bool
function Perl_is_utf8_xdigit (line 1355) | bool
function Perl_is_utf8_mark (line 1365) | bool
function UV (line 1400) | UV
function UV (line 1501) | UV
function UV (line 1521) | UV
function UV (line 1541) | UV
function UV (line 1562) | UV
function SV (line 1571) | SV*
function UV (line 1644) | UV
function U8 (line 1796) | U8 *
function U8 (line 1802) | U8 *
function UV (line 1823) | UV
function I32 (line 1947) | I32
FILE: tests/perlbench/util.c
function Malloc_t (line 70) | Malloc_t
function Malloc_t (line 105) | Malloc_t
function Free_t (line 154) | Free_t
function Malloc_t (line 169) | Malloc_t
function Malloc_t (line 211) | Malloc_t Perl_malloc (MEM_SIZE nbytes)
function Malloc_t (line 217) | Malloc_t Perl_calloc (MEM_SIZE elements, MEM_SIZE size)
function Malloc_t (line 223) | Malloc_t Perl_realloc (Malloc_t where, MEM_SIZE nbytes)
function Free_t (line 229) | Free_t Perl_mfree (Malloc_t where)
function Perl_fbm_compile (line 373) | void
function I32 (line 729) | I32
function I32 (line 742) | I32
function STATIC (line 867) | STATIC SV *
function SV (line 943) | SV *
function SV (line 956) | SV *
function STATIC (line 967) | STATIC COP*
function SV (line 998) | SV *
function Perl_write_to_stderr (line 1039) | void
function S_vdie_common (line 1119) | void
function OP (line 1160) | OP *
function OP (line 1185) | OP *
function OP (line 1198) | OP *
function Perl_vcroak (line 1209) | void
function Perl_croak_nocontext (line 1231) | void
function Perl_croak (line 1263) | void
function Perl_vwarn (line 1273) | void
function Perl_warn_nocontext (line 1322) | void
function Perl_warn (line 1342) | void
function Perl_warner_nocontext (line 1352) | void
function Perl_warner (line 1363) | void
function Perl_vwarner (line 1372) | void
function Perl_my_setenv (line 1488) | void
function I32 (line 1507) | I32
function I32 (line 1529) | I32
function I32 (line 1588) | I32
function vsprintf (line 1608) | int
function Perl_my_swap (line 1633) | short
function Perl_my_htonl (line 1646) | long
function Perl_my_ntohl (line 1675) | long
function Perl_my_swabn (line 1941) | void
function PerlIO (line 1955) | PerlIO *
function PerlIO (line 2089) | PerlIO *
function PerlIO (line 2237) | PerlIO *
function PerlIO (line 2250) | PerlIO *
function Perl_atfork_lock (line 2266) | void
function Perl_atfork_unlock (line 2279) | void
function Pid_t (line 2291) | Pid_t
function Perl_dump_fds (line 2314) | void
function dup2 (line 2330) | int
function Sighandler_t (line 2371) | Sighandler_t
function Sighandler_t (line 2399) | Sighandler_t
function Perl_rsignal_save (line 2410) | int
function Perl_rsignal_restore (line 2435) | int
function Sighandler_t (line 2449) | Sighandler_t
function Signal_t (line 2464) | static
function Sighandler_t (line 2471) | Sighandler_t
function Perl_rsignal_save (line 2490) | int
function Perl_rsignal_restore (line 2502) | int
function I32 (line 2518) | I32
function I32 (line 2580) | I32
function Perl_pidgone (line 2649) | void
function I32 (line 2670) | I32
function I32 (line 2684) | I32
function Perl_repeatcpy (line 2696) | void
function I32 (line 2717) | I32
function Perl_set_context (line 3011) | void
function schedule (line 3030) | void
function Perl_cond_init (line 3036) | void
function Perl_cond_signal (line 3042) | void
function Perl_cond_broadcast (line 3062) | void
function Perl_cond_wait (line 3083) | void
function MAGIC (line 3102) | MAGIC *
function SV (line 3140) | SV *
type perl_thread (line 3176) | struct perl_thread
type perl_thread (line 3180) | struct perl_thread
type perl_thread (line 3187) | struct perl_thread
type perl_thread (line 3188) | struct perl_thread
type perl_vars (line 3305) | struct perl_vars
function U32 (line 3330) | U32 *
function PPADDR_t (line 3336) | PPADDR_t*
function MGVTBL (line 3354) | MGVTBL*
function I32 (line 3461) | I32
function Perl_report_evil_fh (line 3511) | void
function Perl_ebcdic_control (line 3582) | int
function Perl_init_tm (line 3640) | void
function Perl_mini_mktime (line 3657) | void
type tm (line 3856) | struct tm
type tm (line 3873) | struct tm
function Perl_getcwd_sv (line 3956) | int
function S_socketpair_udp (line 4108) | static int
function Perl_my_socketpair (line 4249) | int
function Perl_my_socketpair (line 4347) | int
function Perl_sv_nosharing (line 4368) | void
function Perl_sv_nolocking (line 4383) | void
function Perl_sv_nounlocking (line 4399) | void
function U32 (line 4404) | U32
function U32 (line 4458) | U32
function UV (line 4546) | UV
FILE: tests/perlbench/win32/dirent.h
type _DIRECT (line 25) | typedef struct direct
type DIR (line 33) | typedef struct _dir_struc
type direct (line 46) | struct direct
FILE: tests/perlbench/win32/perlhost.h
function END_EXTERN_C (line 25) | END_EXTERN_C
type interpreter (line 223) | struct interpreter
function CPerlHost (line 227) | inline CPerlHost* CheckInterp(CPerlHost *host)
function CPerlHost (line 237) | inline CPerlHost* IPerlMem2Host(struct IPerlMem* piPerl)
function CPerlHost (line 242) | inline CPerlHost* IPerlMemShared2Host(struct IPerlMem* piPerl)
function CPerlHost (line 247) | inline CPerlHost* IPerlMemParse2Host(struct IPerlMem* piPerl)
function CPerlHost (line 252) | inline CPerlHost* IPerlEnv2Host(struct IPerlEnv* piPerl)
function CPerlHost (line 257) | inline CPerlHost* IPerlStdIO2Host(struct IPerlStdIO* piPerl)
function CPerlHost (line 262) | inline CPerlHost* IPerlLIO2Host(struct IPerlLIO* piPerl)
function CPerlHost (line 267) | inline CPerlHost* IPerlDir2Host(struct IPerlDir* piPerl)
function CPerlHost (line 272) | inline CPerlHost* IPerlSock2Host(struct IPerlSock* piPerl)
function CPerlHost (line 277) | inline CPerlHost* IPerlProc2Host(struct IPerlProc* piPerl)
type IPerlMem (line 289) | struct IPerlMem
type IPerlMem (line 294) | struct IPerlMem
function PerlMemFree (line 298) | void
type IPerlMem (line 304) | struct IPerlMem
function PerlMemGetLock (line 309) | void
function PerlMemFreeLock (line 315) | void
function PerlMemIsLocked (line 321) | int
type IPerlMem (line 327) | struct IPerlMem
type IPerlMem (line 343) | struct IPerlMem
type IPerlMem (line 348) | struct IPerlMem
function PerlMemSharedFree (line 352) | void
type IPerlMem (line 358) | struct IPerlMem
function PerlMemSharedGetLock (line 363) | void
function PerlMemSharedFreeLock (line 369) | void
function PerlMemSharedIsLocked (line 375) | int
type IPerlMem (line 381) | struct IPerlMem
type IPerlMem (line 397) | struct IPerlMem
type IPerlMem (line 402) | struct IPerlMem
function PerlMemParseFree (line 406) | void
type IPerlMem (line 412) | struct IPerlMem
function PerlMemParseGetLock (line 417) | void
function PerlMemParseFreeLock (line 423) | void
function PerlMemParseIsLocked (line 429) | int
type IPerlMem (line 435) | struct IPerlMem
type IPerlEnv (line 452) | struct IPerlEnv
function PerlEnvPutenv (line 457) | int
type IPerlEnv (line 464) | struct IPerlEnv
function PerlEnvUname (line 469) | int
function PerlEnvClearenv (line 475) | void
type IPerlEnv (line 482) | struct IPerlEnv
function PerlEnvFreeChildenv (line 487) | void
type IPerlEnv (line 494) | struct IPerlEnv
function PerlEnvFreeChilddir (line 499) | void
function PerlEnvOsId (line 505) | unsigned long
type IPerlEnv (line 512) | struct IPerlEnv
type IPerlEnv (line 518) | struct IPerlEnv
type IPerlEnv (line 524) | struct IPerlEnv
function PerlEnvGetChildIO (line 529) | void
type IPerlEnv (line 535) | struct IPerlEnv
function FILE (line 557) | FILE*
function FILE (line 563) | FILE*
function FILE (line 569) | FILE*
function FILE (line 575) | FILE*
function PerlStdIOClose (line 581) | int
function PerlStdIOEof (line 587) | int
function PerlStdIOError (line 593) | int
function PerlStdIOClearerr (line 599) | void
function PerlStdIOGetc (line 605) | int
type IPerlStdIO (line 612) | struct IPerlStdIO
function PerlStdIOGetBufsiz (line 622) | int
function PerlStdIOGetCnt (line 633) | int
type IPerlStdIO (line 645) | struct IPerlStdIO
type IPerlStdIO (line 656) | struct IPerlStdIO
function PerlStdIOPutc (line 661) | int
function PerlStdIOPuts (line 667) | int
function PerlStdIOFlush (line 673) | int
function PerlStdIOUngetc (line 679) | int
function PerlStdIOFileno (line 685) | int
function FILE (line 691) | FILE*
function FILE (line 697) | FILE*
function SSize_t (line 703) | SSize_t
function SSize_t (line 709) | SSize_t
function PerlStdIOSetBuf (line 715) | void
function PerlStdIOSetVBuf (line 721) | int
function PerlStdIOSetCnt (line 727) | void
function PerlStdIOSetPtr (line 736) | void
function PerlStdIOSetlinebuf (line 745) | void
function PerlStdIOPrintf (line 751) | int
function PerlStdIOVprintf (line 759) | int
function Off_t (line 765) | Off_t
function PerlStdIOSeek (line 771) | int
function PerlStdIORewind (line 777) | void
function FILE (line 783) | FILE*
function PerlStdIOGetpos (line 789) | int
function PerlStdIOSetpos (line 795) | int
function PerlStdIOInit (line 800) | void
function PerlStdIOInitOSExtras (line 805) | void
function PerlStdIOOpenOSfhandle (line 811) | int
function PerlStdIOGetOSfhandle (line 817) | intptr_t
function FILE (line 823) | FILE*
type IPerlStdIO (line 875) | struct IPerlStdIO
function PerlLIOAccess (line 923) | int
function PerlLIOChmod (line 929) | int
function PerlLIOChown (line 935) | int
function PerlLIOChsize (line 941) | int
function PerlLIOClose (line 947) | int
function PerlLIODup (line 953) | int
function PerlLIODup2 (line 959) | int
function PerlLIOFlock (line 965) | int
function PerlLIOFileStat (line 971) | int
function PerlLIOIOCtl (line 977) | int
function PerlLIOIsatty (line 983) | int
function PerlLIOLink (line 989) | int
function Off_t (line 995) | Off_t
function PerlLIOLstat (line 1001) | int
type IPerlLIO (line 1008) | struct IPerlLIO
function PerlLIOOpen (line 1013) | int
function PerlLIOOpen3 (line 1019) | int
function PerlLIORead (line 1025) | int
function PerlLIORename (line 1031) | int
function PerlLIOSetmode (line 1037) | int
function PerlLIONameStat (line 1043) | int
type IPerlLIO (line 1050) | struct IPerlLIO
function PerlLIOUmask (line 1055) | int
function PerlLIOUnlink (line 1061) | int
function PerlLIOUtime (line 1067) | int
function PerlLIOWrite (line 1073) | int
type IPerlLIO (line 1079) | struct IPerlLIO
function PerlDirMakedir (line 1114) | int
function PerlDirChdir (line 1120) | int
function PerlDirRmdir (line 1126) | int
function PerlDirClose (line 1132) | int
function DIR (line 1138) | DIR*
type direct (line 1144) | struct direct
type IPerlDir (line 1145) | struct IPerlDir
function PerlDirRewind (line 1150) | void
function PerlDirSeek (line 1156) | void
function PerlDirTell (line 1162) | long
type IPerlDir (line 1169) | struct IPerlDir
function WCHAR (line 1174) | WCHAR*
type IPerlDir (line 1180) | struct IPerlDir
function u_long (line 1197) | u_long
function u_short (line 1203) | u_short
function u_long (line 1209) | u_long
function u_short (line 1215) | u_short
function SOCKET (line 1221) | SOCKET PerlSockAccept(struct IPerlSock* piPerl, SOCKET s, struct sockadd...
function PerlSockBind (line 1226) | int
function PerlSockConnect (line 1232) | int
function PerlSockEndhostent (line 1238) | void
function PerlSockEndnetent (line 1244) | void
function PerlSockEndprotoent (line 1250) | void
function PerlSockEndservent (line 1256) | void
type hostent (line 1262) | struct hostent
type IPerlSock (line 1263) | struct IPerlSock
type hostent (line 1268) | struct hostent
type IPerlSock (line 1269) | struct IPerlSock
type hostent (line 1274) | struct hostent
type IPerlSock (line 1275) | struct IPerlSock
function PerlSockGethostname (line 1282) | int
type netent (line 1288) | struct netent
type IPerlSock (line 1289) | struct IPerlSock
type netent (line 1294) | struct netent
type IPerlSock (line 1295) | struct IPerlSock
type netent (line 1300) | struct netent
type IPerlSock (line 1301) | struct IPerlSock
function PerlSockGetpeername (line 1306) | int PerlSockGetpeername(struct IPerlSock* piPerl, SOCKET s, struct socka...
type protoent (line 1311) | struct protoent
type IPerlSock (line 1312) | struct IPerlSock
type protoent (line 1317) | struct protoent
type IPerlSock (line 1318) | struct IPerlSock
type protoent (line 1323) | struct protoent
type IPerlSock (line 1324) | struct IPerlSock
type servent (line 1329) | struct servent
type IPerlSock (line 1330) | struct IPerlSock
type servent (line 1335) | struct servent
type IPerlSock (line 1336) | struct IPerlSock
type servent (line 1341) | struct servent
type IPerlSock (line 1342) | struct IPerlSock
function PerlSockGetsockname (line 1347) | int
function PerlSockGetsockopt (line 1353) | int
function PerlSockInetAddr (line 1359) | unsigned long
type IPerlSock (line 1366) | struct IPerlSock
type in_addr (line 1366) | struct in_addr
function PerlSockListen (line 1371) | int
function PerlSockRecv (line 1377) | int
function PerlSockRecvfrom (line 1383) | int
function PerlSockSelect (line 1389) | int
function PerlSockSend (line 1395) | int
function PerlSockSendto (line 1401) | int
function PerlSockSethostent (line 1407) | void
function PerlSockSetnetent (line 1413) | void
function PerlSockSetprotoent (line 1419) | void
function PerlSockSetservent (line 1425) | void
function PerlSockSetsockopt (line 1431) | int
function PerlSockShutdown (line 1437) | int
function SOCKET (line 1443) | SOCKET
function PerlSockSocketpair (line 1449) | int
function PerlSockClosesocket (line 1455) | int
function PerlSockIoctlsocket (line 1461) | int
type IPerlSock (line 1467) | struct IPerlSock
function PerlProcAbort (line 1521) | void
type IPerlProc (line 1528) | struct IPerlProc
function PerlProcExit (line 1533) | void
function PerlProc_Exit (line 1539) | void
function PerlProcExecl (line 1545) | int
function PerlProcExecv (line 1551) | int
function PerlProcExecvp (line 1557) | int
function uid_t (line 1563) | uid_t
function uid_t (line 1569) | uid_t
function gid_t (line 1575) | gid_t
function gid_t (line 1581) | gid_t
type IPerlProc (line 1588) | struct IPerlProc
function PerlProcKill (line 1593) | int
function PerlProcKillpg (line 1599) | int
function PerlProcPauseProc (line 1607) | int
function PerlIO (line 1613) | PerlIO*
function PerlIO (line 1621) | PerlIO*
function PerlProcPclose (line 1629) | int
function PerlProcPipe (line 1635) | int
function PerlProcSetuid (line 1641) | int
function PerlProcSetgid (line 1647) | int
function PerlProcSleep (line 1653) | int
function PerlProcTimes (line 1659) | int
function PerlProcWait (line 1665) | int
function PerlProcWaitpid (line 1671) | int
function Sighandler_t (line 1677) | Sighandler_t
function PerlProcGetTimeOfDay (line 1683) | int
function THREAD_RET_TYPE (line 1690) | static THREAD_RET_TYPE
function PerlProcFork (line 1796) | int
function PerlProcGetpid (line 1855) | int
type IPerlProc (line 1862) | struct IPerlProc
function PerlProcGetOSError (line 1867) | void
function PerlProcSpawnvp (line 1873) | int
function PerlProcLastHost (line 1879) | int
type IPerlProc (line 1887) | struct IPerlProc
type IPerlMem (line 1976) | struct IPerlMem
function LPSTR (line 2068) | LPSTR
function lookup (line 2085) | int
function compare (line 2126) | int
function Add (line 2159) | void
function DWORD (line 2195) | DWORD
function FreeLocalEnvironmentStrings (line 2206) | void
function FreeChildDir (line 2231) | void
function LPSTR (line 2238) | LPSTR
function Reset (line 2328) | void
function Clearenv (line 2343) | void
function Putenv (line 2395) | int
function Chdir (line 2406) | int
FILE: tests/perlbench/win32/perllib.c
function xs_init (line 34) | static void
function win32_checkTLS (line 51) | void
function EXTERN_C (line 62) | EXTERN_C void
function EXTERN_C (line 111) | EXTERN_C PerlInterpreter*
function EXTERN_C (line 140) | EXTERN_C PerlInterpreter*
function EXTERN_C (line 163) | EXTERN_C void
function RunPerl (line 174) | int
function BOOL (line 246) | BOOL APIENTRY
function EXTERN_C (line 300) | EXTERN_C PerlInterpreter *
FILE: tests/perlbench/win32/sys/socket.h
type Perl_fd_mask (line 33) | typedef int Perl_fd_mask;
type Perl_fd_set (line 35) | typedef struct Perl_fd_set {
type sockaddr (line 60) | struct sockaddr
type sockaddr (line 61) | struct sockaddr
type sockaddr (line 63) | struct sockaddr
type sockaddr (line 65) | struct sockaddr
type sockaddr (line 66) | struct sockaddr
type in_addr (line 71) | struct in_addr
type sockaddr (line 77) | struct sockaddr
type timeval (line 79) | struct timeval
type sockaddr (line 82) | struct sockaddr
type hostent (line 90) | struct hostent
type hostent (line 91) | struct hostent
type servent (line 93) | struct servent
type servent (line 94) | struct servent
type protoent (line 95) | struct protoent
type protoent (line 96) | struct protoent
type protoent (line 97) | struct protoent
type servent (line 98) | struct servent
type netent (line 101) | struct netent
type netent (line 102) | struct netent
type netent (line 103) | struct netent
FILE: tests/perlbench/win32/vdir.h
function class (line 19) | class VDir
function Init (line 134) | void VDir::Init(VDir* pDir, VMem *p)
function SetDirA (line 168) | int VDir::SetDirA(char const *pPath, int index)
function FromEnvA (line 202) | void VDir::FromEnvA(char *pEnv, int index)
function SetDefaultA (line 214) | void VDir::SetDefaultA(char const *pDefault)
function SetDirW (line 227) | int VDir::SetDirW(WCHAR const *pPath, int index)
function SetDefaultW (line 260) | void VDir::SetDefaultW(WCHAR const *pDefault)
function BOOL (line 273) | inline BOOL IsPathSep(char ch)
function DoGetFullPathNameA (line 278) | inline void DoGetFullPathNameA(char* lpBuffer, DWORD dwSize, char* Dest)
function IsSpecialFileName (line 292) | inline bool IsSpecialFileName(const char* pName)
function SetCurrentDirectoryA (line 440) | int VDir::SetCurrentDirectoryA(char *lpBuffer)
function DWORD (line 464) | DWORD VDir::CalculateEnvironmentSpace(void)
function LPSTR (line 476) | LPSTR VDir::BuildEnvironmentSpace(LPSTR lpStr)
function BOOL (line 501) | inline BOOL IsPathSep(WCHAR ch)
function DoGetFullPathNameW (line 506) | inline void DoGetFullPathNameW(WCHAR* lpBuffer, DWORD dwSize, WCHAR* Dest)
function IsSpecialFileName (line 520) | inline bool IsSpecialFileName(const WCHAR* pName)
function SetCurrentDirectoryW (line 667) | int VDir::SetCurrentDirectoryW(WCHAR *lpBuffer)
FILE: tests/perlbench/win32/vmem.h
function MEMODS (line 33) | inline void MEMODS(char *str)
function MEMODSlx (line 39) | inline void MEMODSlx(char *str, long x)
type _MemoryBlockHeader (line 75) | struct _MemoryBlockHeader
type MEMORY_BLOCK_HEADER (line 76) | typedef struct _MemoryBlockHeader {
function class (line 83) | class VMem
function Free (line 197) | void VMem::Free(void* pMem)
function GetLock (line 226) | void VMem::GetLock(void)
function FreeLock (line 231) | void VMem::FreeLock(void)
function IsLocked (line 236) | int VMem::IsLocked(void)
function Release (line 253) | long VMem::Release(void)
function AddRef (line 261) | long VMem::AddRef(void)
function CalcEntry (line 302) | inline size_t CalcEntry(size_t size)
type BYTE (line 309) | typedef BYTE* PBLOCK;
function SetTags (line 320) | inline void SetTags(PBLOCK block, long size)
function SetLink (line 334) | inline void SetLink(PBLOCK block, PBLOCK prev, PBLOCK next)
function Unlink (line 339) | inline void Unlink(PBLOCK p)
function AddToFreeList (line 347) | inline void AddToFreeList(PBLOCK block, PBLOCK pInList)
type FREE_LIST_ENTRY (line 371) | typedef struct _FreeListEntry
type HeapRec (line 391) | typedef struct _HeapRec
function class (line 400) | class VMem
function ReInit (line 535) | void VMem::ReInit(void)
function Init (line 554) | void VMem::Init(void)
function Free (line 810) | void VMem::Free(void* p)
function GetLock (line 871) | void VMem::GetLock(void)
function FreeLock (line 876) | void VMem::FreeLock(void)
function IsLocked (line 881) | int VMem::IsLocked(void)
function Release (line 899) | long VMem::Release(void)
function AddRef (line 907) | long VMem::AddRef(void)
function Getmem (line 914) | int VMem::Getmem(size_t requestSize)
function HeapAdd (line 1011) | int VMem::HeapAdd(void* p, size_t size
function MemoryUsageMessage (line 1174) | void VMem::MemoryUsageMessage(char *str, long x, long y, int c)
function WalkHeap (line 1192) | void VMem::WalkHeap(int complete)
FILE: tests/perlbench/win32/win32.c
function IsWin95 (line 124) | int
function IsWinNT (line 130) | int
function EXTERN_C (line 136) | EXTERN_C void
function BOOL (line 351) | static BOOL
function PerlIO (line 396) | PerlIO *
function Perl_my_pclose (line 419) | long
function win32_os_id (line 426) | DllExport unsigned long
function DllExport (line 440) | DllExport int
function tokenize (line 464) | static long
function get_shell (line 511) | static void
function Perl_do_aspawn (line 532) | int
function do_spawn2 (line 620) | static int
function Perl_do_spawn (line 711) | int
function Perl_do_spawn_nowait (line 717) | int
function Perl_do_exec (line 723) | bool
function DllExport (line 734) | DllExport DIR *
function direct (line 832) | direct *
function win32_telldir (line 896) | DllExport long
function DllExport (line 906) | DllExport void
function DllExport (line 913) | DllExport void
function DllExport (line 920) | DllExport int
function uid_t (line 946) | uid_t
function uid_t (line 952) | uid_t
function gid_t (line 958) | gid_t
function gid_t (line 964) | gid_t
function setuid (line 970) | int
function setgid (line 976) | int
function chown (line 995) | int
function mkstemp (line 1006) | int mkstemp(const char *path)
function find_pid (line 1027) | static long
function remove_dead_process (line 1039) | static void
function find_pseudo_pid (line 1054) | static long
function remove_dead_pseudo_process (line 1066) | static void
function DllExport (line 1081) | DllExport int
function DllExport (line 1185) | DllExport int
function DllExport (line 1336) | DllExport char *
function DllExport (line 1424) | DllExport char *
function DllExport (line 1475) | DllExport int
function filetime_to_clock (line 1527) | static long
function DllExport (line 1537) | DllExport int
function BOOL (line 1561) | static BOOL
function DllExport (line 1583) | DllExport int
function DllExport (line 1628) | DllExport int
type FT_t (line 1686) | typedef union {
function DllExport (line 1701) | DllExport int
function DllExport (line 1718) | DllExport int
function do_raise (line 1848) | int
function sig_terminate (line 1881) | void
function DllExport (line 1891) | DllExport int
function DllExport (line 1962) | DllExport DWORD
function win32_internal_wait (line 2003) | int
function DllExport (line 2067) | DllExport int
function DllExport (line 2150) | DllExport int
function win32_sleep (line 2156) | DllExport unsigned int
function win32_alarm (line 2176) | DllExport unsigned int
function DllExport (line 2204) | DllExport char *
function _alloc_osfhnd (line 2256) | static int
function my_open_osfhandle (line 2268) | static int
function DllExport (line 2311) | DllExport int
function DllExport (line 2359) | DllExport int *
function DllExport (line 2365) | DllExport char ***
function DllExport (line 2372) | DllExport FILE *
function DllExport (line 2378) | DllExport FILE *
function DllExport (line 2384) | DllExport FILE *
function DllExport (line 2390) | DllExport int
function DllExport (line 2397) | DllExport int
function DllExport (line 2409) | DllExport char *
function DllExport (line 2432) | DllExport void
function DllExport (line 2464) | DllExport int
function DllExport (line 2473) | DllExport int
function DllExport (line 2482) | DllExport int
function DllExport (line 2488) | DllExport int
function DllExport (line 2494) | DllExport size_t
function DllExport (line 2500) | DllExport size_t
function DllExport (line 2508) | DllExport FILE *
function DllExport (line 2539) | DllExport FILE *
function DllExport (line 2557) | DllExport FILE *
function DllExport (line 2573) | DllExport int
function DllExport (line 2579) | DllExport int
function DllExport (line 2585) | DllExport int
function DllExport (line 2591) | DllExport int
function DllExport (line 2597) | DllExport int
function DllExport (line 2603) | DllExport int
function DllExport (line 2609) | DllExport void
function DllExport (line 2616) | DllExport int
function DllExport (line 2622) | DllExport Off_t
function DllExport (line 2639) | DllExport int
function DllExport (line 2675) | DllExport int
function DllExport (line 2689) | DllExport int
function DllExport (line 2699) | DllExport void
function DllExport (line 2706) | DllExport int
function DllExport (line 2739) | DllExport FILE*
function DllExport (line 2748) | DllExport void
function DllExport (line 2755) | DllExport int
function DllExport (line 2779) | DllExport int
function DllExport (line 2785) | DllExport PerlIO*
function DllExport (line 2799) | DllExport PerlIO*
function DllExport (line 2920) | DllExport int
function BOOL (line 2959) | static BOOL WINAPI
function DllExport (line 3017) | DllExport int
function DllExport (line 3045) | DllExport int
function DllExport (line 3170) | DllExport int
function DllExport (line 3176) | DllExport int
function DllExport (line 3225) | DllExport Off_t
function DllExport (line 3251) | DllExport Off_t
function DllExport (line 3278) | DllExport int
function DllExport (line 3303) | DllExport int
function DllExport (line 3309) | DllExport int
function DllExport (line 3315) | DllExport int
function DllExport (line 3321) | DllExport int
function _fixed_read (line 3341) | int __cdecl
function DllExport (line 3523) | DllExport int
function DllExport (line 3533) | DllExport int
function DllExport (line 3539) | DllExport int
function DllExport (line 3551) | DllExport int
function DllExport (line 3563) | DllExport int
function DllExport (line 3579) | DllExport int
function DllExport (line 3591) | DllExport int
function DllExport (line 3853) | DllExport void*
function DllExport (line 3859) | DllExport void
function DllExport (line 3864) | DllExport void
function DllExport (line 3884) | DllExport char*
function DllExport (line 3904) | DllExport void
function DllExport (line 3923) | DllExport int
function DllExport (line 4085) | DllExport int
function DllExport (line 4098) | DllExport int
function DllExport (line 4118) | DllExport void
function DllExport (line 4124) | DllExport void
function DllExport (line 4130) | DllExport int
function DllExport (line 4136) | DllExport int
function DllExport (line 4142) | DllExport int
function DllExport (line 4148) | DllExport char*
function DllExport (line 4154) | DllExport char*
function DllExport (line 4160) | DllExport int
function DllExport (line 4166) | DllExport int
function DllExport (line 4172) | DllExport int
function DllExport (line 4178) | DllExport int
function DllExport (line 4184) | DllExport int
function DllExport (line 4288) | DllExport void*
function DllExport (line 4294) | DllExport void*
function DllExport (line 4300) | DllExport void*
function DllExport (line 4306) | DllExport void
function DllExport (line 4313) | DllExport int
function DllExport (line 4323) | DllExport intptr_t
function DllExport (line 4329) | DllExport FILE *
function DllExport (line 4381) | DllExport void*
function XS (line 4420) | static
function XS (line 4446) | static
function XS (line 4474) | static
function XS (line 4486) | static
function XS (line 4504) | static
function XS (line 4512) | static
function XS (line 4522) | static
function XS (line 4539) | static
function XS (line 4555) | static
function XS (line 4621) | static
function XS (line 4642) | static
function XS (line 4730) | static
function XS (line 4738) | static
function XS (line 4746) | static
function XS (line 4776) | static
function XS (line 4825) | static
function XS (line 4836) | static
function XS (line 4866) | static
function XS (line 4912) | static
function XS (line 4935) | static
function XS (line 4945) | static
function Perl_init_os_extras (line 4971) | void
function BOOL (line 5033) | BOOL WINAPI
function Perl_win32_init (line 5090) | void
function Perl_win32_term (line 5105) | void
function win32_get_child_IO (line 5112) | void
function Sighandler_t (line 5120) | Sighandler_t
function win32_csighandler (line 5144) | static void
function Perl_sys_intern_dup (line 5215) | void
function win32_free_argvw (line 5233) | static void
function win32_argv2utf8 (line 5244) | void
FILE: tests/perlbench/win32/win32.h
type tms (line 81) | struct tms {
type utsname (line 92) | struct utsname {
type uid_t (line 203) | typedef long uid_t;
type gid_t (line 204) | typedef long gid_t;
type mode_t (line 205) | typedef unsigned short mode_t;
type uid_t (line 217) | typedef long uid_t;
type gid_t (line 218) | typedef long gid_t;
type child_IO_table (line 283) | typedef struct {
type thread_intern (line 356) | struct thread_intern {
type child_tab (line 381) | typedef struct {
type Signal_t (line 388) | typedef Signal_t (*Sighandler_t) (int);
type interp_intern (line 392) | struct interp_intern {
type ioinfo (line 496) | typedef struct {
FILE: tests/perlbench/win32/win32io.c
type PerlIOWin32 (line 24) | typedef struct
function IV (line 35) | IV
function IV (line 48) | IV
function IV (line 54) | IV
function PerlIO (line 67) | PerlIO *
function SSize_t (line 211) | SSize_t
function SSize_t (line 238) | SSize_t
function IV (line 254) | IV
function Off_t (line 272) | Off_t
function IV (line 285) | IV
function PerlIO (line 307) | PerlIO *
FILE: tests/perlbench/win32/win32iop.h
type tms (line 131) | struct tms
type utimbuf (line 138) | struct utimbuf
type timeval (line 139) | struct timeval
type utsname (line 140) | struct utsname
FILE: tests/perlbench/win32/win32sck.c
type servent (line 66) | struct servent
type servent (line 66) | struct servent
type servent (line 67) | struct servent
function EXTERN_C (line 72) | EXTERN_C void
function start_sockets (line 81) | void
function set_socktype (line 105) | void
function FILE (line 121) | FILE *
function u_long (line 157) | u_long
function u_short (line 164) | u_short
function u_long (line 171) | u_long
function u_short (line 178) | u_short
function SOCKET (line 187) | SOCKET
function win32_bind (line 200) | int
function win32_connect (line 213) | int
function win32_getpeername (line 227) | int
function win32_getsockname (line 240) | int
function win32_getsockopt (line 253) | int
function win32_ioctlsocket (line 266) | int
function win32_listen (line 279) | int
function win32_recv (line 292) | int
function win32_recvfrom (line 305) | int
function win32_select (line 326) | int
function win32_send (line 398) | int
function win32_sendto (line 411) | int
function win32_setsockopt (line 425) | int
function win32_shutdown (line 438) | int
function win32_closesocket (line 451) | int
function convert_proto_info_w2a (line 467) | void
function SOCKET (line 474) | SOCKET
function SOCKET (line 531) | SOCKET
function my_close (line 561) | int my_close(int fd)
function my_fclose (line 592) | int
function my_fstat (line 625) | int
type hostent (line 682) | struct hostent
type hostent (line 688) | struct hostent
type hostent (line 695) | struct hostent
type hostent (line 701) | struct hostent
function win32_gethostname (line 708) | int
type protoent (line 721) | struct protoent
type protoent (line 727) | struct protoent
type protoent (line 734) | struct protoent
type protoent (line 740) | struct protoent
type servent (line 747) | struct servent
type servent (line 754) | struct servent
type servent (line 764) | struct servent
type servent (line 771) | struct servent
function win32_ioctl (line 781) | int
type in_addr (line 809) | struct in_addr
function win32_inet_addr (line 819) | unsigned long
function win32_endhostent (line 834) | void
function win32_endnetent (line 841) | void
function win32_endprotoent (line 848) | void
function win32_endservent (line 855) | void
type netent (line 863) | struct netent
type netent (line 868) | struct netent
type netent (line 871) | struct netent
type netent (line 876) | struct netent
type netent (line 879) | struct netent
type netent (line 884) | struct netent
type protoent (line 887) | struct protoent
type protoent (line 892) | struct protoent
type servent (line 895) | struct servent
type servent (line 900) | struct servent
function win32_sethostent (line 903) | void
function win32_setnetent (line 911) | void
function win32_setprotoent (line 919) | void
function win32_setservent (line 927) | void
type servent (line 934) | struct servent
type servent (line 935) | struct servent
type servent (line 935) | struct servent
FILE: tests/perlbench/win32/win32thread.c
function Perl_set_context (line 8) | void
function Perl_init_thread_intern (line 40) | void
function Perl_set_thread_self (line 56) | void
function Perl_thread_create (line 71) | int
FILE: tests/perlbench/win32/win32thread.h
type perl_cond (line 6) | typedef struct win32_cond { LONG waiters; HANDLE sem; } perl_cond;
type DWORD (line 7) | typedef DWORD perl_key;
type HANDLE (line 8) | typedef HANDLE perl_os_thread;
type CRITICAL_SECTION (line 16) | typedef CRITICAL_SECTION perl_mutex;
type HANDLE (line 24) | typedef HANDLE perl_mutex;
type THREAD_RET_TYPE (line 143) | typedef THREAD_RET_TYPE thread_func_t(void *);
type perl_thread (line 158) | struct perl_thread
type perl_thread (line 159) | struct perl_thread
type perl_thread (line 160) | struct perl_thread
type perl_thread (line 161) | struct perl_thread
FILE: tests/perlbench/xsutils.c
function Perl_boot_core_xsutils (line 46) | void
function modify_SV_attributes (line 56) | static int
function XS (line 159) | XS(XS_attributes_bootstrap)
function XS (line 176) | XS(XS_attributes__modify_attrs)
function XS (line 197) | XS(XS_attributes__fetch_attrs)
function XS (line 240) | XS(XS_attributes__guess_stash)
function XS (line 292) | XS(XS_attributes_reftype)
function XS (line 317) | XS(XS_attributes__warn_reserved)
Copy disabled (too large)
Download .json
Condensed preview — 1352 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (25,222K chars).
[
{
"path": ".gitignore",
"chars": 348,
"preview": "Heap-Layers\nDieHard\n\nLLVMStabilizer.so\nLLVMStabilizer.dylib\nlibstabilizer.a\nlibstabilizer.so\nlibstabilizer.dylib\n\nruntim"
},
{
"path": ".hgignore",
"chars": 139,
"preview": "LLVMStabilizer.so\nLLVMStabilizer.dylib\nlibstabilizer.so\nlibstabilizer.dylib\npass/obj\nruntime/obj\n\ntests/HelloWorld/obj\nt"
},
{
"path": "LICENSE",
"chars": 11357,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "Makefile",
"chars": 127,
"preview": "ROOT = .\nDIRS = pass runtime\n\ninclude $(ROOT)/common.mk\n\nclean::\n\t@$(MAKE) -C tests clean\n\ntest: build\n\t@$(MAKE) -C test"
},
{
"path": "README.md",
"chars": 6067,
"preview": "## Stabilizer: Statistically Sound Performance Evaluation\n[Charlie Curtsinger](https://curtsinger.cs.grinnell.edu/) and "
},
{
"path": "common.mk",
"chars": 4244,
"preview": "# Get the current OS and architecture\nOS ?= $(shell uname -s)\nCPU ?= $(shell uname -m)\nPLATFORM ?= $(OS).$(CPU)\nTARGET_P"
},
{
"path": "pass/IntrinsicLibcalls.h",
"chars": 3845,
"preview": "/*\n * IntrinsicLibcalls.h\n *\n * Created on: Apr 2, 2010\n * Author: charlie\n */\n\n#ifndef INTRINSICLIBCALLS_H_\n#defi"
},
{
"path": "pass/LowerIntrinsics.cpp",
"chars": 1758,
"preview": "#define DEBUG_TYPE \"lower_intrinsics\"\n\n#include <iostream>\n#include <set>\n\n#include \"llvm/Module.h\"\n#include \"llvm/Pass."
},
{
"path": "pass/Makefile",
"chars": 230,
"preview": "ROOT = ..\n\nTARGETS = $(ROOT)/LLVMStabilizer.$(SHLIB_SUFFIX)\nLIBS = \n\ninclude $(ROOT)/common.mk\n\nCXXFLAGS += -D_GNU_SOURC"
},
{
"path": "pass/Stabilizer.cpp",
"chars": 35489,
"preview": "#define DEBUG_TYPE \"stabilizer\"\n\n#include <llvm/Pass.h>\n#include <llvm/Module.h>\n#include <llvm/Constants.h>\n#include <l"
},
{
"path": "platforms/Darwin.i386.mk",
"chars": 76,
"preview": "include $(ROOT)/platforms/Darwin.x86_64.mk\n\nCFLAGS += -m32\nCXXFLAGS += -m32\n"
},
{
"path": "platforms/Darwin.x86_64.mk",
"chars": 263,
"preview": "\nSHLIB_SUFFIX = dylib\nCFLAGS = -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS\nSZCFLAGS = -frontend=clang\nLD_PATH_VAR = D"
},
{
"path": "platforms/Linux.i386.mk",
"chars": 75,
"preview": "include $(ROOT)/platforms/Linux.x86_64.mk\n\nCFLAGS += -m32\nCXXFLAGS += -m32\n"
},
{
"path": "platforms/Linux.i686.mk",
"chars": 40,
"preview": "include $(ROOT)/platforms/Linux.i386.mk\n"
},
{
"path": "platforms/Linux.ppc.mk",
"chars": 133,
"preview": "\nCC = gcc\nCXX = g++\n\nCFLAGS =\nCXXFLAGS = $(CFLAGS)\n\nSZCFLAGS = -frontend=clang\nLD_PATH_VAR = LD_LIBRARY_PATH\nCXXLIB = $("
},
{
"path": "platforms/Linux.x86_64.mk",
"chars": 90,
"preview": "\nSZCFLAGS = \nLD_PATH_VAR = LD_LIBRARY_PATH\nCXXFLAGS = -fPIC\nCXXLIB = $(CXX) -shared -fPIC\n"
},
{
"path": "process.py",
"chars": 6103,
"preview": "#!/usr/bin/env python\n\nimport sys\nimport argparse\nfrom numpy import mean, median, std, histogram\nfrom scipy.stats import"
},
{
"path": "run.py",
"chars": 1651,
"preview": "#!/usr/bin/env python\n\nimport os\nimport sys\n\nbenchmarks = ['astar', 'bwaves', 'bzip2', 'cactusADM', 'calculix', 'gcc', '"
},
{
"path": "runtime/Arch.h",
"chars": 756,
"preview": "/**\n * Macros for target-specific code.\n */\n\n#if !defined(RUNTIME_ARCH_H)\n#define RUNTIME_ARCH_H\n\n#if defined(__APPLE__)"
},
{
"path": "runtime/Context.h",
"chars": 2638,
"preview": "/**\n * Signal context and stack-walking code\n */\n\n#if !defined(RUNTIME_CONTEXT_H)\n#define RUNTIME_CONTEXT_H\n\n#if !define"
},
{
"path": "runtime/Debug.cpp",
"chars": 838,
"preview": "#include <execinfo.h>\n#include \"Debug.h\"\n#include \"FunctionLocation.h\"\n\n/**\n * Dump a stack trace to screen.\n * \n * Use "
},
{
"path": "runtime/Debug.h",
"chars": 453,
"preview": "#if !defined(RUNTIME_DEBUG_H)\n#define RUNTIME_DEBUG_H\n\nvoid panic();\n\n#if !defined(NDEBUG)\n#include <stdio.h>\n#include <"
},
{
"path": "runtime/Function.cpp",
"chars": 2044,
"preview": "#include \"Function.h\"\n#include \"FunctionLocation.h\"\n\n/**\n * Free the current function location and stack pad table\n */\nF"
},
{
"path": "runtime/Function.h",
"chars": 3712,
"preview": "#if !defined(RUNTIME_FUNCTION_H)\n#define RUNTIME_FUNCTION_H\n\n#include <string.h>\n#include <sys/mman.h>\n\n#include \"Util.h"
},
{
"path": "runtime/FunctionLocation.h",
"chars": 2756,
"preview": "#if !defined(RUNTIME_FUNCTIONLOCATION_H)\n#define RUNTIME_FUNCTIONLOCATION_H\n\n#include <set>\n\n#include \"MemRange.h\"\n#incl"
},
{
"path": "runtime/Heap.cpp",
"chars": 348,
"preview": "#include \"Heap.h\"\n\nDataHeapType* getDataHeap() {\n static char buf[sizeof(DataHeapType)];\n static DataHeapType* _th"
},
{
"path": "runtime/Heap.h",
"chars": 957,
"preview": "#if !defined(RUNTIME_HEAP_H)\n#define RUNTIME_HEAP_H\n\n#include <heaplayers>\n#include <shuffleheap.h>\n\n#include \"Util.h\"\n#"
},
{
"path": "runtime/Intrinsics.cpp",
"chars": 426,
"preview": "#include <stdlib.h>\n#include <stdint.h>\n#include <math.h>\n#include <string.h>\n\nextern \"C\" {\n float powif(float b, int"
},
{
"path": "runtime/Jump.h",
"chars": 2950,
"preview": "#ifndef RUNTIME_JUMP_H\n#define RUNTIME_JUMP_H\n\n#include <new>\n#include <stdint.h>\n\n#include \"Arch.h\"\n#include \"Debug.h\"\n"
},
{
"path": "runtime/MMapSource.h",
"chars": 961,
"preview": "#if !defined(RUNTIME_MMAPSOURCE_H)\n#define RUNTIME_MMAPSOURCE_H\n\n#include \"Util.h\"\n\ntemplate<int Prot, int Flags> class "
},
{
"path": "runtime/Makefile",
"chars": 352,
"preview": "ROOT = ..\nCROSS_TARGET = 1\nTARGETS = $(ROOT)/libstabilizer.$(SHLIB_SUFFIX) $(ROOT)/libstabilizer.a\nINCLUDE_DIRS = $(ROOT"
},
{
"path": "runtime/MemRange.h",
"chars": 1219,
"preview": "#if !defined(RUNTIME_MEMRANGE_H)\n#define RUNTIME_MEMRANGE_H\n\n#include \"Util.h\"\n\nstruct MemRange {\nprivate:\n uintptr_t"
},
{
"path": "runtime/Trap.h",
"chars": 614,
"preview": "#if !defined(RUNTIME_TRAP_H)\n#define RUNTIME_TRAP_H\n\n#include <signal.h>\n\n#include \"Arch.h\"\n\nstruct X86Trap {\n uint8_"
},
{
"path": "runtime/Util.h",
"chars": 1015,
"preview": "#ifndef RUNTIME_UTIL_H\n#define RUNTIME_UTIL_H\n\n#include <stdint.h>\n#include <sys/mman.h>\n#include <randomnumbergenerator"
},
{
"path": "runtime/libstabilizer.cpp",
"chars": 6217,
"preview": "#include <set>\n#include <vector>\n#include <math.h>\n#include <signal.h>\n#include <stdlib.h>\n#include <execinfo.h>\n\n#inclu"
},
{
"path": "szc",
"chars": 4115,
"preview": "#!/usr/bin/env python\n\nimport os\nimport sys\nimport random\nimport argparse\nfrom distutils import util\n\nparser = argparse."
},
{
"path": "szchi.cfg",
"chars": 2053,
"preview": "ignore_errors = no\ntune = base\next = szc\noutput_format = csv,screen\nreportable = no\nteeout "
},
{
"path": "szclo.cfg",
"chars": 2067,
"preview": "ignore_errors = no\ntune = base\next = szc\noutput_format = csv,screen\nreportable = no\nteeout "
},
{
"path": "tests/Context/Makefile",
"chars": 168,
"preview": "ROOT = ../..\n\ninclude $(ROOT)/common.mk\n\ntest:: hello.cpp stub.asm\n\tyasm -o stub.o -f macho64 stub.asm\n\tclang++ -g -I$(R"
},
{
"path": "tests/Context/hello.cpp",
"chars": 3159,
"preview": "#include <stdio.h>\n#include <signal.h>\n#include <sys/mman.h>\n#include <stdint.h>\n#include <string.h>\n#include <errno.h>\n"
},
{
"path": "tests/Context/stub.asm",
"chars": 665,
"preview": "global _stub\nglobal _stubSize\nglobal _saveState\n\nextern _doStuff\n\nBITS 64\n\n_stub:\n lea rax, [rip-7]\n sub rsp, 8\n "
},
{
"path": "tests/HelloWorld/Makefile",
"chars": 308,
"preview": "ROOT = ../..\nTARGETS = hello\n\nbuild:: hello\n\ninclude $(ROOT)/common.mk\n\nCC = $(ROOT)/szc $(SZCFLAGS) -Rcode -Rheap -Rsta"
},
{
"path": "tests/HelloWorld/hello.cpp",
"chars": 187,
"preview": "#include <stdio.h>\n\nvoid ctor() __attribute__((constructor));\n\nvoid ctor() {\n\tprintf(\"Hello Constructor!\\n\");\n}\n\nint mai"
},
{
"path": "tests/LICENSE",
"chars": 193,
"preview": "The test programs in this directory are included for convenience, but are not integral parts of Stabilizer. Each test pa"
},
{
"path": "tests/Makefile",
"chars": 98,
"preview": "ROOT = ..\n\nRECURSIVE_TARGETS = test\nDIRS = HelloWorld libquantum bzip2\n\ninclude $(ROOT)/common.mk\n"
},
{
"path": "tests/bzip2/Makefile",
"chars": 361,
"preview": "ROOT = ../..\nTARGETS = bzip2\n\nbuild:: bzip2\n\ninclude $(ROOT)/common.mk\n\nCC = $(ROOT)/szc $(SZCFLAGS) -Rcode -Rheap -Rsta"
},
{
"path": "tests/bzip2/blocksort.c",
"chars": 32614,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Block sorting machinery "
},
{
"path": "tests/bzip2/bzip2.c",
"chars": 63036,
"preview": "\n/*-----------------------------------------------------------*/\n/*--- A block-sorting, lossless compressor bzip2"
},
{
"path": "tests/bzip2/bzlib.c",
"chars": 48783,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Library top-level functions. "
},
{
"path": "tests/bzip2/bzlib.h",
"chars": 10012,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Public header file for the library. "
},
{
"path": "tests/bzip2/bzlib_private.h",
"chars": 14284,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Private header file for the library. "
},
{
"path": "tests/bzip2/compress.c",
"chars": 22149,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Compression machinery (not incl block sorting) "
},
{
"path": "tests/bzip2/crctable.c",
"chars": 6398,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Table for doing CRCs "
},
{
"path": "tests/bzip2/decompress.c",
"chars": 21610,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Decompression machinery "
},
{
"path": "tests/bzip2/huffman.c",
"chars": 8571,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Huffman coding low-level stuff "
},
{
"path": "tests/bzip2/randtable.c",
"chars": 5440,
"preview": "\n/*-------------------------------------------------------------*/\n/*--- Table for randomising repetitive blocks "
},
{
"path": "tests/bzip2/spec.c",
"chars": 11253,
"preview": "#include <stdio.h>\n#include <stdlib.h>\n#include <errno.h>\n#include <fcntl.h>\n#ifdef TIMING_OUTPUT\n#include <time.h>\n#inc"
},
{
"path": "tests/bzip2/spec.h",
"chars": 675,
"preview": "/* Prototypes for stuff in spec.c */\nvoid spec_initbufs();\nvoid spec_compress(int in, int out, int level);\nvoid spec_unc"
},
{
"path": "tests/libquantum/Makefile",
"chars": 375,
"preview": "ROOT = ../..\nTARGETS = libquantum\n\nbuild:: libquantum\n\ninclude $(ROOT)/common.mk\n\nCC = $(ROOT)/szc $(SZCFLAGS) -Rcode -R"
},
{
"path": "tests/libquantum/classic.c",
"chars": 2388,
"preview": "/* classic.c: Classic operations used in libquantum\n\n Copyright 2003, 2004 Bjoern Butscher, Hendrik Weimer\n\n This fi"
},
{
"path": "tests/libquantum/classic.h",
"chars": 1109,
"preview": "/* classic.h: Declarations for classic.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of lib"
},
{
"path": "tests/libquantum/complex.c",
"chars": 1449,
"preview": "/* complex.c: Complex number functions\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libqu"
},
{
"path": "tests/libquantum/config.h",
"chars": 3236,
"preview": "/* config.h.in. Generated from configure.in by autoheader. */\n#if defined(SPEC_CPU)\n\n#define PACKAGE_BUGREPORT \"libqua"
},
{
"path": "tests/libquantum/decoherence.c",
"chars": 2910,
"preview": "/* decoherence.c: Simulation of decoherence effects\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is "
},
{
"path": "tests/libquantum/decoherence.h",
"chars": 1045,
"preview": "/* decoherence.h: Declarations for decoherence.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is par"
},
{
"path": "tests/libquantum/defs.h",
"chars": 942,
"preview": "/* defs.h: Global definitions\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquantum\n\n "
},
{
"path": "tests/libquantum/expn.c",
"chars": 1361,
"preview": "/* expn.c: x^a mod n\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquantum\n\n libquant"
},
{
"path": "tests/libquantum/gates.c",
"chars": 18430,
"preview": "/* gates.c: Basic gates for quantum register manipulation\n\n Copyright 2003, 2004 Bjoern Butscher, Hendrik Weimer\n\n T"
},
{
"path": "tests/libquantum/gates.h",
"chars": 2353,
"preview": "/* gates.h: Declarations for gates.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquan"
},
{
"path": "tests/libquantum/lq_complex.h",
"chars": 1568,
"preview": "/* complex.h: Declarations for complex.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of lib"
},
{
"path": "tests/libquantum/matrix.c",
"chars": 2460,
"preview": "/* matrix.c: Matrix operations\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquantum\n\n "
},
{
"path": "tests/libquantum/matrix.h",
"chars": 1341,
"preview": "/* matrix.h: Declarations for matrix.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libqu"
},
{
"path": "tests/libquantum/measure.c",
"chars": 5193,
"preview": "/* measure.c: Quantum register measurement\n\n Copyright 2003, 2004 Bjoern Butscher, Hendrik Weimer\n\n This file is par"
},
{
"path": "tests/libquantum/measure.h",
"chars": 1158,
"preview": "/* measure.h: Declarations for measure.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of lib"
},
{
"path": "tests/libquantum/oaddn.c",
"chars": 7808,
"preview": "/* oaddn.c: Addition modulo an integer N\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of lib"
},
{
"path": "tests/libquantum/oaddn.h",
"chars": 1480,
"preview": "/* oaddn.h: Declarations for oaddn.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquan"
},
{
"path": "tests/libquantum/objcode.c",
"chars": 9327,
"preview": "/* objcode.c: Quantum object code functions\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of "
},
{
"path": "tests/libquantum/objcode.h",
"chars": 1968,
"preview": "/* objcode.h: Object code declarations and definitions\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file "
},
{
"path": "tests/libquantum/omuln.c",
"chars": 2135,
"preview": "/* omuln.c: Multiplication modulo an integer N\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part "
},
{
"path": "tests/libquantum/omuln.h",
"chars": 1091,
"preview": "/* omuln.h: Declarations for omuln.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquan"
},
{
"path": "tests/libquantum/qec.c",
"chars": 5555,
"preview": "/* qec.c: Quantum Error Correction\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquantu"
},
{
"path": "tests/libquantum/qec.h",
"chars": 1393,
"preview": "/* gates.h: Declarations for qec.c\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libquantu"
},
{
"path": "tests/libquantum/qft.c",
"chars": 1459,
"preview": "/* qft.c: Quantum Fourier Transform\n \n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of libqu"
},
{
"path": "tests/libquantum/quantum.h",
"chars": 4516,
"preview": "/* quantum.h: Header file for libquantum\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of lib"
},
{
"path": "tests/libquantum/qureg.c",
"chars": 9258,
"preview": "/* qureg.c: Quantum register management\n\n Copyright 2003, 2004 Bjoern Butscher, Hendrik Weimer\n\n This file is part o"
},
{
"path": "tests/libquantum/qureg.h",
"chars": 3243,
"preview": "/* qureg.h: Declarations for qureg.c and inline hashing functions\n\n Copyright 2003, 2004 Bjoern Butscher, Hendrik Weim"
},
{
"path": "tests/libquantum/shor.c",
"chars": 3660,
"preview": " /* shor.c: Implementation of Shor's factoring algorithm\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This fil"
},
{
"path": "tests/libquantum/specrand.c",
"chars": 1286,
"preview": "/*\n ****************************************************************************\n *\n * HEY!\n * \n * Absolutely do NOT for"
},
{
"path": "tests/libquantum/specrand.h",
"chars": 51,
"preview": "void spec_srand(int seed);\ndouble spec_rand(void);\n"
},
{
"path": "tests/libquantum/version.c",
"chars": 928,
"preview": "/* version.c: libquantum version information\n\n Copyright 2003 Bjoern Butscher, Hendrik Weimer\n\n This file is part of"
},
{
"path": "tests/perlbench/Base64.c",
"chars": 13027,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Base64.xs. Do not edit this"
},
{
"path": "tests/perlbench/Cwd.c",
"chars": 11906,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Cwd.xs. Do not edit this fi"
},
{
"path": "tests/perlbench/Dumper.c",
"chars": 32342,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Dumper.xs. Do not edit this"
},
{
"path": "tests/perlbench/DynaLoader.c",
"chars": 1076,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of DynaLoader.xs. Do not edit "
},
{
"path": "tests/perlbench/EXTERN.h",
"chars": 1751,
"preview": "/* EXTERN.h\n *\n * Copyright (C) 1991, 1992, 1993, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, by Larry Wall an"
},
{
"path": "tests/perlbench/HiRes.c",
"chars": 32708,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of HiRes.xs. Do not edit this "
},
{
"path": "tests/perlbench/Hostname.c",
"chars": 2375,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Hostname.xs. Do not edit th"
},
{
"path": "tests/perlbench/INTERN.h",
"chars": 1424,
"preview": "/* INTERN.h\n *\n * Copyright (C) 1991, 1992, 1993, 1995, 1996, 1998, 2000, 2001,\n * by Larry Wall and others\n *\n"
},
{
"path": "tests/perlbench/IO.c",
"chars": 15483,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of IO.xs. Do not edit this fil"
},
{
"path": "tests/perlbench/MD5.c",
"chars": 22347,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of MD5.xs. Do not edit this fi"
},
{
"path": "tests/perlbench/Makefile",
"chars": 1085,
"preview": "ROOT = ../..\nTARGETS = perlbench\nLIBS = m\nSRCS = av.c deb.c doio.c doop.c dump.c globals.c gv.c hv.c locale.c mg.c numer"
},
{
"path": "tests/perlbench/Opcode.c",
"chars": 19234,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Opcode.xs. Do not edit this"
},
{
"path": "tests/perlbench/Parser.c",
"chars": 17605,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Parser.xs. Do not edit this"
},
{
"path": "tests/perlbench/Peek.c",
"chars": 15708,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Peek.xs. Do not edit this f"
},
{
"path": "tests/perlbench/Storable.c",
"chars": 171169,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of Storable.xs. Do not edit th"
},
{
"path": "tests/perlbench/WORDS",
"chars": 279088,
"preview": "A-pattern\nAAV\nABG\nACP\nADEPT\nAIDS-related\nALT:AST\nANF\nAPACHE\nARF\nAT-II\nATRASS\nAahme\nAarskog-Scott\nAbaks\nAbdaker\nAbegg\nAbe"
},
{
"path": "tests/perlbench/XSUB.h",
"chars": 17933,
"preview": "/* XSUB.h\n *\n * Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 2004, 2005 by Larr"
},
{
"path": "tests/perlbench/attrs.c",
"chars": 2607,
"preview": "/*\n * This file was generated automatically by xsubpp version 1.9508 from the\n * contents of attrs.xs. Do not edit this "
},
{
"path": "tests/perlbench/av.c",
"chars": 22822,
"preview": "/* av.c\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 20"
},
{
"path": "tests/perlbench/av.h",
"chars": 3044,
"preview": "/* av.h\n *\n * Copyright (C) 1991, 1992, 1993, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, by Larry Wall "
},
{
"path": "tests/perlbench/config.h",
"chars": 131,
"preview": "#ifdef SPEC_CPU\n# include \"spec_config.h\"\n#else\n# error \"400.perlbench really isn't useful outside of the SPEC CPU harne"
},
{
"path": "tests/perlbench/const-c.inc",
"chars": 5758,
"preview": "#define PERL_constant_NOTFOUND\t1\n#define PERL_constant_NOTDEF\t2\n#define PERL_constant_ISIV\t3\n#define PERL_constant_ISNO\t"
},
{
"path": "tests/perlbench/cop.h",
"chars": 18546,
"preview": "/* cop.h\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 2"
},
{
"path": "tests/perlbench/cpu2006_mhonarc.rc",
"chars": 4003,
"preview": "<!-- MHonArc resource file -->\n<SORT>\n<REVERSE>\n<MSGLOCALDATEFMT>\n%d-%B-%Y %H:%M:%S\n</MSGLOCALDATEFMT>\n<LOCALDATEFMT>\n%d"
},
{
"path": "tests/perlbench/cv.h",
"chars": 7990,
"preview": "/* cv.h\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,\n * 2000, 2001, 2002, 2003, 2004, by"
},
{
"path": "tests/perlbench/deb.c",
"chars": 6848,
"preview": "/* deb.c\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,\n * 2000, 2001, 2002, 2003, 2004, 2"
},
{
"path": "tests/perlbench/dictionary",
"chars": 2079012,
"preview": "a\na&m\na&p\na's\naa\naaa\naad\naalii\naam\naani\naaron\naaronic\naaronical\naaronite\naau\nab\naba\nababa\nababua\nabacay\nabacinate\nabacin"
},
{
"path": "tests/perlbench/doio.c",
"chars": 60687,
"preview": "/* doio.c\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, "
},
{
"path": "tests/perlbench/doop.c",
"chars": 32123,
"preview": "/* doop.c\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2004, "
},
{
"path": "tests/perlbench/dump.c",
"chars": 47328,
"preview": "/* dump.c\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, "
},
{
"path": "tests/perlbench/embed.h",
"chars": 146404,
"preview": "/*\n * embed.h\n *\n * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 2004, 20"
},
{
"path": "tests/perlbench/embedvar.h",
"chars": 61792,
"preview": "/*\n * embedvar.h\n *\n * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 2004,"
},
{
"path": "tests/perlbench/fakesdio.h",
"chars": 3202,
"preview": "/* fakestdio.h\n *\n * Copyright (C) 2000, by Larry Wall and others\n *\n * You may distribute under the terms of e"
},
{
"path": "tests/perlbench/fakethr.h",
"chars": 1822,
"preview": "/* fakethr.h\n *\n * Copyright (C) 1999, by Larry Wall and others\n *\n * You may distribute under the terms of eit"
},
{
"path": "tests/perlbench/form.h",
"chars": 723,
"preview": "/* form.h\n *\n * Copyright (C) 1991, 1992, 1993, 2000, 2004 by Larry Wall and others\n *\n * You may distribute un"
},
{
"path": "tests/perlbench/globals.c",
"chars": 1643,
"preview": "/* globals.c\n *\n * Copyright (C) 1995, 1999, 2000, 2001, by Larry Wall and others\n *\n * You may distribute unde"
},
{
"path": "tests/perlbench/gv.c",
"chars": 50419,
"preview": "/* gv.c\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 20"
},
{
"path": "tests/perlbench/gv.h",
"chars": 5298,
"preview": "/* gv.h\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 20"
},
{
"path": "tests/perlbench/handy.h",
"chars": 24832,
"preview": "/* handy.h\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,\n * 2000, 2001, 2002, 2004, 2005 "
},
{
"path": "tests/perlbench/hctype.h",
"chars": 2937,
"preview": "/* This file is autogenerated by mkhctype */\n\n#define HCTYPE_SPACE 0x01\n#define HCTYPE_NAME_FIRST "
},
{
"path": "tests/perlbench/hparser.c",
"chars": 40265,
"preview": "/* $Id: hparser.c,v 2.119 2004/12/28 13:47:44 gisle Exp $\n *\n * Copyright 1999-2004, Gisle Aas\n * Copyright 1999-2000, M"
},
{
"path": "tests/perlbench/hparser.h",
"chars": 2646,
"preview": "/* $Id: hparser.h,v 2.31 2004/11/23 20:38:27 gisle Exp $\n *\n * Copyright 1999-2004, Gisle Aas\n * Copyright 1999-2000, Mi"
},
{
"path": "tests/perlbench/hv.c",
"chars": 57949,
"preview": "/* hv.c\n *\n * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2003, 20"
},
{
"path": "tests/perlbench/hv.h",
"chars": 12679,
"preview": "/* hv.h\n *\n * Copyright (C) 1991, 1992, 1993, 1996, 1997, 1998, 1999,\n * 2000, 2001, 2002, 2005, by Larry Wall "
},
{
"path": "tests/perlbench/input/checkspam.pl",
"chars": 8356,
"preview": "#!/usr/bin/perl \n\n#\n# $Log: checkspam.pl,v $\n# Revision 1.3 2004/03/26 20:55:28 cloyce\n# Multiply all SpamAssassin sco"
},
{
"path": "tests/perlbench/input/diffmail.in",
"chars": 93,
"preview": "# ~50 secs\n#4 70 15 24 23 100 \n# ~110 secs\n2 550 15 24 23 100 \n# 65 secs\n#3 150 15 24 30 100\n"
},
{
"path": "tests/perlbench/input/diffmail.pl",
"chars": 7634,
"preview": "#!/usr/bin/perl \n\n#\n# $Log: diffmail.pl,v $\n# Revision 1.1 1999/04/23 05:15:39 channui\n# kit71\n#\n# Revision 1.1 1999/"
},
{
"path": "tests/perlbench/input/perfect.in",
"chars": 111,
"preview": "# Definitely don't put anything over 4 here, or you'll be waiting for a *long*\n# time, with either method.\nb 3\n"
},
{
"path": "tests/perlbench/input/perfect.pl",
"chars": 1555,
"preview": "#!/usr/bin/perl\n\n# Find some number of perfect numbers, using either native integers or\n# perl BigInts\n\n# This is a toy,"
},
{
"path": "tests/perlbench/input/scrabbl.in",
"chars": 51,
"preview": "zed\nyankeeist\nband\napril\nacetylic\nabdomen\nabortive\n"
},
{
"path": "tests/perlbench/input/scrabbl.pl",
"chars": 1095,
"preview": "# Scrabbl.pl\t-- Find all words from a collection of letters\n#\t\t- basically a simple application utilizing associative ar"
},
{
"path": "tests/perlbench/input/splitmail.in",
"chars": 335,
"preview": "# And now some values from the actual SPEC mail archives:\n# An osgcpu-ish mix (~160 secs):\n#704 12 26 16 836\n# An osgsup"
},
{
"path": "tests/perlbench/input/splitmail.pl",
"chars": 11129,
"preview": "#!/usr/bin/perl \n\n#\n# $Log: splitmail.pl,v $\n# Revision 1.3 2004/03/24 00:13:55 cloyce\n# Don't output MD5 sums for tem"
},
{
"path": "tests/perlbench/input/suns.pl",
"chars": 3461,
"preview": "#!/usr/local/bin/perl\n# Developed by Kaivalya/Cloyce/Jason - Kmd\n# Version 1.0 Tue Aug 27 14:01:53 CDT 2002\n# Default ou"
},
{
"path": "tests/perlbench/intrpvar.h",
"chars": 20694,
"preview": "/***********************************************/\n/* Global only to current interpreter instance */\n/*******************"
},
{
"path": "tests/perlbench/iperlsys.h",
"chars": 48273,
"preview": "/*\n * iperlsys.h - Perl's interface to the system\n *\n * This file defines the system level functionality that perl needs"
},
{
"path": "tests/perlbench/keywords.h",
"chars": 6195,
"preview": "/*\n * keywords.h\n *\n * Copyright (C) 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,\n * by Larry Wall and other"
},
{
"path": "tests/perlbench/lib/AutoLoader.pm",
"chars": 11093,
"preview": "package AutoLoader;\n\nuse strict;\nuse 5.006_001;\n\nour($VERSION, $AUTOLOAD);\n\nmy $is_dosish;\nmy $is_epoc;\nmy $is_vms;\nmy $"
},
{
"path": "tests/perlbench/lib/Carp/Heavy.pm",
"chars": 5817,
"preview": "# Carp::Heavy uses some variables in common with Carp.\npackage Carp;\n\n=head1 NAME\n\nCarp::Heavy - heavy machinery, no use"
},
{
"path": "tests/perlbench/lib/Carp.pm",
"chars": 6917,
"preview": "package Carp;\n\nour $VERSION = '1.03';\n\n=head1 NAME\n\ncarp - warn of errors (from perspective of caller)\n\ncluck - war"
},
{
"path": "tests/perlbench/lib/Config.pm",
"chars": 29695,
"preview": "# This file was created by configpm when Perl was built. Any changes\n# made to this file will be lost the next time perl"
},
{
"path": "tests/perlbench/lib/Cwd.pm",
"chars": 16634,
"preview": "package Cwd;\n$VERSION = $VERSION = '2.19';\n\n=head1 NAME\n\nCwd - get pathname of current working directory\n\n=head1 SYNOPSI"
},
{
"path": "tests/perlbench/lib/DB_File.pm",
"chars": 1780,
"preview": "package DB_File;\n\n# This is a faked-up version of DB_File that uses in-memory hashes instead\n# of files.\n\n# Written for "
},
{
"path": "tests/perlbench/lib/Date/Format.pm",
"chars": 9850,
"preview": "# Date::Format $Id: //depot/TimeDate/lib/Date/Format.pm#9 $\n#\n# Copyright (c) 1995-1999 Graham Barr. All rights reserved"
},
{
"path": "tests/perlbench/lib/Date/Language/Afar.pm",
"chars": 1032,
"preview": "##\n## Afar tables\n##\n\npackage Date::Language::Afar;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs @AMPM"
},
{
"path": "tests/perlbench/lib/Date/Language/Amharic.pm",
"chars": 1769,
"preview": "##\n## Amharic tables\n##\n\npackage Date::Language::Amharic;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs"
},
{
"path": "tests/perlbench/lib/Date/Language/Austrian.pm",
"chars": 958,
"preview": "##\n## Austrian tables\n##\n\npackage Date::Language::Austrian;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @Mo"
},
{
"path": "tests/perlbench/lib/Date/Language/Brazilian.pm",
"chars": 963,
"preview": "##\n## Brazilian tables, contributed by Christian Tosta (tosta@cce.ufmg.br)\n##\n\npackage Date::Language::Brazilian;\n\nuse D"
},
{
"path": "tests/perlbench/lib/Date/Language/Chinese_GB.pm",
"chars": 801,
"preview": "##\n## English tables\n##\n\npackage Date::Language::Chinese_GB;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @M"
},
{
"path": "tests/perlbench/lib/Date/Language/Czech.pm",
"chars": 1380,
"preview": "##\n## Czech tables\n##\n## Contributed by Honza Pazdziora \n\npackage Date::Language::Czech;\n\nuse vars qw(@ISA @DoW @DoWs @M"
},
{
"path": "tests/perlbench/lib/Date/Language/Danish.pm",
"chars": 961,
"preview": "##\n## Danish tables\n##\n\npackage Date::Language::Danish;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs @"
},
{
"path": "tests/perlbench/lib/Date/Language/Dutch.pm",
"chars": 1086,
"preview": "##\n## Dutch tables\n## Contributed by Johannes la Poutre <jlpoutre@corp.nl.home.com>\n##\n\npackage Date::Language::Dutch;\n\n"
},
{
"path": "tests/perlbench/lib/Date/Language/English.pm",
"chars": 973,
"preview": "##\n## English tables\n##\n\npackage Date::Language::English;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs"
},
{
"path": "tests/perlbench/lib/Date/Language/Finnish.pm",
"chars": 1237,
"preview": "##\n## Finnish tables\n## Contributed by Matthew Musgrove <muskrat@mindless.com>\n## Corrected by roke\n##\n\npackage Date::La"
},
{
"path": "tests/perlbench/lib/Date/Language/French.pm",
"chars": 989,
"preview": "##\n## French tables, contributed by Emmanuel Bataille (bem@residents.frmug.org)\n##\n\npackage Date::Language::French;\n\nuse"
},
{
"path": "tests/perlbench/lib/Date/Language/Gedeo.pm",
"chars": 1064,
"preview": "##\n## Gedeo tables\n##\n\npackage Date::Language::Gedeo;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs @AM"
},
{
"path": "tests/perlbench/lib/Date/Language/German.pm",
"chars": 1039,
"preview": "##\n## German tables\n##\n\npackage Date::Language::German;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs @"
},
{
"path": "tests/perlbench/lib/Date/Language/Greek.pm",
"chars": 2826,
"preview": "##\n## Greek tables\n##\n## Traditional date format is: DoW DD{eta} MoY Year (%A %o %B %Y)\n##\n## Matthew Musgrove <muskrat@"
},
{
"path": "tests/perlbench/lib/Date/Language/Italian.pm",
"chars": 974,
"preview": "##\n## Italian tables\n##\n\npackage Date::Language::Italian;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs"
},
{
"path": "tests/perlbench/lib/Date/Language/Norwegian.pm",
"chars": 966,
"preview": "##\n## Norwegian tables\n##\n\npackage Date::Language::Norwegian;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @"
},
{
"path": "tests/perlbench/lib/Date/Language/Oromo.pm",
"chars": 999,
"preview": "##\n## Oromo tables\n##\n\npackage Date::Language::Oromo;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs @AM"
},
{
"path": "tests/perlbench/lib/Date/Language/Sidama.pm",
"chars": 980,
"preview": "##\n## Sidama tables\n##\n\npackage Date::Language::Sidama;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs @"
},
{
"path": "tests/perlbench/lib/Date/Language/Somali.pm",
"chars": 1155,
"preview": "##\n## Somali tables\n##\n\npackage Date::Language::Somali;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @MoYs @"
},
{
"path": "tests/perlbench/lib/Date/Language/Swedish.pm",
"chars": 1086,
"preview": "##\n## Swedish tables\n## Contributed by Matthew Musgrove <muskrat@mindless.com>\n## Corrected by dempa\n##\n\npackage Date::L"
},
{
"path": "tests/perlbench/lib/Date/Language/Tigrinya.pm",
"chars": 1510,
"preview": "##\n## Tigrinya tables\n##\n\npackage Date::Language::Tigrinya;\n\nuse Date::Language ();\nuse vars qw(@ISA @DoW @DoWs @MoY @Mo"
},
{
"path": "tests/perlbench/lib/Date/Language/TigrinyaEritrean.pm",
"chars": 1766,
"preview": "##\n## Tigrinya-Eritrean tables\n##\n\npackage Date::Language::TigrinyaEritrean;\n\nuse Date::Language ();\nuse vars qw(@ISA @D"
},
{
"path": "tests/perlbench/lib/Date/Language/TigrinyaEthiopian.pm",
"chars": 1776,
"preview": "##\n## Tigrinya-Ethiopian tables\n##\n\npackage Date::Language::TigrinyaEthiopian;\n\nuse Date::Language ();\nuse vars qw(@ISA "
},
{
"path": "tests/perlbench/lib/Date/Language.pm",
"chars": 1343,
"preview": "\npackage Date::Language;\n\nuse strict;\nuse Time::Local;\nuse Carp;\nuse vars qw($VERSION @ISA);\nrequire Dat"
},
{
"path": "tests/perlbench/lib/Date/Parse.pm",
"chars": 8952,
"preview": "# Date::Parse $Id: //depot/TimeDate/lib/Date/Parse.pm#22 $\n#\n# Copyright (c) 1995 Graham Barr. All rights reserved. This"
},
{
"path": "tests/perlbench/lib/Digest/MD5.pm",
"chars": 10124,
"preview": "package Digest::MD5;\n\nuse strict;\nuse vars qw($VERSION @ISA @EXPORT_OK);\n\n$VERSION = '2.33'; # $Date: 2003/12/07 08:40:"
},
{
"path": "tests/perlbench/lib/DynaLoader.pm",
"chars": 28127,
"preview": "\n# Generated from DynaLoader.pm.PL\n\npackage DynaLoader;\n\n# And Gandalf said: 'Many folk like to know beforehand what i"
},
{
"path": "tests/perlbench/lib/Exporter/Heavy.pm",
"chars": 6397,
"preview": "package Exporter::Heavy;\n\nuse strict;\nno strict 'refs';\n\n# On one line so MakeMaker will see it.\nrequire Exporter; our "
},
{
"path": "tests/perlbench/lib/Exporter.pm",
"chars": 14419,
"preview": "package Exporter;\n\nrequire 5.006;\n\n# Be lean.\n#use strict;\n#no strict 'refs';\n\nour $Debug = 0;\nour $ExportLevel = 0;\nour"
},
{
"path": "tests/perlbench/lib/Fcntl.pm",
"chars": 5821,
"preview": "package Fcntl;\n\n# Faked-up fcntl.h defines for 400.perlbench\n\nour($VERSION, @ISA, @EXPORT, @EXPORT_OK, %EXPORT_TAGS);\n\nr"
},
{
"path": "tests/perlbench/lib/File/Basename.pm",
"chars": 9543,
"preview": "package File::Basename;\n\n=head1 NAME\n\nfileparse - split a pathname into pieces\n\nbasename - extract just the filename fro"
},
{
"path": "tests/perlbench/lib/File/CheckTree.pm",
"chars": 7423,
"preview": "package File::CheckTree;\n\nuse 5.006;\nuse Cwd;\nuse Exporter;\nuse File::Spec;\nuse warnings;\nuse strict;\n\nour $VERSION = '4"
},
{
"path": "tests/perlbench/lib/File/Compare.pm",
"chars": 4284,
"preview": "package File::Compare;\n\nuse 5.006;\nuse strict;\nuse warnings;\nour($VERSION, @ISA, @EXPORT, @EXPORT_OK, $Too_Big);\n\nrequir"
},
{
"path": "tests/perlbench/lib/File/Copy.pm",
"chars": 13605,
"preview": "# File/Copy.pm. Written in 1994 by Aaron Sherman <ajs@ajs.com>. This\n# source code has been placed in the public domain "
},
{
"path": "tests/perlbench/lib/File/DosGlob.pm",
"chars": 16626,
"preview": "#!perl -w\n\n# use strict fails\n#Can't use string (\"main::glob\") as a symbol ref while \"strict refs\" in use at /usr/lib/pe"
},
{
"path": "tests/perlbench/lib/File/Find.pm",
"chars": 35771,
"preview": "package File::Find;\nuse 5.006;\nuse strict;\nuse warnings;\nuse warnings::register;\nour $VERSION = '1.07';\nrequire Exporter"
},
{
"path": "tests/perlbench/lib/File/Path.pm",
"chars": 7551,
"preview": "package File::Path;\n\n=head1 NAME\n\nFile::Path - create or remove directory trees\n\n=head1 SYNOPSIS\n\n use File::Path;\n\n "
},
{
"path": "tests/perlbench/lib/File/Spec/Epoc.pm",
"chars": 1339,
"preview": "package File::Spec::Epoc;\n\nuse strict;\nuse vars qw($VERSION @ISA);\n\n$VERSION = '1.1';\n\nrequire File::Spec::Unix;\n@ISA = "
},
{
"path": "tests/perlbench/lib/File/Spec/Functions.pm",
"chars": 1655,
"preview": "package File::Spec::Functions;\n\nuse File::Spec;\nuse strict;\n\nuse vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS $VERSION);"
},
{
"path": "tests/perlbench/lib/File/Spec/Mac.pm",
"chars": 22466,
"preview": "package File::Spec::Mac;\n\nuse strict;\nuse vars qw(@ISA $VERSION);\nrequire File::Spec::Unix;\n\n$VERSION = '1.4';\n\n@ISA = q"
},
{
"path": "tests/perlbench/lib/File/Spec/OS2.pm",
"chars": 6521,
"preview": "package File::Spec::OS2;\n\nuse strict;\nuse vars qw(@ISA $VERSION);\nrequire File::Spec::Unix;\n\n$VERSION = '1.2';\n\n@ISA = q"
},
{
"path": "tests/perlbench/lib/File/Spec/Unix.pm",
"chars": 11515,
"preview": "package File::Spec::Unix;\n\nuse strict;\nuse vars qw($VERSION);\n\n$VERSION = '1.5';\n\n=head1 NAME\n\nFile::Spec::Unix - File::"
},
{
"path": "tests/perlbench/lib/File/Spec/VMS.pm",
"chars": 14322,
"preview": "package File::Spec::VMS;\n\nuse strict;\nuse vars qw(@ISA $VERSION);\nrequire File::Spec::Unix;\n\n$VERSION = '1.4';\n\n@ISA = q"
},
{
"path": "tests/perlbench/lib/File/Spec/Win32.pm",
"chars": 9504,
"preview": "package File::Spec::Win32;\n\nuse strict;\n\nuse vars qw(@ISA $VERSION);\nrequire File::Spec::Unix;\n\n$VERSION = '1.4';\n\n@ISA "
},
{
"path": "tests/perlbench/lib/File/Spec.pm",
"chars": 9161,
"preview": "package File::Spec;\n\nuse strict;\nuse vars qw(@ISA $VERSION);\n\n$VERSION = '0.87';\n\nmy %module = (MacOS => 'Mac',\n\t "
},
{
"path": "tests/perlbench/lib/File/Temp.pm",
"chars": 59726,
"preview": "package File::Temp;\n\n=head1 NAME\n\nFile::Temp - return name and handle of a temporary file safely\n\n=begin __INTERNALS\n\n=h"
}
]
// ... and 1152 more files (download for full content)
About this extraction
This page contains the full source code of the ccurtsinger/stabilizer GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1352 files (105.8 MB), approximately 5.9M tokens, and a symbol index with 3421 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.