research-article

Devirtualization in LLVM

Author:

SPLASH Companion 2017: Proceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity

Pages 42 - 44

https://doi.org/10.1145/3135932.3135947

Published: 22 October 2017 Publication History

Get Access

Abstract

Devirtualization is an optimization changing indirect (virtual) calls to direct calls. It improves performance by allowing extra inlining and removal of redundant loads. This paper presents a novel way of handling C++ devirtualization in LLVM by unifying virtual table loads across calls using different SSA values to represent different dynamic types.

References

[1]

2017. Working Draft, Standard for Programming Language C++:Objects lifetime. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4659.pdf. (21 March 2017).

Google Scholar

[2]

Brad Calder and Dirk Grunwald. 1994. Reducing Indirect Function Call Overhead in C++ Programs. In Proceedings of the 21st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL '94). ACM, New York, NY, USA, 397-408.

Digital Library

Google Scholar

[3]

Peter Collingbourne. 2017. Devirtualization using LTO with Clang. https://clang.llvm.org/docs/LTOVisibility.html. (16 March 2017).

Google Scholar

[4]

Jan Hubicka. 2014. Devirtualization in C++. (2014). http://hubicka.blogspot.com/2014/01/devirtualization-in-c-part-1.html

Google Scholar

[5]

Jose A. Joao, Onur Mutlu, Hyesoon Kim, Rishi Agarwal, and Yale N. Patt. 2008. Improving the Performance of Object-oriented Languages with Dynamic Predication of Indirect Jumps. SIGOPS Oper. Syst. Rev. 42, 2 (March 2008), 80-90.

Digital Library

Google Scholar

[6]

Hyesoon Kim, José A. Joao, Onur Mutlu, Chang Joo Lee, Yale N. Patt, and Robert Cohn. 2007. VPC Prediction: Reducing the Cost of Indirect Branches via Hardware-based Dynamic Devirtualization. SIGARCH Comput. Archit. News 35, 2 (June 2007), 424-435.

Digital Library

Google Scholar

[7]

Jason Mccandless and David Gregg. 2012. Compiler Techniques to Improve Dynamic Branch Prediction for Indirect Jump and Call Instructions. ACM Trans. Archit. Code Optim. 8, 4, Article 24 (Jan. 2012), 20 pages.

Digital Library

Google Scholar

Cited By

View all

Galustov ABorodin ABelevantsev A(2022)Devirtualization for static analysis with low level intermediate representation2022 Ivannikov Ispras Open Conference (ISPRAS)10.1109/ISPRAS57371.2022.10076859(18-23)Online publication date: 1-Dec-2022
https://doi.org/10.1109/ISPRAS57371.2022.10076859
VanHattum ASchwartz-Narbonne DChong NSampson A(2022)Verifying Dynamic Trait Objects in Rust2022 IEEE/ACM 44th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP)10.1109/ICSE-SEIP55303.2022.9794041(321-330)Online publication date: May-2022
https://doi.org/10.1109/ICSE-SEIP55303.2022.9794041
Chen DLim WBakhshalipour MGibbons PHoe JParno BSherwood TBerger EKozyrakis C(2021)HerQules: securing programs via hardware-enforced message queuesProceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems10.1145/3445814.3446736(773-788)Online publication date: 19-Apr-2021
https://dl.acm.org/doi/10.1145/3445814.3446736
Show More Cited By

Index Terms

Devirtualization in LLVM
1. Software and its engineering
  1. Software notations and tools
    1. Compilers
      1. Source code generation
    2. General programming languages
      1. Language features
        Polymorphism

Recommendations

SVF: interprocedural static value-flow analysis in LLVM
CC '16: Proceedings of the 25th International Conference on Compiler Construction

