Per Lindgren, Nils Fitinghoff, Jorge Martínez Aparicio · 2019
Memory safety is instrumental to the safety and security of software systems. The Rust language stands out with a type system and underlying memory model targeting memory safety without the need for dynamic garbage collection, making Rust a viable option for embedded applications. In this paper we present an integrated tool for call-stack analysis of Rust applications. We cover both theoretical and practical challenges, their solutions and open questions. The cargo-call-stack tool is useful for analyzing Rust applications in general, and embedded Rust in particular. To the latter, we show that using the call-stack analysis we can give guarantees of total memory safety, free of assumptions on operating systems and underlying memory protection mechanisms in hardware. The feasibility of the approach is demonstrated by applying the `call-stack' tool on production code targeting a light-weight ARM Cortex-M platform.
Cited by 3
Bulletin of Miscellaneous Information (Royal Gardens Kew)
Cited by 0
Byoungyoung Lee, Yeongjin Jang, Tielei Wang et al. · 2011
Cited by 0
Scott McMaster, Azhar M. Memon · 2005
Test suite reduction is an important test maintenance activity that attempts to reduce the size of a test suite with respect to some criteria. Emerging trends in software development such as component reuse, multi-language implementations, and stringent performance requirements present new challenges for existing reduction techniques that may limit their applicability. A test suite reduction technique that is not affected by these challenges is presented; it is based on dynamically generated language-independent information that can be collected with little run-time overhead. Specifically, test cases from the suite being reduced are executed on the application under test and the call stacks produced during execution are recorded. These call stacks are then used as a coverage requirement in a test suite reduction algorithm. Results of experiments on test suites for the space antenna-steering application show significant reduction in test suite size at the cost of a moderate loss in fault detection effectiveness.
Cited by 55
Ju Qian, Lin Chen, Baowen Xu et al. · Information and Software Technology · 2010
Cited by 0
Johan Söderström, Rashid Aligholipour, Yuan Yao · Zenodo (CERN European Organization for Nuclear Research) · 2026
Cited by 0Open access
Harald Servat, Germán Llort, Juan González et al. · QRU Quaderns de Recerca en Urbanisme · 2016
The correlation of performance bottlenecks and their associated source code has become a cornerstone of performance analysis. It allows understanding why the efficiency of an application falls behind the computer's peak performance and enabling optimizations on the code ultimately. To this end, performance analysis tools collect the processor call-stack and then combine this information with measurements to allow the analyst comprehend the application behavior. Some tools modify the call-stack during run-time to diminish the collection expense but at the cost of resulting in non-portable solutions. In this paper, we present a novel portable approach to associate performance issues with their source code counterpart. To address it, we capture a reduced segment of the call-stack (up to three levels) and then process the segments using an algorithm inspired by multi-sequence alignment techniques. The results of our approach are easily mapped to detailed performance views, enabling the analyst to unveil the application behavior and its corresponding region of code. To demonstrate the usefulness of our approach, we have applied the algorithm to several first-time seen in-production applications to describe them finely, and optimize them by using tiny modifications based on the analyses.
Cited by 5Open access
Kurz, Joachim · RWTH Publications (RWTH Aachen) · 2011
Cited by 1
Johan Söderström, Rashid Aligholipour, Yuan Yao · Zenodo (CERN European Organization for Nuclear Research) · 2026
Cited by 0Open access
Stephen Chang, David Van Horn, Matthias Felleisen · Lecture notes in computer science · 2011
Cited by 4
Richard J. Eickemeyer · Defense Technical Information Center (DTIC) · 1985
A processor organization is presented to reduce the large overhead of procedure calls in high-level languages. In the Parallel Stack Processor, processor registers are each at the top of a hardware stack of registers. Saving processor registers on procedure call takes place in one cycle by pushing all registers simultaneously. A detailed performance model, driven by dynamic high-level language statistics, is presented. Results from the model indicate the effect on performance of the parallel stack computer architecture when compared to a processor without parallel stacks. The processor architecture is specified in the report along with a discussion of implementation details for the VLSI single-chip processor. Keywords: Parallel processors; Stacking; and Reduced Instruction Set Computer. (Author)
Cited by 0
Goverdhan Reddy Jidiga, P. Sammulal · 2014
The call stack is an important baseline to detecting the intrusions spread over the system application programs penetrate and injected with malicious programs, also exploited by unauthorized users. But the previous work presented based on stack with the long training period, so in this paper demonstrate the extraction of sequences of return addresses generated by function calls in the code. This approach use two sets of input test data like return address set and function call sequence (virtual path) set. We apply smart trace tool and it is easy for anomaly detection and finding the unknown coding exploits as anomaly. We tested 14 attacks on Linux platform by setting different threshold values while training and given the affect of this technique with discussions on false positive rate.
Cited by 3
Bogdan Ditu · 2015
This paper presents a way of modeling the application binary interface aspects related to stack layout and function call sequence in the context of code generation and stack management for retargetable compilers (implementation and targeting for new architectures). This paper tries to present a model of stack layout and function call sequences as solution for the problem of efficient code generation related to function calls and stack management without compiler redesign in the context of efficient, architecture specific, non-standardized application binary interfaces. The proposed solution is centered toward the application binary interface model with four components (for description of stack layout, function call scenario, save / restore information around function calls, parameter passing convention) and three methods using this ABI model that are integrated in the retargetable compiler flow (the code generation for prologue / epilogue sequences, the code generation for function calls and parameter passing and the stack management).
Cited by 1
Mark Foster, Joseph N. Wilson, Shigang Chen · Lecture notes in computer science · 2004
Cited by 3
Pjotr Prins, N. Goto, Andrew Yates et al. · Methods in molecular biology · 2012
Open-source software (OSS) encourages computer programmers to reuse software components written by others. In evolutionary bioinformatics, OSS comes in a broad range of programming languages, including C/C++, Perl, Python, Ruby, Java, and R. To avoid writing the same functionality multiple times for different languages, it is possible to share components by bridging computer languages and Bio* projects, such as BioPerl, Biopython, BioRuby, BioJava, and R/Bioconductor. In this chapter, we compare the two principal approaches for sharing software between different programming languages: either by remote procedure call (RPC) or by sharing a local call stack. RPC provides a language-independent protocol over a network interface; examples are RSOAP and Rserve. The local call stack provides a between-language mapping not over the network interface, but directly in computer memory; examples are R bindings, RPy, and languages sharing the Java Virtual Machine stack. This functionality provides strategies for sharing of software between Bio* projects, which can be exploited more often. Here, we present cross-language examples for sequence translation, and measure throughput of the different options. We compare calling into R through native R, RSOAP, Rserve, and RPy interfaces, with the performance of native BioPerl, Biopython, BioJava, and BioRuby implementations, and with call stack bindings to BioJava and the European Molecular Biology Open Software Suite. In general, call stack approaches outperform native Bio* implementations and these, in turn, outperform RPC-based approaches. To test and compare strategies, we provide a downloadable BioNode image with all examples, tools, and libraries included. The BioNode image can be run on VirtualBox-supported operating systems, including Windows, OSX, and Linux.
Cited by 2Open access
Shams Azad, Peter C. Rigby, Latifa Guerrouj · ACM Transactions on Software Engineering and Methodology · 2017
Researchers have shown that related functions can be mined from groupings of functions found in the version history of a system. Our first contribution is to expand this approach to a community of applications and set of similar applications. Android developers use a set of application programming interface (API) calls when creating apps. These API calls are used in similar ways across multiple applications. By clustering co-changing API calls used by 230 Android apps across 12k versions, we are able to predict the API calls that individual app developers will use with an average precision of 75% and recall of 22%. When we make predictions from the same category of app, such as Finance, we attain precision and recall of 81% and 28%, respectively. Our second contribution can be characterized as “programmers who discussed these functions were also interested in these functions.” Informal discussions on Stack Overflow provide a rich source of information about related API calls as developers provide solutions to common problems. By grouping API calls contained in each positively voted answer posts, we are able to create rules that predict the calls that app developers will use in their own apps with an average precision of 66% and recall of 13%. For comparison purposes, we developed a baseline by clustering co-changing API calls for each individual app and generated association rules from them. The baseline predicts API calls used by app developers with a precision and recall of 36% and 23%, respectively.
Cited by 33
Qiang Zhang, Yifei Chu, Yuheng Shen et al. · 2025
The Linux kernel network stack is a critical component of modern operating systems, widely deployed across platforms and often exposed to untrusted inputs. Its complex and stateful nature makes it a frequent target of security vulnerabilities, particularly those triggered by subtle protocol interactions. While existing fuzzers like syzkaller have demonstrated strong capabilities in discovering kernel bugs, they face challenges in exercising deep protocol logic due to the lack of coordinated inputs and protocol awareness. In this paper, we present Tron, a tool designed for fuzzing the Linux kernel network stack. By synthesizing syscall–packet input sequences based on protocol structure and incorporating runtime feedback, Tron enables the exploration of protocol-dependent state transitions and deep execution paths. Our approach addresses the fundamental challenges in dual-input fuzzing by integrating protocol knowledge with execution feedback. We evaluate Tron on four recent Linux kernel versions and compare it against syzkaller and kernelGPT. The results show that Tron improves branch coverage by 22.9% and 12.1% over syzkaller and kernelGPT, respectively, and discovers 25 previously unknown bugs, 7 of which have been fixed. These results demonstrate the effectiveness of protocol–system call input synthesis in enhancing network stack fuzzing and uncovering hard-to-reach bugs in kernel protocol implementations.
Cited by 0
Jing Qiu, Xiao Hong Su, Jun Pei · Advanced materials research · 2014
Instruction traces are essential for dynamic analysis in reverse engineering. Code in instruction traces is often obfuscated to hinder analysts from understanding and analyzing in malware and binaries that protected by packers. Non-returning calls and call-stack tampering are two typical kinds of such obfuscation. We propose a deobfuscation approach to fight against these two kinds of obfuscated code. We first apply static analysis on instruction traces to identify obfuscated code. Then we transform obfuscated code into semantically equivalent instructions to make the code be easy to understand. Evaluations results on some packed binaries indicate that our approach works well in deobfuscate instruction traces with non-returning calls and call-stack tampering in high precision.
Cited by 0
Veerle Desmet, Yiannakis Sazeides, Constantinos Kourouyiannis et al. · 2008
It is accepted that the alignment of a return-addressstack can be preserved by checkpointing on branches and recovering on branch mispredictions the top-ofstack pointer. However, virtually all published literature, is vague or proposes sub-optimal algorithms on how to repair the alignment of a return-address-stack on call and return mispredictions. Possible manifestations of this ambiguity are lower performing implementations of return-address-stack mechanisms in processors and simulators. This paper suggests that on call and return mispredictions the recovered top-of-stack pointer should point to the next and previous stack position respectively relative to the checkpointed top-ofstack pointer. It is established experimentally that the proposed method can improve the performance, over an otherwise identical processor configuration, on the average by 2 % and by as much as 10%. This corresponds to a drop in return-address mispredictions by 40%, from 11.3 % downto 6.7%. This work also considers whether the performance of one of the best known return-address-stack methods, proposed several years ago, is satisfactory with increasing pipeline depth. The results show that the average performance of the method is still satisfactory, but for some benchmarks appears insufficient. This may suggest a need for better returnaddress predictors. 1.
Cited by 0
Hyukwoo Park, Seonghyun Kim · IEEE Access · 2024
JavaScript has significantly evolved, broadening its capabilities. However, the uptake of tail call optimization (TCO) remains limited, largely due to concerns about debugging difficulties and the potential increase in overall complexity. This paper highlights the compelling importance of tail calls within web applications, advocating for TCO as a means to boost performance and enhance memory efficiency. We present an innovative TCO technique that leverages the native stack within JavaScript engines, capitalizing on the native stack’s inherent benefits over heap memory. This technique is carefully crafted to comply with diverse TCO standards, prioritizing simplicity and providing debugging features. We tackle the inherent challenges of TCO and successfully deploy our method in a lightweight JavaScript engine. Our approach is rigorously evaluated, proving its effectiveness and practicality. Notably, our implementation facilitates considerable memory savings for web applications, comparable to the maximum Resident Set Size (RSS), and achieves an average performance improvement of approximately 19.8% for algorithms that are heavily recursive. This research not only demonstrates the versatility and efficiency of our TCO strategy but also makes a significant contribution to the wider adoption and comprehension of TCO, thereby improving JavaScript engines’ performance and memory management efficiency.
Cited by 1Open access