Home Archive
Archive
2026 Volume 63 Issue 5  Published: 2026-05-01
    Special Issue on Security and Trustworthiness for AI-Enabled Human-Cyber-Physical Systems
  • Zhen Dong , Dehui Du , Min Zhang , Tao Yue , Peng Liang
    doi: 10.7544/issn1000-1239.20265
  • Special Issue on Security and Trustworthiness for AI-Enabled Human-Cyber-Physical Systems
  • Chunhui Wang , Jiaqi Zhao , Xiaohong Chen , Zhi Jin
    doi: 10.7544/issn1000-1239.202550898

    The embedded system requirements specification serves as the cornerstone of system development, playing a crucial role in transforming high-level user intentions into clear and executable software requirements. Currently, this process remains highly dependent on manual derivation and composition by domain experts, with inherent limitations such as low efficiency and insufficient interpretability. Although automated requirements generation is regarded as a potential solution, its development still faces two core challenges: how to effectively embed domain-specific device knowledge, and how to strictly adhere to the standards of intent satisfiability and traceability to construct an interpretable requirements system. To address these issues, we propose an interpretable requirements specification method based on large language models (LLMs). By constructing a prompt chain that integrates domain knowledge and requirements engineering, our method gradually complements and refines user intentions into device, system, and software requirements level by level under human-computer interaction collaboration, ensuring the satisfiability of requirements. Additionally, it introduces the problem diagram and scenario diagram model to guarantee the traceability of requirements. Experiments on four embedded system cases show that compared with manual methods, our method reduces time cost by approximately 73% and improves the quality of requirements specification documents by 82%. Moreover, its interpretability increases by about 15% and 21% compared with both manual methods and single-step LLM methods, providing an efficient and reliable new approach for requirements specification of complex embedded systems.

  • Special Issue on Security and Trustworthiness for AI-Enabled Human-Cyber-Physical Systems
  • Zhengkang Zuo , Xiaoying Zhu , Zhen You , Changjing Wang
    doi: 10.7544/issn1000-1239.202550899

    Search tree algorithms are widely used in areas such as database indexing, compiler design, and file systems, where the functional correctness of these algorithms is a critical factor in ensuring software reliability. However, traditional development process faces two major challenges: first, algorithm design often lacks rigorous mathematical modeling, causing correctness verification to remain at an empirical level; second, existing verification approaches heavily rely on manual or interactive theorem proving, making the verification complexity grow exponentially with increasing algorithm scale. To address the above issues, an Isabelle-driven method for modeling and automated verification of search tree algorithms is proposed. This method builds on a formally verified functional modeling library to construct a modular modeling strategy that supports various search tree structures, and introduces a formal specification-driven framework for automatically synthesizing algorithmic code. Developers are required to supply only minimal functional expressions to complete the implementation. In addition, a reusable lemma library has been developed to support an automated block-wise verification strategy, significantly reducing verification costs. Furthermore, a method for generating functional executable programs is proposed. Experimental evaluation using a representative case study demonstrates that the proposed method substantially reduces verification costs. Compared with interactive verification approaches, the average reductions in code size and manual effort are 88.60% and 61.51%, respectively; compared with generative AI plus interactive verification methods, the average reductions in code size and manual effort are 88.09% and 41.76%, respectively. Overall, the proposed framework provides a systematic and highly automated solution for the formal verification of complex data structure algorithms in specific domains, while also offering a feasible pathway and methodological support for generating correct functional executable programs.

  • Special Issue on Security and Trustworthiness for AI-Enabled Human-Cyber-Physical Systems
  • Zhengkang Zuo , Chao Zhou , Yuhan Ke , Zhen You , Changjing Wang
    doi: 10.7544/issn1000-1239.202550901

    The priority search tree (PST) is a data structure that combines the characteristics of search trees and priority queues, enabling efficient retrieval of high-priority elements while maintaining worst-case search efficiency comparable to that of search trees. Nipkow et al. further modeled and mechanized the verification of PST with a static priority mechanism, laying an important foundation for its formal analysis and subsequent theoretical exploration. However, static priority mechanisms can lead to degraded performance under highly skewed access distributions, limiting their applicability in practice. To overcome this limitation, a functional adaptive priority search tree (FAPST) is proposed. FAPST adopts dynamic priority adjustment based on access frequency and is formally modeled and verified at the formal level to ensure functional correctness and reliability. This structure preserves balance and worst-case efficiency while adaptively responding to access patterns, thereby significantly improving the retrieval of frequently accessed elements. To further address the shifting nature of data hotspots in practical scenarios, a hotspot migration mechanism is introduced. This mechanism incorporates a priority decay strategy to accelerate responses to emerging hotspots and mitigate the stagnation of outdated ones. Experimental results demonstrate that, in both access-sensitive and hotspot-shifting workloads, the formally verified FAPST achieves notable reductions in the number of key function calls of 64.8% and 46.3% respectively, compared with conventional PSTs.

  • Special Issue on Security and Trustworthiness for AI-Enabled Human-Cyber-Physical Systems
  • Jiahao Zhu , Zichao Wei , Jingyi Guo , Ming Wen , Hai Jin
    doi: 10.7544/issn1000-1239.202550902

    Graph neural networks (GNNs) and code pre-trained models (CodePTMs) have been widely applied in vulnerability detection tasks, achieving the state-of-the-art (SOTA) performance on vulnerability benchmark datasets. However, such datasets (denoted as regular datasets) commonly collect vulnerable and non-vulnerable samples from different sources, resulting in significantly divergent code characteristics. Consequently, existing learning models tend to capture spurious features specific to certain datasets, rather than understanding the actual root causes of vulnerabilities. A robust and reliable vulnerability detection model should be able to make pairwise predictions, that is, recognizing the vulnerable code as vulnerable while the corresponding fixed version as non-vulnerable. However, the capability of existing learning models to make such pairwise predictions is significant and has not been explored extensively. Specifically, we first construct a large-scale real-world dataset containing vulnerable code and the corresponding fixed version. This ensures that positive and negative samples are derived from the same source, thus forming similar distributions in terms of code characteristics. We then evaluate eight mainstream SOTA vulnerability detection models in the rigorous setting to see if they can distinguish vulnerable code from its fixed versions (i.e., paired vulnerability instances). Our results reveal that all models perform poorly in making pairwise predictions when trained on regular datasets. We also find that retraining with these paired instances can improve the models’ performance by 17% on average. Furthermore, we highlight the limitations of existing CodePTMs in aggregating local code information (i.e., a key statement concerning vulnerable semantics). Driven by our findings, we devise a new approach and the evaluation results demonstrate that it outperforms the SOTA model UniXcoder by 58.47% towards making pairwise predictions.

  • Special Issue on Security and Trustworthiness for AI-Enabled Human-Cyber-Physical Systems
  • Quan Zhang , Juexiao Feng , Chijin Zhou , Yu Jiang
    doi: 10.7544/issn1000-1239.202550874

    The evolution of large language models (LLMs) and Model Context Protocol (MCP) has facilitated the development of various MCP servers and tools that extend LLM capabilities, allowing LLMs to interact with external services and content. However, these servers also introduce new security threats. Specifically, they are granted privileges to automate tasks such as email processing and cloud infrastructure management. Due to the inherent instability of LLM outputs and their susceptibility to manipulation, attackers can exploit LLMs to illicitly invoke these tools, causing severe damage. Therefore, the analysis and control of privileges for LLM servers are of paramount importance. This research designs an automated analysis framework to analyze MCP servers and their associated tools. Through static analysis, the framework identifies the privileged APIs called by these tools and their invocation methods. It then categorizes these privileges based on their sensitivity and corresponding behaviors to investigate the current state of privilege usage. We collect 1609 MCP servers and conduct a detailed analysis of 200, revealing that each server requests an average of 40.74 privileged APIs. Furthermore, a significant 52% of these privilege validations rely on API Tokens and passwords, which fail to adhere to the principle of least privilege. This study calls for developers to implement stricter privilege controls for MCP servers and actively explore more secure authorization mechanisms.

  • Computer Architecture
  • Ziwei Huang , Yiqi Yao , Yungang Bao , Sa Wang
    doi: 10.7544/issn1000-1239.202440970

    Improving resource utilization is important for cloud service providers to achieve cost reduction and efficiency, as the cost of construction and operating costs in datacenters are extremely high. However, existing metrics such as benchmarks are often scenario-specific and lack adaptability. Some metrics, such as simulated or pre-execution solutions are struggle to cope with sudden workload fluctuations. Therefore, cloud service providers urgently require a real-time performance metric for monitoring performance and managing resources. Existing real-time metrics often rely on software or hardware support, and most fail to accurately identify resource bottlenecks. To address this challenge, we propose KFCMetric (metric based on kernel function call frequencies), a performance metric based on the frequency of kernel function calls. KFCMetric employs static kernel analysis techniques to generate kernel function call graphs and utilizes a random forest algorithm to select kernel functions that exhibit a strong correlation with application performance and resource status. The behavior of these kernel can dynamically reflect the runtime resource state of applications and accurately pinpoint the root causes of performance bottlenecks. Building on KFCMetric, we further introduce a resource management system, KFCSys. Using dynamic kernel instrumentation techniques, KFCSys captures the calls and returns of these kernel functions and uses a variance-based scaling algorithm to measure the deviation of data points from normal. Based on the real-time status of latency-critical applications, KFCSys dynamically adapts resource allocation to meet the resource requirements of latency-critical applications, ensuring their service quality. Experimental results indicate that KFCMetric achieves an accuracy of 96.7% in detecting resource bottlenecks, and its interference detection accuracy shows up to a 31.4% improvement over CPI. In terms of resource management, KFCSys reduces the average tail latency by up to 30.4% compared with PARTIES, and by 40.7% compared with the standard Linux resource management system. Moreover, KFCSys decreases the proportion of performance violation time by 10% relative to PARTIES. Therefore, in scenarios where hardware or software support is not available, KFCMetric, constructed from kernel function features, is a novel and robust performance metric for performance monitoring and resource management.

  • Computer Architecture
  • Chaoyang Jia , Shi Chen , Jingyu Liu , Li Shen
    doi: 10.7544/issn1000-1239.202550219

    With the continuous advancement of computer hardware and software, graph computing has been widely applied in many fields, including social network analysis, recommendation systems, bioinformatics, and fraud detection. The memory access behavior in graph computing is highly variable: different kernels accessing property arrays exhibit different spatial locality when graph computing is executed on a GPU, and the same kernel shows varying spatial locality across different property arrays. Existing cache optimization strategies in GPU architectures fail to enhance the performance of graph computing effectively. State-of-the-art cache optimization strategies cannot implement distinct management strategies for data with different reusability, which is an essential reason for the poor performance of graph computing. To address this, AB-Cache architecture is proposed, specifically designed for GPU platforms. AB-Cache adopts an adaptive approach that utilizes two cache structures to optimize memory access requests with different spatial locality characteristics. An online automatic classification mechanism compatible with AB-Cache architecture is also proposed, enabling fast classification of memory access requests with different spatial locality with minimal overhead. Comprehensive evaluations across multiple graph computing applications and a wide range of graph datasets show that AB-Cache scheme achieves a 1.14 times speedup over the baseline, demonstrating its effectiveness and practicality in optimizing graph computing performance.

  • Computer Architecture
  • Ziwei Deng , Wei Guo , Yaming Xu , Qing Wang , Deshan Zhang , Shengcai Lu , Tao Liu
    doi: 10.7544/issn1000-1239.202550393

    The three-dimensional fast Fourier transform (3D-FFT) algorithm serves as a fundamental computing kernel for numerous high performance computing (HPC) applications, where its efficient implementation critically determines the overall system performance. We propose a heterogeneous computing architecture leveraging CPU-FPGA co-processing to address the performance bottlenecks in conventional 3D-FFT implementations, including inefficient memory access patterns, procedural redundancy, and limited parallelization capabilities. Three key architectural innovations are introduced: 1) a hierarchical data management strategy enabling multi-channel data transmission with optimized bandwidth utilization; 2) a pipelined synchronization mechanism that overlaps matrix transpose operations with FFT computation; 3) a scalable parallel computation architecture supporting up to 128 concurrent FFT processing units. Experimental evaluations demonstrate significant performance improvements of 3D-FFT for common scientific computing scenarios involving 643 and 1283 matrices. Compared with CPU-only solutions, the proposed architecture achieves computation time reductions of 62.7% and 56.6% for 643 and 1283 matrices, respectively. When compared with existing FPGA-accelerated 3D-FFT implementations, the proposed design exhibits performance enhancements of 32.6% and 35.3% for the corresponding matrix sizes. These results validate our architecture’s effectiveness in optimizing memory utilization, improving task synchronization efficiency and enhancing computational parallelism. The solution provides a scalable and energy-efficient acceleration architecture for HPC systems requiring large-scale 3D-FFT computations, particularly in scenarios demanding high throughput and low latency.

  • Computer Architecture
  • Dongyang Li , Zeyang Li , Yibin Tang , Bosheng Liu , Jigang Wu
    doi: 10.7544/issn1000-1239.202550645

    Hybrid bit-width block floating point (BFP) offers a flexible solution for low bit-width convolution computations, optimizing storage efficiency and computational precision. By assigning higher bit-widths to numerically sensitive layers while using lower bit-widths for redundant or stable regions, this approach preserves near-floating-point accuracy with substantially reduced computational and storage cost. Recent researches have deployed hardware solutions such as field programmable gate arrays (FPGAs) for hybrid bit-width BFP-based convolution accelerations, but they tend to underutilize FPGA resources by overlooking the full potential of digital signal processors (DSPs). Specifically, the underutilization of DSPs often leads to unnecessary resource waste and limited computational throughput, which restricts the overall performance of FPGA-based BFP convolution accelerators. This work develops a novel FPGA-based BFP convolution processing unit, termed “BE-HB”, capable of coupling two sets of BFP convolution calculations in dual-mode bit-width (i.e., 8 b or 16 b) using a single DSP for high performance. We then introduce a novel mapping method that reuses the shared exponents and private mantissas of BFP representations to perform two sets of BFP convolution computations within 8 b or 16 b DSP data paths. By leveraging the exponent sharing, data packing and data reuse, the proposed approach significantly reduces hardware resource overhead. Compared with representative baseline designs, the proposed design achieves an average reduction of 61.4% in LUT utilization while maintaining model accuracy, thereby delivering superior performance and resource efficiency, which makes it more suitable for resource-constrained FPGA-based edge computing platforms.

  • Artificial Intelligence
  • Peng Tan , Zhihua Zhou
    doi: 10.7544/issn1000-1239.202550460

    Machine learning techniques have been widely applied in various fields but still face numerous challenges, including heavy dependence on large-scale training data, limited adaptability to changing environments, concerns regarding data privacy and ownership, and the issue of catastrophic forgetting. The learnware paradigm provides a systematic solution to these challenges, focusing on reusing existing high-quality models to tackle new tasks instead of training models from scratch. The learnware comprises a model and a specification describing its capabilities. Various learnwares are managed by the learnware dock system. Existing studies have shown the effectiveness of this paradigm when learnwares and user tasks share the same feature space. However, in real-world scenarios, the system often lacks models that precisely match the feature space of user’s task. Current work has preliminarily explored the identification and reuse of single learnware in heterogeneous feature spaces. However, the performance of a single heterogeneous learnware is limited and may fall short when addressing the entirety of a user task. While multiple heterogeneous learnwares can complement each other’s capabilities, the key challenge lies in identifying and effectively integrating the localized strengths of different heterogeneous learnwares. We propose a decision tree-like learnware assembly algorithm, which effectively integrates the high-confidence regions of multiple heterogeneous learnwares. Furthermore, to facilitate the effective learnware recommendation, we introduce an identification mechanism based on reuse performance estimation. Experiments demonstrate that even in the absence of models that perfectly match the user’s task, the proposed method can effectively assist the system in recommending potentially useful heterogeneous learnwares and significantly outperform models trained from scratch through tree-like assembly.

  • Artificial Intelligence
  • Wei Zhang , Dong’ao Zhou , Yongshun Gong , Yilong Yin
    doi: 10.7544/issn1000-1239.202550355

    With the advent of the big data era, various enterprises and organizations have accumulated massive amounts of data driven by the growing demands for business expansion and information. This data are typically stored in relational databases in structured or semi-structured formats. SQL, as a structured database query language, has long been widely used for data retrieval and processing. It provides professionals with an efficient way to interact with databases, thereby facilitating quicker and more convenient data sharing and analysis. With the exponential advancement of large language models (LLMs), in-context learning (ICL) has shown significant promise for the text-to-SQL task, where LLMs utilize reference examples to accurately generate SQL queries. To fully harness the potential of LLMs through ICL for text-to-SQL, we propose a new SQL generation pipeline comprising three parts: first, we propose a schema enhancement component to strengthen LLMs’ focus on question-related information. Second, we leverage the inherent structure of SQL to preselect semantically similar, aiding in the generation of initial pseudo-SQL queries. Third, a selection strategy is proposed for selecting reference examples, which considers the similarities between the question and the pseudo-SQL structure to enhance the accuracy of the generated SQL queries. We implement an iterative refinement process in both stages, employing a boosting-like mechanism that progressively improves selection until stabilization is achieved. Extensive experiments across various models and datasets demonstrate the effectiveness of our approach.

  • Artificial Intelligence
  • Donghong Xu , Shilong Wu
    doi: 10.7544/issn1000-1239.202550320

    Visual reinforcement learning has demonstrated enormous potential across a wide range of domains. However, current algorithms still face two core challenges: insufficient generalization capability and low sample efficiency. Due to the limited availability of training data and the diversity and complexity of environments, reinforcement learning agents often become overly reliant on specific features present in the training settings, which hampers their ability to adapt to novel environments. Even minor environmental changes can induce significant alterations in image pixels, thereby affecting the latent representations learned by the agents and ultimately causing their policies to fail. To develop robust representations, we introduce the environment disentangled representation learning (EDRL) algorithm for visual reinforcement learning. It employs a self-supervised framework to extract environment-invariant features, thereby significantly enhancing the agent’s generalization and sample efficiency. Firstly, by employing periodic data augmentation and integrating historical observations, the method simulates complex environmental changes and expands the effective observation range, thus reducing policy biases caused by training instability. Secondly, robust, environment-invariant features are obtained by disentangling latent features and isolating them through reconstruction. Finally, by predicting the changes in representations across time steps and incorporating a dynamic consistency loss, the approach ensures the consistency and robustness of the representations. Experimental results demonstrate the effectiveness of EDRL, as validated on the DMControl generalization benchmark (DMControl-GB) and the distracting control suite (DistractingCS). The results indicate that, compared with state-of-the-art methods, EDRL achieves an average performance improvement of over 15% in complex scenarios on DMControl-GB and over 20% in highly distracting environments on DistractingCS.

  • Artificial Intelligence
  • Leilei Geng , Zhenxi Xu , Zexuan Ji , Sihan Wu , Linwei Fan , Hui Liu
    doi: 10.7544/issn1000-1239.202550492

    Segmenting skin lesions from dermatoscopic images is crucial for the quantitative analysis and early diagnosis of skin cancer. However, automatic segmentation remains challenging due to blurred lesion boundaries, low contrast between lesions and surrounding skin, and the presence of artifacts, all of which complicate the segmentation process. Although the visual state space model based on Mamba architecture demonstrates notable advantages over Transformer models in terms of linear computational complexity and long-range dependency modeling, it still struggles to preserve the topological integrity of segmentation results. To address this issue, a topological prior guided dual-branch vision Mamba network (TDBVM) is proposed. The proposed architecture adopts a dual-encoder design to extract topological priors and deep semantic features independently. In particular, the topology branch incorporates a multi-color space topological component extraction module to generate topological prior maps. These priors are fused with visual features through a multi-scale fusion mechanism, effectively guiding feature learning, enhancing the model’s ability to capture complex lesion boundaries and morphological variations, and suppressing artifacts. Experimental results on ISIC2018, ISIC2017, ISIC2016 and PH2 datasets demonstrate that the proposed method significantly outperforms existing state-of-the-art approaches in terms of both segmentation accuracy and topological structure preservation, showing better segmentation results and robust generalization capability.

  • Network Technology
  • Zhetao Li , Xiyu Zeng , Jianhui Wang , Yong Xiao , Zhongren Liu , Junru Wu , Junjie Lai , Jijun Huang , Saiqin Long
    doi: 10.7544/issn1000-1239.202550223

    While the primary function of computers lies in computation and processing, the core value of the Internet is rooted in sharing and collaboration. Computers create the Internet, and the Internet empowers the value of computers. The rapid development of the Internet, cloud computing, and big data is pushing artificial intelligence into the era of large models (LMs). However, the practical application of LMs is currently hindered by high training costs and deployment complexities, driving a shift toward lightweight, private, and domain-specific models. With the rapid proliferation and wide distribution of heterogeneous models, enabling effective interaction and collaboration among them has emerged as a critical bottleneck that urgently needs to be addressed in LM development. Drawing inspiration from the development of the Internet, we propose the concept, vision, and system architecture of world wide AI-model network (AI-ModelNet). It is a novel paradigm that achieves interconnection, capability sharing, and collaborative reasoning by establishing pathways between models. We first briefly review the current state of single-model and multi-model research. Subsequently, the systemic vision and hierarchical architecture of AI-ModelNet are articulated, followed by validation of the framework’s feasibility through a prototype system and diverse application cases. Finally, key directions for future research are discussed preliminarily.

  • Network Technology
  • Zitong Zhang , Haoxiang Han , Chaoming Shi , Zheng Yan , Haiguang Wang , Tieyan Li
    doi: 10.7544/issn1000-1239.202550305

    Blockchain sharding, which divides a blockchain network into multiple shards to process transactions in parallel, is widely considered to be one of the most effective techniques for enhancing blockchain scalability and system performance. However, existing sharding schemes primarily focus on optimizing point-to-point asset transfer transactions and exhibit significant limitations in supporting Turing-complete smart contracts. Since executing the business logic based on Turing-complete smart contracts typically involves initiating multiple internal transactions to synchronize state across shard, designing the schemes of blockchain sharding with smart contract compatibility (BS-SCC) presents significant and unique challenges. Although there are some studies in the literatures, there is still a lack of a systematic survey to review the academic progress and research landscape. This paper provides a comprehensive survey on existing BS-SCC schemes. First, we introduce the research motivation and basic concepts of BS-SCC. Next, we propose a taxonomy of BS-SCC schemes based on the dimensions of transaction execution and state storage, categorizing them into such classes as on-chain and off-chain execution models. Then, we propose a set of criteria for evaluating BS-SCC schemes that encompass reliability, effectiveness, and other performance properties. By employing the proposed criteria, we furthermore conduct a multi-dimensional comparative analysis of existing schemes. Finally, we identify a list of technical bottlenecks and suggest corresponding future research directions to offer theoretical insights and practical guidance for advancing BS-SCC.

  • Network Technology
  • Hui Yang , Yutao Zhang , Mandi Huang , Yulei Yuan , Qing Wang , Tao Li
    doi: 10.7544/issn1000-1239.202550472

    Remote direct memory access(RDMA)technology is widely used in high-performance computing and intelligent computing scenarios that require high bandwidth and low latency transmission, offering significant advantages over traditional TCP/IP protocol stacks in terms of bandwidth, efficiency, and latency. It has gradually become an industry consensus for high-speed sensors to access computing networks through RDMA technology. However, deploying RDMA in this scenario faces challenges due to the limited resources of embedded sensor nodes, making it difficult to deploy traditional software stacks. We conduct research on lightweight techniques for embedded RDMA software stacks, proposing a lightweight RDMA connection establishment method based on reliable UDP and a lightweight RDMA driver based on reliable Ethernet under conditions without high-performance CPU or operating system. An ultra-lightweight RDMA software stack suitable for embedded sensor nodes is designed. The experimental results show that the lightweight RDMA software stack for embedded systems can reduce the connection establishment overhead by approximately 94% and the software driver overhead by 84% compared with the standard RDMA software stack. The embedded sensor nodes and standard nodes use RDMA technology to perform sensor data acquisition and reliable transmission through one-level switching, with a system bandwidth of up to 98.04 Gbps, end-to-end latency as low as 4.58 μs, and CPU overhead of standard nodes within the system as low as 4.2%. In terms of protocol compatibility, as the number of queue pairs and data volume increase, the READ and WRITE bandwidths of embedded RDMA nodes can reach the peak performance of standard nodes. Meanwhile, the READ and WRITE latency remains at the microsecond level when the data volume is small.

  • Software Technology
  • Yuanming Lai , Zhe Wang , Chenggang Wu , Ding Yu , Chengxuan Hou
    doi: 10.7544/issn1000-1239.202440881

    Integrating C/C++ with assembly language is a common practice in software development, particularly in operating system-level software. However, programming with inline assembly can be more error-prone due to its complex architecture-related details and the lack of compiler checks. Modern software engineering employs static analysis to detect bugs and security vulnerabilities. Nevertheless, analyzing inline assembly poses challenges beyond the capabilities of LLVM IR-based static analysis tools. If the effects of inline assembly on data flow and control flow are not addressed effectively, the result can be a rise in false positives and a decline in precision. We present LASM, an innovative tool that can automatically lift x86 inline assembly code into LLVM IR and integrate it with the IR generated from compiling the C/C++ code. LASM enables downstream static analysis tools to perform whole program analysis on applications containing inline assembly code fragments, thereby reducing false positives and improving precision. It emulates hardware and the semantics of assembly instructions using LLVM IR. By providing optional optimizations that simplify the semantics of atomic instructions and enhance pointer arithmetic semantics, LASM supports static analysis tools more effectively. By completely and accurately emulating assembly instructions, the LLVM IR lifted by LASM can be compiled into an executable program. The strength of LASM lies in its ease of integration; LLVM IR-based static analysis tools can analyze inline assembly code by incorporating it seamlessly into their existing workflows without requiring additional modifications or adaptations to their implementations. LASM facilitates the reuse of many pre-existing tools in the ecosystem. Our experimental results indicate that LASM effectively supports SVF-based static analysis on the Linux kernel. This analysis systematically categorizes global variables based on whether their access occurs during the initialization or post-initialization phase. The results show an impressive 62.03% reduction in misclassifications and an 8.06 percentage point increase in precision. LASM helps to identify 14.80% more protectable variables without introducing new misclassifications. These results highlight LASM’s potential to enhance the effectiveness of static analysis in the presence of inline assembly code.