This paper presents SVF, a tool that enables scalable and precise interprocedural Static Value-Flow analysis for C programs by leveraging recent advances in sparse analysis. SVF, which is fully implemented in LLVM, allows value-flow construction and ...
Precise Call Graph Construction for OO Programs in the Presence of Virtual Functions
ICPP '97: Proceedings of the international Conference on Parallel Processing

Several intra- and inter-procedural program analysis techniques form the backbone of an optimizing and parallelizing compiler. The efficacy of these analyses depends upon how precise the call graph is. However, due to lack of exact type information for ...
Formal verification of SSA-based optimizations for LLVM
PLDI '13: Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation

Modern compilers, such as LLVM and GCC, use a static single assignment(SSA) intermediate representation (IR) to simplify and enable many advanced optimizations. However, formally verifying the correctness of SSA-based optimizations is challenging ...

Comments

Please enable JavaScript to view thecomments powered by Disqus.

Information & Contributors

Information

Published In

SPLASH Companion 2017: Proceedings Companion of the 2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity

October 2017

56 pages

ISBN:9781450355148

DOI:10.1145/3135932

General Chair:
Gail C. Murphy
University of British Columbia, Canada

Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]

In-Cooperation

SIGAda: ACM Special Interest Group on Ada Programming Language

Publisher

Association for Computing Machinery

New York, NY, United States

Publication History

Published: 22 October 2017

Permissions

Request permissions for this article.

Request Permissions

Check for updates

Author Tags

Qualifiers

Research-article

Conference

SPLASH '17

Sponsor:

SIGPLAN

SPLASH '17: Conference on Systems, Programming, Languages, and Applications: Software for Humanity

October 22 - 27, 2017

BC, Vancouver, Canada

Acceptance Rates

Overall Acceptance Rate 268 of 1,244 submissions, 22%

Upcoming Conference

Contributors

Other Metrics

View Article Metrics

Bibliometrics & Citations

Bibliometrics

Article Metrics

5
Total Citations
View Citations
586
Total Downloads

Downloads (Last 12 months)35
Downloads (Last 6 weeks)1

Reflects downloads up to 01 Oct 2024

Other Metrics

View Author Metrics

Citations

Cited By

View all

Galustov ABorodin ABelevantsev A(2022)Devirtualization for static analysis with low level intermediate representation2022 Ivannikov Ispras Open Conference (ISPRAS)10.1109/ISPRAS57371.2022.10076859(18-23)Online publication date: 1-Dec-2022
https://doi.org/10.1109/ISPRAS57371.2022.10076859
VanHattum ASchwartz-Narbonne DChong NSampson A(2022)Verifying Dynamic Trait Objects in Rust2022 IEEE/ACM 44th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP)10.1109/ICSE-SEIP55303.2022.9794041(321-330)Online publication date: May-2022
https://doi.org/10.1109/ICSE-SEIP55303.2022.9794041
Chen DLim WBakhshalipour MGibbons PHoe JParno BSherwood TBerger EKozyrakis C(2021)HerQules: securing programs via hardware-enforced message queuesProceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems10.1145/3445814.3446736(773-788)Online publication date: 19-Apr-2021
https://dl.acm.org/doi/10.1145/3445814.3446736
Godbolt M(2020)Optimizations in C++ compilersCommunications of the ACM10.1145/336975463:2(41-49)Online publication date: 22-Jan-2020
https://dl.acm.org/doi/10.1145/3369754
Gadepalli PPeach GParmer GEspy JDay Z(2019)Chaos: a System for Criticality-Aware, Multi-Core Coordination2019 IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS)10.1109/RTAS.2019.00015(77-89)Online publication date: Apr-2019
https://doi.org/10.1109/RTAS.2019.00015

View Options

Get Access

Login options

Check if you have access through your login credentials or your institution to get full access on this article.

Cited By

Index Terms

Recommendations

SVF: interprocedural static value-flow analysis in LLVM

Precise Call Graph Construction for OO Programs in the Presence of Virtual Functions

Formal verification of SSA-based optimizations for LLVM