Compilers Lab’s Post

Fernando Pereira has recently launched a new series of coding labs for UFMG's Static Program Analysis course. DCC888 - Static Program Analysis is an annual offering in the Graduate Program in Computer Science at the Federal University of Minas Gerais. The course delves into various static analysis techniques, including data-flow equations, control-flow and data-flow graphs, type systems, fixed-point theory, lattices, proofs of termination, constraint generation, and Static-Single Assignment form. Students are tasked with completing project assignments, primarily involving filling in missing parts of static analysis algorithms implemented in Python. These assignments are evaluated using UFMG's automated grading system (based on Moodle), but interested students can still try the labs: they all include doctests to guide students through completing the assignments. Check out the labs: https://lnkd.in/eA7NNpbc Check out DCC888: https://lnkd.in/dG8Wrv5k #university #computerscience #compiler #programming #science #research

Jialong Wu, Chaoyi Deng, Jianmin Wang and Mingsheng Long, from Tsinghua University, have released CodeZero, a technique that predicts the best optimization sequence for a given program. Typically, compilers apply fixed sequences of optimizations on programs. For instance, if you want to check which optimizations clang runs at its -O3 level, just do: llvm-as < /dev/null | opt -O3 -disable-output -debug-pass=Arguments These sequences are great, but they are not universally great: there are programs that don't benefit as much of all this greatness :) Now, image that you could find the best sequence of optimizations for each program. CodeZero is an attempt towards this goal! CodeZero, like many predictive compilation techniques, requires training data. The Compilers Lab has released one of the largest collections of real-world benchmarks exactly with this purpose: the AnghaBench suite. AnghaBench has been used to train CodeZero, and many other predictive optimization techniques. Try AnghaBench: https://lnkd.in/dTuYNC8 Read the AnghaBench paper: https://lnkd.in/gJCt72J Read the CodeZero paper: https://lnkd.in/gn3qXNyu To know a bit more about the phase-ordering problem: https://lnkd.in/dqRXtRU #research #compiler #programming #academia #llvm

Students from the Universidad de Buenos Aires ended up 13th in the ICPC - International Collegiate Programming Contest. The last time a Latin American team did so well at ICPC was in 2003! ¡Bien hecho muchachos! And thank you Luxor, for hosting the event! Standings: https://lnkd.in/dcsP4Dgk #programming #competition #sport #friendship

Please join us at JensFest'24, a workshop to honor Jens Palsberg with a series of distinguished talks and papers in the many areas of research that he’s contributed to. This workshop celebrates the career and accomplishments of Jens Palsberg on the occasion of his 60th birthday. Jens has been a pillar of the OOPSLA community for over three decades and has represented the SIGPLAN community at the ACM, Association for Computing Machinery as a member of the Executive Committee. His distinguished service to the community includes ACM SIGPLAN chair, vice-chair of SIGBED, editor-in-chief of TOPLAS, editorial board of Information and Computation, Program Chair of POPL, TACAS, EMSOFT, and SAS, General Chair of POPL, LICS, and SPIN, as well as a member of over 100 Program Committees. Jens has been honored with many awards, including the ACM Distinguished Service Award. But more than that, Jens has been a great advisor, mentor, and friend to so many in the community, particularly his many successful students. Event website: https://lnkd.in/dSqdgjgm Submission website: https://lnkd.in/d9w56fX4 Organizers: Ben L. Titzer, Mayur Naik, Fernando Pereira.

Delve into the fascinating journey of decompilation over the past thirty years with Zion Leonahenahe Basque's two-part article. From Dr Cristina Cifuentes's groundbreaking work to the latest advancements in the field, Basque covers the evolution of decompilation. Decompilation is the problem of recovering high-level information from low-level binaries. To solve decompilation, researchers face three challenges: 1. Control-flow graph recovery via disassembling. 2. Variable recovery, including type inferencing and naming. 3. Control flow structuring. Much work has been done in the field, since Cifuentes' seminal PhD dissertation in 1994. Disassembling got a lot of supporting tools. New algorithms (many of them due to Basque himself) are now able to get pretty to the structure of the original program, and developments in AI have allowed decompilers to get meaningful names to program variables. And yet, there is much to be done in the field, as Zion Leonahenahe Basque explains in his blog. And by the way, want to recover the control-flow graph after observing the execution of the program? Try Andrei Rimsa Alvares's CFGGrind, which is openly available at https://lnkd.in/d7Xui2u, and runs on top of Valgrind. Andrei explains how CFGGrind works in this paper: https://lnkd.in/d9e-Rxs Read Zion L. Basque's article at https://lnkd.in/dEVXR_Kc and https://lnkd.in/dw4emdX8. #compilers #programming #hacking #research #science #security

Saman Amarasinghe will be the keynote speaker of SBLP 24, which will happen as part of the Brazilian Conference on Software: Practice and Theory (CBSoft), from 30-Sep to 04-Oct 2024. Every year, SBLP invites some prominent figure in the programming language community to give the keynote talk. This year, Saman Amarashing has accepted to be the keynote speaker. Saman is a Professor at MIT in the Department of Electrical Engineering and Computer Science. Under his direction, the CSAIL group has created numerous pioneering programming languages and compilers such as StreamIt, Halide, and GraphIt, along with advanced compiler/runtime frameworks like DynamoRIO and Tiramisu. His extensive contributions have earned him recognition as an ACM Fellow, highlighting his significant impact on the field of programming languages and compilers. SBLP 2024: https://lnkd.in/d8s2T6Ar Keynote speaker: https://lnkd.in/dmSicukr #science #research #compilers #programminglanguages #academia

Some dynamically typed languages, like Python, JavaScrip, or Lua, represent objects as hash tables containing methods and fields. It is possible to speedup execution by replacing these hash tables with (C++/Java/C#)-style virtual tables. An early example of class inference is presented in the paper "Optimizing compiler technology for self, a dynamically-typed object-oriented programming language", by Craig Chambers and David Ungar (Read the paper on the ACM Digital Library: https://lnkd.in/dpx7gcZq) The paper "Parameterized Construction of Program Representations for Sparse Dataflow Analyses" shows how to implement class inference in linear time on the number of statements in the program: https://lnkd.in/dxqNiuRY #compiler #staticanalysis #programming #objectoriented #research

Static analyses link information to syntactic elements such as variables, sets of variables, program points, and memory locations. The classification of static analyses varies based on the entities they examine and how these entities are interconnected. Analyses that associate variables with specific information are termed sparse. In such analyses, the information tied to a variable remains consistent across all instances of that variable's occurrence. Range analysis (symbolic or not) and Pentagons are sparse, but Octagons are not. The specific information linked to a variable can vary depending on the segment of the program being considered. To illustrate that, figure in this post presents the outcomes of four distinct analyses at three different program points. In this example, classic range analysis can determine the positiveness of variables. Both pentagons and symbolic range analyses can deduce that 'j' is consistently less than 'N' within the loop. Octagons, which are more accurate but also more computationally intensive, can identify that 'm' equals 'i' at control points 'b' and 'c'. Range analysis on the integer interval lattice: https://lnkd.in/dj8_wGfy Symbolic range analysis: https://lnkd.in/dThVKYBJ Pentagons: https://lnkd.in/dwp78Smp Octagons: https://lnkd.in/dWiAxkNp #compiler #programming #science #theory #staticanalysis #softwaresecurity

Writing a recursive descent parser for expressions with left-associative operands that are not commutative can be surprisingly irritating, but there are many ways to handle this problem! In this online article, Theodore Norvell explains three different techniques to implement recursive descent parsers for expressions such as "a*b - a*d - e*f". These techniques include the shunting yard algorithm; grammar rewriting; and precedence climbing. You can read the article here: https://lnkd.in/eKPZqW4e For an example on how this kind of parsing can be implemented in Python, see Austin Henley's article on the Teeny Tiny Compiler: https://lnkd.in/e5c2MHYG #compilers #parsing #programming #theory

To optimize code effectively, C/C++ compilers resolve memory dependencies through a combination of dynamic condicional checks and code duplication. It's really cool! To vectorize code involving pointers, for instance, compilers must deal with memory dependencies. This paper explains how to create alias-free regions in code, so that the compiler can optimize it with wild abandon! Creating an alias-free region involves: (i) finding the boundaries of memory regions referenced through the pointers alive in those regions; (ii) inserting checks to determine if alias actually happen at running time; (iii) duplicating code, so that one version of the program, guarded by the conditional checks, is guaranteed to be alias free. Both clang and gcc use this combination of dynamic guards and code duplication to vectorize code, for instance. Read the paper (author version): https://lnkd.in/deUubqA8 Find the paper in the ACM Digital Library: https://lnkd.in/dVyJHCSj #compiler #programming #science #research