2727-Proper-C-Parser-GhidraClangPoweredParse.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: PlayDay <18056374+playday3008@users.noreply.github.com>
Date: Thu, 26 Mar 2026 15:59:00 +0100
Subject: [PATCH] 2727: Proper C++ Parser (GhidraClangPoweredParse)

---
 Ghidra/Features/Base/certification.manifest   |   26 +
 .../java/ghidra/app/util/gcpp/GCPPPlugin.java |  352 ++++++
 .../util/gcpp/clang/CallingConvention.java    |   53 +
 .../ghidra/app/util/gcpp/clang/Cursor.java    |  346 ++++++
 .../app/util/gcpp/clang/CursorKind.java       |  313 +++++
 .../app/util/gcpp/clang/Diagnostic.java       |   71 ++
 .../ghidra/app/util/gcpp/clang/Index.java     |   49 +
 .../util/gcpp/clang/JavaVersionHelper.java    |   47 +
 .../ghidra/app/util/gcpp/clang/LibClang.java  |  955 ++++++++++++++++
 .../app/util/gcpp/clang/SourceLocation.java   |   68 ++
 .../app/util/gcpp/clang/TranslationUnit.java  |  231 ++++
 .../java/ghidra/app/util/gcpp/clang/Type.java |  199 ++++
 .../ghidra/app/util/gcpp/clang/TypeKind.java  |  115 ++
 .../util/gcpp/clang/error/ParseErrorCode.java |   36 +
 .../util/gcpp/clang/error/ParseException.java |   22 +
 .../gcpp/processing/ArchitectureMapping.java  |  260 +++++
 .../app/util/gcpp/processing/ParsedEnum.java  |   27 +
 .../gcpp/processing/ParsedFunctionType.java   |   71 ++
 .../util/gcpp/processing/ParsedStructure.java |   81 ++
 .../app/util/gcpp/processing/ParsedType.java  |   20 +
 .../util/gcpp/processing/ParsedTypedef.java   |   27 +
 .../app/util/gcpp/processing/ParsedUnion.java |   60 +
 .../util/gcpp/processing/ParsedVtable.java    |   93 ++
 .../util/gcpp/processing/SourceParser.java    |  625 ++++++++++
 .../app/util/gcpp/processing/TypePool.java    |  319 ++++++
 .../app/util/gcpp/task/ClangParseTask.java    |  212 ++++
 .../app/util/gcpp/ui/ClangParseDialog.java    | 1005 +++++++++++++++++
 .../RuntimeScripts/support/launch.properties  |    6 +
 28 files changed, 5689 insertions(+)
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/GCPPPlugin.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CallingConvention.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Cursor.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CursorKind.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Diagnostic.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Index.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/JavaVersionHelper.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/LibClang.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/SourceLocation.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TranslationUnit.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Type.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TypeKind.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseErrorCode.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseException.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ArchitectureMapping.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedEnum.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedFunctionType.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedStructure.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedType.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedTypedef.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedUnion.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedVtable.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/SourceParser.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/TypePool.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/task/ClangParseTask.java
 create mode 100644 Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/ui/ClangParseDialog.java

diff --git a/Ghidra/Features/Base/certification.manifest b/Ghidra/Features/Base/certification.manifest
index 8fcedb9297..75c3cfa6e5 100644
--- a/Ghidra/Features/Base/certification.manifest
+++ b/Ghidra/Features/Base/certification.manifest
@@ -837,6 +837,32 @@ src/main/java/ghidra/app/util/bin/format/stabs/types/StabsTypeModifierTypeDescri
 src/main/java/ghidra/app/util/bin/format/stabs/types/StabsTypeReferenceTypeDescriptor.java||GHIDRA||||END|
 src/main/java/ghidra/app/util/bin/package.html||GHIDRA||||END|
 src/main/java/ghidra/app/util/exporter/package.html||GHIDRA||||END|
+src/main/java/ghidra/app/util/gcpp/GCPPPlugin.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/CallingConvention.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/Cursor.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/CursorKind.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/Diagnostic.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/Index.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/LibClang.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/JavaVersionHelper.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/SourceLocation.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/TranslationUnit.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/Type.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/TypeKind.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/error/ParseErrorCode.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/clang/error/ParseException.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ArchitectureMapping.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ParsedEnum.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ParsedFunctionType.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ParsedStructure.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ParsedType.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ParsedTypedef.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ParsedUnion.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/ParsedVtable.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/SourceParser.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/processing/TypePool.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/task/ClangParseTask.java||Apache License 2.0||||END|
+src/main/java/ghidra/app/util/gcpp/ui/ClangParseDialog.java||Apache License 2.0||||END|
 src/main/java/ghidra/app/util/importer/package.html||GHIDRA||||END|
 src/main/java/ghidra/app/util/opinion/package.html||GHIDRA||||END|
 src/main/java/ghidra/app/util/package.html||GHIDRA||||END|
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/GCPPPlugin.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/GCPPPlugin.java
new file mode 100644
index 0000000000..26d4517dfe
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/GCPPPlugin.java
@@ -0,0 +1,352 @@
+/**
+ * Copyright 2024 playday3008
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+ * provided that the above copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+package ghidra.app.util.gcpp;
+
+import docking.ActionContext;
+import docking.action.DockingAction;
+import docking.action.MenuData;
+import docking.tool.ToolConstants;
+import docking.widgets.OptionDialog;
+import ghidra.app.CorePluginPackage;
+import ghidra.app.plugin.PluginCategoryNames;
+import ghidra.app.plugin.ProgramPlugin;
+import ghidra.app.services.DataTypeManagerService;
+import ghidra.app.util.gcpp.clang.error.ParseException;
+import ghidra.app.util.gcpp.processing.SourceParser;
+import ghidra.app.util.gcpp.processing.TypePool;
+import ghidra.app.util.gcpp.task.ClangParseTask;
+import ghidra.app.util.gcpp.ui.ClangParseDialog;
+import ghidra.framework.Application;
+import ghidra.framework.options.SaveState;
+import ghidra.framework.plugintool.PluginInfo;
+import ghidra.framework.plugintool.PluginTool;
+import ghidra.framework.plugintool.util.PluginStatus;
+import ghidra.program.database.data.ProgramDataTypeManager;
+import ghidra.program.model.data.BuiltInDataTypeManager;
+import ghidra.program.model.data.DataType;
+import ghidra.program.model.data.DataTypeConflictHandler;
+import ghidra.program.model.data.DataTypeManager;
+import ghidra.program.model.lang.LanguageCompilerSpecPair;
+import ghidra.program.model.listing.Program;
+import ghidra.util.*;
+import ghidra.util.exception.CancelledException;
+import ghidra.util.task.TaskMonitor;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+@PluginInfo(
+        status = PluginStatus.STABLE,
+        packageName = CorePluginPackage.NAME,
+        category = PluginCategoryNames.ANALYSIS,
+        shortDescription = "Clang C/C++ Parser",
+        description = GCPPPlugin.DESCRIPTION,
+        servicesRequired = { DataTypeManagerService.class }
+)
+public class GCPPPlugin extends ProgramPlugin
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    static final String DESCRIPTION =
+        "Parse C and C++ header files using libclang, extracting data type definitions.";
+
+    private ClangParseDialog parseDialog;
+    private File userProfileDir;
+
+    public GCPPPlugin(PluginTool plugintool)
+    {
+        super(plugintool);
+        createActions();
+        userProfileDir = new File(
+            Application.getUserSettingsDirectory().getAbsolutePath() +
+            File.separatorChar + "parserprofiles");
+        userProfileDir.mkdir();
+    }
+
+    public File getUserProfileDir()
+    {
+        return userProfileDir;
+    }
+
+    public Program getProgram()
+    {
+        return currentProgram;
+    }
+
+    public ClangParseDialog getDialog()
+    {
+        return parseDialog;
+    }
+
+    @Override
+    public void dispose()
+    {
+        if (parseDialog != null)
+        {
+            parseDialog.close();
+            parseDialog = null;
+        }
+    }
+
+    @Override
+    public void readDataState(SaveState saveState)
+    {
+        parseDialog = new ClangParseDialog(this);
+        parseDialog.readState(saveState);
+    }
+
+    @Override
+    public void writeDataState(SaveState saveState)
+    {
+        if (parseDialog != null)
+            parseDialog.writeState(saveState);
+    }
+
+    @Override
+    protected boolean canClose()
+    {
+        if (parseDialog != null)
+            parseDialog.closeProfile();
+        return true;
+    }
+
+    private void createActions()
+    {
+        DockingAction parseAction = new DockingAction("Parse C/C++ Source (Clang Powered)", getName())
+        {
+            @Override
+            public void actionPerformed(ActionContext context)
+            {
+                showParseDialog();
+            }
+        };
+        String[] menuPath = { ToolConstants.MENU_FILE, "Parse C/C++ Source (Clang Powered)..." };
+        MenuData menuData = new MenuData(menuPath, "Import/Export");
+        menuData.setMenuSubGroup("d");
+        parseAction.setMenuBarData(menuData);
+        parseAction.setDescription(DESCRIPTION);
+        parseAction.setEnabled(true);
+        tool.addAction(parseAction);
+    }
+
+    private void showParseDialog()
+    {
+        if (parseDialog == null)
+            parseDialog = new ClangParseDialog(this);
+        parseDialog.setupForDisplay();
+        tool.showDialog(parseDialog);
+    }
+
+    /**
+     * Parse to the current program's DataTypeManager.
+     */
+    public void parse(String[] filenames, String[] includePaths, String options)
+    {
+        if (currentProgram == null)
+        {
+            Msg.showInfo(getClass(), parseDialog.getComponent(), "No Open Program",
+                "A program must be open to \"Parse to Program\"");
+            return;
+        }
+
+        LanguageCompilerSpecPair lcsPair = currentProgram.getLanguageCompilerSpecPair();
+        String procID = lcsPair.languageID.getIdAsString();
+        String compilerID = lcsPair.compilerSpecID.getIdAsString();
+
+        int confirm = OptionDialog.showOptionDialog(parseDialog.getComponent(), "Confirm",
+            "Parse C/C++ source to \"" + currentProgram.getDomainFile().getName() + "\"?" + "\n\n" +
+                "Using program architecture: " + procID + " / " + compilerID, "Continue");
+
+        if (confirm == OptionDialog.CANCEL_OPTION)
+            return;
+
+        DataTypeManager[] openDTMgrs;
+        try
+        {
+            openDTMgrs = getOpenDTMgrs();
+        }
+        catch (CancelledException e)
+        {
+            return;
+        }
+
+        ClangParseTask task = new ClangParseTask(this, currentProgram.getDataTypeManager())
+            .setFileNames(filenames)
+            .setIncludePaths(includePaths)
+            .setOptions(options)
+            .setOpenArchives(openDTMgrs);
+
+        tool.execute(task);
+    }
+
+    /**
+     * Parse to a file (creates a new .gdt archive).
+     */
+    public void parse(String[] filenames, String[] includePaths, String options,
+                      String languageIDString, String compilerSpecID, String dataFilename)
+    {
+        DataTypeManager[] openDTMgrs;
+        try
+        {
+            openDTMgrs = getOpenDTMgrs();
+        }
+        catch (CancelledException e)
+        {
+            return;
+        }
+
+        ClangParseTask task = new ClangParseTask(this, dataFilename)
+            .setFileNames(filenames)
+            .setIncludePaths(includePaths)
+            .setOptions(options)
+            .setLanguageID(languageIDString)
+            .setCompilerID(compilerSpecID)
+            .setOpenArchives(openDTMgrs);
+
+        tool.execute(task, 500);
+    }
+
+    /**
+     * Prompt the user whether to use currently open archives for type resolution.
+     * Matches the behavior of the built-in CParserPlugin.
+     *
+     * @return array of open DTMs to use, or null if user chose not to use them
+     * @throws CancelledException if user cancelled
+     */
+    private DataTypeManager[] getOpenDTMgrs() throws CancelledException
+    {
+        DataTypeManagerService dtService = tool.getService(DataTypeManagerService.class);
+        if (dtService == null)
+            return null;
+
+        DataTypeManager[] allDTMs = dtService.getDataTypeManagers();
+
+        ArrayList<DataTypeManager> list = new ArrayList<>();
+        StringBuilder htmlNamesList = new StringBuilder();
+        for (DataTypeManager dtm : allDTMs)
+        {
+            if (dtm instanceof ProgramDataTypeManager)
+                continue;
+            list.add(dtm);
+            if (!(dtm instanceof BuiltInDataTypeManager))
+                htmlNamesList.append("<li><b>").append(HTMLUtilities.escapeHTML(dtm.getName())).append("</b></li>");
+        }
+
+        DataTypeManager[] openDTMgrs = list.toArray(new DataTypeManager[0]);
+
+        if (openDTMgrs.length > 1)
+        {
+            int result = OptionDialog.showOptionDialog(
+                parseDialog.getComponent(), "Use Open Archives?",
+                "<html>The following archives are currently open: " +
+                    "<ul>" + htmlNamesList + "</ul>" +
+                    "<p><b>The new archive will become dependent on these archives<br>" +
+                    "for any datatypes already defined in them </b>(only unique <br>" +
+                    "data types will be added to the new archive).",
+                "Use Open Archives", "Don't Use Open Archives", OptionDialog.QUESTION_MESSAGE);
+
+            if (result == OptionDialog.CANCEL_OPTION)
+                throw new CancelledException("User Cancelled");
+            if (result == OptionDialog.OPTION_TWO)
+                return null;
+        }
+
+        return openDTMgrs;
+    }
+
+    /**
+     * Core parse method called by {@link ClangParseTask}.
+     * Parses source files via libclang, resolves types, and commits them to the DTM.
+     *
+     * @param filenames     source files to parse
+     * @param includePaths  include directories for header resolution
+     * @param options       parse options (one per line, e.g. -D flags)
+     * @param dtMgr         target DataTypeManager to commit types to
+     * @param languageId    Ghidra LanguageID string (e.g. "x86:LE:64:default")
+     * @param compilerSpec  Ghidra CompilerSpecID string (e.g. "gcc", "windows")
+     * @param openArchives  additional DTMs to use for type resolution (may be null)
+     * @param monitor       task monitor for progress reporting
+     * @return diagnostic messages from clang
+     * @throws ParseException if clang parsing fails
+     */
+    public String parseWithClang(String[] filenames, String[] includePaths, String options,
+                                 DataTypeManager dtMgr, String languageId, String compilerSpec,
+                                 DataTypeManager[] openArchives, TaskMonitor monitor)
+        throws ParseException
+    {
+        TypePool typePool = new TypePool(openArchives);
+        try
+        {
+            // Phase 1: Parse with clang
+            monitor.setMessage("Parsing " + filenames.length + " source file(s) with clang...");
+            SourceParser parser = new SourceParser();
+
+            List<String> diagnostics = parser.parseFiles(typePool, filenames, includePaths, options, languageId, compilerSpec);
+
+            // Phase 2: Resolve type dependencies
+            monitor.setMessage("Resolving type dependencies...");
+            TypePool.ResolutionResult result = typePool.resolve();
+
+            // Phase 3: Commit resolved types to the target DTM
+            List<DataType> dataTypes = result.getDataTypes();
+            monitor.setMessage("Committing " + dataTypes.size() + " data types...");
+            monitor.setMaximum(dataTypes.size());
+            monitor.setProgress(0);
+
+            int transaction = dtMgr.startTransaction("Add clang-parsed data types");
+            try
+            {
+                int count = 0;
+                for (DataType t : dataTypes)
+                {
+                    monitor.setProgress(++count);
+                    monitor.setMessage("Adding: " + t.getName());
+                    try
+                    {
+                        dtMgr.addDataType(t, DataTypeConflictHandler.REPLACE_HANDLER);
+                    }
+                    catch (Exception e)
+                    {
+                        LOGGER.warn("Failed to add type: " + t.getName(), e);
+                    }
+                }
+            }
+            finally
+            {
+                dtMgr.endTransaction(transaction, true);
+            }
+
+            // Build result message with diagnostics and any unresolved warnings
+            StringBuilder messages = new StringBuilder();
+            if (!diagnostics.isEmpty())
+                messages.append(String.join("\n", diagnostics));
+
+            var unresolved = result.getUnresolvedDependencies();
+            if (!unresolved.isEmpty())
+            {
+                LOGGER.warn("Unresolved type dependencies (skipped): " + unresolved);
+                if (!messages.isEmpty())
+                    messages.append("\n");
+                messages.append(unresolved.size()).append(" types skipped due to unresolved dependencies.");
+            }
+
+            return messages.toString();
+        }
+        finally
+        {
+            typePool.close();
+        }
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CallingConvention.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CallingConvention.java
new file mode 100644
index 0000000000..62099166a9
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CallingConvention.java
@@ -0,0 +1,53 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public enum CallingConvention {
+    DEFAULT(0, "__cdecl"),
+    C(1, "__cdecl"),
+    X86_STDCALL(2, "__stdcall"),
+    X86_FASTCALL(3, "__fastcall"),
+    X86_THISCALL(4, "__thiscall"),
+    X86_PASCAL(5, "__pascal"),
+    AAPCS(6, "__cdecl"),
+    AAPCS_VFP(7, "__cdecl"),
+    X86_REGCALL(8, "__regcall"),
+    INTEL_OCL_BICC(9, "__cdecl"),
+    WIN64(10, "__fastcall"),
+    X86_64_SYSV(11, "__cdecl"),
+    X86_VECTORCALL(12, "__vectorcall"),
+    SWIFT(13, "__cdecl"),
+    PRESERVE_MOST(14, "__cdecl"),
+    PRESERVE_ALL(15, "__cdecl"),
+    AARCH64_VECTORCALL(16, "__cdecl"),
+    SWIFT_ASYNC(17, "__cdecl"),
+    AARCH64_SVE_PCS(18, "__cdecl"),
+    INVALID(100, null),
+    UNEXPOSED(200, null);
+
+    private final int value;
+    private final String ghidraName;
+    private static final Map<Integer, CallingConvention> BY_VALUE = new HashMap<>();
+
+    static {
+        for (var v : values()) BY_VALUE.put(v.value, v);
+    }
+
+    CallingConvention(int value, String ghidraName) {
+        this.value = value;
+        this.ghidraName = ghidraName;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public String getGhidraName() {
+        return ghidraName;
+    }
+
+    public static CallingConvention fromInteger(int value) {
+        return BY_VALUE.get(value);
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Cursor.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Cursor.java
new file mode 100644
index 0000000000..64b5d9ede7
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Cursor.java
@@ -0,0 +1,346 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.List;
+
+/**
+ * A cursor representing some element in the abstract syntax tree for
+ * a translation unit.
+ * <p>
+ * The cursor abstraction unifies the different kinds of entities in a
+ * program (declarations, statements, expressions, references to declarations,
+ * etc.) under a single "cursor" abstraction with a common set of operations.
+ * <p>
+ * Wraps a {@code CXCursor} struct (passed by value as a MemorySegment).
+ */
+public final class Cursor {
+
+    private final MemorySegment segment;
+    private final Arena arena;
+
+    // Thread-locals for visitor callback bridge
+    private static final ThreadLocal<CursorVisitor> CURRENT_VISITOR = new ThreadLocal<>();
+    private static final ThreadLocal<Arena> CURRENT_ARENA = new ThreadLocal<>();
+
+    /**
+     * Creates a Cursor wrapping the given CXCursor segment.
+     *
+     * @param segment the CXCursor memory segment (must be CX_CURSOR.byteSize() bytes)
+     * @param arena   the arena used for allocating return-by-value structs
+     */
+    Cursor(MemorySegment segment, Arena arena) {
+        this.segment = segment;
+        this.arena = arena;
+    }
+
+    /**
+     * Returns the underlying CXCursor memory segment.
+     */
+    MemorySegment getSegment() {
+        return segment;
+    }
+
+    // ========================================================================
+    // Cursor properties
+    // ========================================================================
+
+    /**
+     * Return the kind of this cursor.
+     */
+    public CursorKind kind() {
+        int kindVal = LibClang.getCursorKind(segment);
+        return CursorKind.fromInteger(kindVal);
+    }
+
+    /**
+     * Return the spelling of the entity pointed at by the cursor.
+     */
+    public String spelling() {
+        MemorySegment cxStr = LibClang.getCursorSpelling(arena, segment);
+        return LibClang.extractString(arena, cxStr);
+    }
+
+    /**
+     * Return the display name for the entity referenced by this cursor.
+     * <p>
+     * The display name contains extra information that helps identify the
+     * cursor, such as the parameters of a function or template or the
+     * arguments of a class template specialization.
+     */
+    public String displayName() {
+        MemorySegment cxStr = LibClang.getCursorDisplayName(arena, segment);
+        return LibClang.extractString(arena, cxStr);
+    }
+
+    /**
+     * Retrieve the Type (if any) of the entity pointed at by the cursor.
+     */
+    public Type type() {
+        MemorySegment typeSeg = LibClang.getCursorType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * Return the underlying type of a typedef declaration.
+     */
+    public Type underlyingTypedefType() {
+        MemorySegment typeSeg = LibClang.getTypedefDeclUnderlyingType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * Return the integer type of an enum declaration.
+     */
+    public Type enumType() {
+        MemorySegment typeSeg = LibClang.getEnumDeclIntegerType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * Return the value of an enum constant.
+     * <p>
+     * Automatically selects signed or unsigned retrieval based on the
+     * underlying enum integer type.
+     */
+    public long enumValue() {
+        Type underlyingType = this.type();
+
+        // If the type is ENUM, get the enum's integer type
+        if (underlyingType.kind() == TypeKind.ENUM) {
+            underlyingType = underlyingType.declaration().enumType();
+        }
+
+        // Check if the underlying type is unsigned
+        List<TypeKind> unsignedKinds = List.of(
+            TypeKind.CHAR_U, TypeKind.U_CHAR, TypeKind.CHAR16, TypeKind.CHAR32,
+            TypeKind.U_SHORT, TypeKind.U_INT, TypeKind.U_LONG, TypeKind.U_LONG_LONG,
+            TypeKind.U_INT128
+        );
+
+        if (unsignedKinds.contains(underlyingType.kind())) {
+            return LibClang.getEnumConstantDeclUnsignedValue(segment);
+        } else {
+            return LibClang.getEnumConstantDeclValue(segment);
+        }
+    }
+
+    /**
+     * Return the source location of this cursor.
+     */
+    public SourceLocation location() {
+        MemorySegment locSeg = LibClang.getCursorLocation(arena, segment);
+        return new SourceLocation(locSeg, arena);
+    }
+
+    /**
+     * Return the semantic parent of this cursor.
+     */
+    public Cursor semanticParent() {
+        MemorySegment parentSeg = LibClang.getCursorSemanticParent(arena, segment);
+        return new Cursor(parentSeg, arena);
+    }
+
+    /**
+     * Returns whether this cursor represents a bit-field declaration.
+     */
+    public boolean isBitField() {
+        return LibClang.cursorIsBitField(segment) != 0;
+    }
+
+    /**
+     * Returns the bit width of a bit-field declaration.
+     */
+    public int getBitFieldWidth() {
+        return LibClang.getFieldDeclBitWidth(segment);
+    }
+
+    /**
+     * Returns the offset of a field in bits.
+     */
+    public long getFieldOffset() {
+        return LibClang.cursorGetOffsetOfField(segment);
+    }
+
+    /**
+     * Returns whether this cursor represents an anonymous declaration.
+     */
+    public boolean isAnonymous() {
+        return LibClang.cursorIsAnonymous(segment) != 0;
+    }
+
+    /**
+     * Returns whether this cursor represents an anonymous record declaration.
+     */
+    public boolean isAnonymousRecordDecl() {
+        return LibClang.cursorIsAnonymousRecordDecl(segment) != 0;
+    }
+
+    /**
+     * Returns whether this C++ method is declared virtual.
+     */
+    public boolean isVirtualMethod() {
+        return LibClang.cxxMethodIsVirtual(segment) != 0;
+    }
+
+    /**
+     * Returns whether this C++ method is declared pure virtual (= 0).
+     */
+    public boolean isPureVirtualMethod() {
+        return LibClang.cxxMethodIsPureVirtual(segment) != 0;
+    }
+
+    /**
+     * Returns whether this C++ method is declared static.
+     */
+    public boolean isStaticMethod() {
+        return LibClang.cxxMethodIsStatic(segment) != 0;
+    }
+
+    /**
+     * Returns whether this base specifier represents a virtual base class.
+     */
+    public boolean isVirtualBase() {
+        return LibClang.isVirtualBase(segment) != 0;
+    }
+
+    // ========================================================================
+    // Visitor pattern
+    // ========================================================================
+
+    /**
+     * Functional interface for visiting child cursors.
+     */
+    @FunctionalInterface
+    public interface CursorVisitor {
+        ChildVisitResult visit(Cursor cursor, Cursor parent);
+    }
+
+    /**
+     * Result codes for cursor visitor callbacks.
+     */
+    public enum ChildVisitResult {
+        /** Terminates the cursor traversal. */
+        BREAK(0),
+        /** Continues with the next sibling, without visiting children. */
+        CONTINUE(1),
+        /** Recursively traverse the children of this cursor. */
+        RECURSE(2);
+
+        final int value;
+
+        ChildVisitResult(int v) {
+            this.value = v;
+        }
+    }
+
+    /**
+     * Visit the children of this cursor, invoking the visitor for each child.
+     *
+     * @param visitor the visitor callback to invoke for each child
+     */
+    public void visitChildren(CursorVisitor visitor) {
+        try (Arena upcallArena = Arena.ofConfined()) {
+            MethodHandle callback;
+            try {
+                callback = MethodHandles.lookup().findStatic(
+                    Cursor.class,
+                    "visitChildrenCallback",
+                    MethodType.methodType(int.class,
+                        MemorySegment.class, MemorySegment.class, MemorySegment.class)
+                );
+            } catch (NoSuchMethodException | IllegalAccessException e) {
+                throw new RuntimeException("Failed to find visitChildrenCallback", e);
+            }
+
+            MemorySegment stub = LibClang.linker().upcallStub(
+                callback,
+                LibClang.VISITOR_DESC,
+                upcallArena
+            );
+
+            // Save previous values for re-entrant (nested) visitChildren calls.
+            // SourceParser nests visitors: outer callback -> parseStruct -> inner visitChildren.
+            // Without save/restore, the inner finally block would remove() the ThreadLocal
+            // values that the outer callback still needs, causing a null dereference.
+            CursorVisitor previousVisitor = CURRENT_VISITOR.get();
+            Arena previousArena = CURRENT_ARENA.get();
+            CURRENT_VISITOR.set(visitor);
+            CURRENT_ARENA.set(this.arena);
+            try {
+                LibClang.visitChildren(this.segment, stub, MemorySegment.NULL);
+            } finally {
+                // Restore previous values (not remove!) so outer callbacks keep working
+                if (previousVisitor != null) {
+                    CURRENT_VISITOR.set(previousVisitor);
+                } else {
+                    CURRENT_VISITOR.remove();
+                }
+                if (previousArena != null) {
+                    CURRENT_ARENA.set(previousArena);
+                } else {
+                    CURRENT_ARENA.remove();
+                }
+            }
+        }
+    }
+
+    /**
+     * Native upcall target for clang_visitChildren. Receives raw MemorySegments
+     * representing CXCursor structs passed by value from libclang.
+     * <p>
+     * CRITICAL: Catches ALL Throwable to prevent JVM termination from uncaught
+     * exceptions in upcall stubs.
+     */
+    @SuppressWarnings("unused") // Invoked via MethodHandles.lookup().findStatic() in visitChildren()
+    private static int visitChildrenCallback(MemorySegment cursorSeg,
+                                             MemorySegment parentSeg,
+                                             MemorySegment clientData) {
+        try {
+            Arena arena = CURRENT_ARENA.get();
+            CursorVisitor visitor = CURRENT_VISITOR.get();
+
+            // Copy callback-scoped segments into the TU's persistent arena.
+            // The segments provided by Panama for struct-by-value upcall parameters
+            // are only valid for the duration of this callback invocation.
+            MemorySegment cursorCopy = arena.allocate(LibClang.CX_CURSOR);
+            cursorCopy.copyFrom(cursorSeg.reinterpret(LibClang.CX_CURSOR.byteSize()));
+            MemorySegment parentCopy = arena.allocate(LibClang.CX_CURSOR);
+            parentCopy.copyFrom(parentSeg.reinterpret(LibClang.CX_CURSOR.byteSize()));
+
+            Cursor cursor = new Cursor(cursorCopy, arena);
+            Cursor parent = new Cursor(parentCopy, arena);
+            return visitor.visit(cursor, parent).value;
+        } catch (Throwable t) {
+            // MUST catch everything -- uncaught exceptions in upcalls terminate the JVM
+            t.printStackTrace();
+            return ChildVisitResult.BREAK.value;
+        }
+    }
+
+    // ========================================================================
+    // Object methods
+    // ========================================================================
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (!(obj instanceof Cursor other)) return false;
+        return LibClang.equalCursors(this.segment, other.segment) != 0;
+    }
+
+    @Override
+    public int hashCode() {
+        return LibClang.hashCursor(segment);
+    }
+
+    @Override
+    public String toString() {
+        CursorKind k = kind();
+        String s = spelling();
+        return "Cursor{kind=" + k + ", spelling='" + s + "'}";
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CursorKind.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CursorKind.java
new file mode 100644
index 0000000000..d9d49827d1
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/CursorKind.java
@@ -0,0 +1,313 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum CursorKind {
+    UNEXPOSED_DECL(1),
+    STRUCT_DECL(2),
+    UNION_DECL(3),
+    CLASS_DECL(4),
+    ENUM_DECL(5),
+    FIELD_DECL(6),
+    ENUM_CONSTANT_DECL(7),
+    FUNCTION_DECL(8),
+    VAR_DECL(9),
+    PARM_DECL(10),
+    OBJ_C_INTERFACE_DECL(11),
+    OBJ_C_CATEGORY_DECL(12),
+    OBJ_C_PROTOCOL_DECL(13),
+    OBJ_C_PROPERTY_DECL(14),
+    OBJ_C_IVAR_DECL(15),
+    OBJ_C_INSTANCE_METHOD_DECL(16),
+    OBJ_C_CLASS_METHOD_DECL(17),
+    OBJ_C_IMPLEMENTATION_DECL(18),
+    OBJ_C_CATEGORY_IMPL_DECL(19),
+    TYPEDEF_DECL(20),
+    C_X_X_METHOD(21),
+    NAMESPACE(22),
+    LINKAGE_SPEC(23),
+    CONSTRUCTOR(24),
+    DESTRUCTOR(25),
+    CONVERSION_FUNCTION(26),
+    TEMPLATE_TYPE_PARAMETER(27),
+    NON_TYPE_TEMPLATE_PARAMETER(28),
+    TEMPLATE_TEMPLATE_PARAMETER(29),
+    FUNCTION_TEMPLATE(30),
+    CLASS_TEMPLATE(31),
+    CLASS_TEMPLATE_PARTIAL_SPECIALIZATION(32),
+    NAMESPACE_ALIAS(33),
+    USING_DIRECTIVE(34),
+    USING_DECLARATION(35),
+    TYPE_ALIAS_DECL(36),
+    OBJ_C_SYNTHESIZE_DECL(37),
+    OBJ_C_DYNAMIC_DECL(38),
+    C_X_X_ACCESS_SPECIFIER(39),
+    FIRST_REF(40),
+    OBJ_C_SUPER_CLASS_REF(40),
+    OBJ_C_PROTOCOL_REF(41),
+    OBJ_C_CLASS_REF(42),
+    TYPE_REF(43),
+    C_X_X_BASE_SPECIFIER(44),
+    TEMPLATE_REF(45),
+    NAMESPACE_REF(46),
+    MEMBER_REF(47),
+    LABEL_REF(48),
+    OVERLOADED_DECL_REF(49),
+    VARIABLE_REF(50),
+    FIRST_INVALID(70),
+    INVALID_FILE(70),
+    NO_DECL_FOUND(71),
+    NOT_IMPLEMENTED(72),
+    INVALID_CODE(73),
+    FIRST_EXPR(100),
+    UNEXPOSED_EXPR(100),
+    DECL_REF_EXPR(101),
+    MEMBER_REF_EXPR(102),
+    CALL_EXPR(103),
+    OBJ_C_MESSAGE_EXPR(104),
+    BLOCK_EXPR(105),
+    INTEGER_LITERAL(106),
+    FLOATING_LITERAL(107),
+    IMAGINARY_LITERAL(108),
+    STRING_LITERAL(109),
+    CHARACTER_LITERAL(110),
+    PAREN_EXPR(111),
+    UNARY_OPERATOR(112),
+    ARRAY_SUBSCRIPT_EXPR(113),
+    BINARY_OPERATOR(114),
+    COMPOUND_ASSIGN_OPERATOR(115),
+    CONDITIONAL_OPERATOR(116),
+    C_STYLE_CAST_EXPR(117),
+    COMPOUND_LITERAL_EXPR(118),
+    INIT_LIST_EXPR(119),
+    ADDR_LABEL_EXPR(120),
+    STMT_EXPR(121),
+    GENERIC_SELECTION_EXPR(122),
+    G_N_U_NULL_EXPR(123),
+    C_X_X_STATIC_CAST_EXPR(124),
+    C_X_X_DYNAMIC_CAST_EXPR(125),
+    C_X_X_REINTERPRET_CAST_EXPR(126),
+    C_X_X_CONST_CAST_EXPR(127),
+    C_X_X_FUNCTIONAL_CAST_EXPR(128),
+    C_X_X_TYPEID_EXPR(129),
+    C_X_X_BOOL_LITERAL_EXPR(130),
+    C_X_X_NULL_PTR_LITERAL_EXPR(131),
+    C_X_X_THIS_EXPR(132),
+    C_X_X_THROW_EXPR(133),
+    C_X_X_NEW_EXPR(134),
+    C_X_X_DELETE_EXPR(135),
+    UNARY_EXPR(136),
+    OBJ_C_STRING_LITERAL(137),
+    OBJ_C_ENCODE_EXPR(138),
+    OBJ_C_SELECTOR_EXPR(139),
+    OBJ_C_PROTOCOL_EXPR(140),
+    OBJ_C_BRIDGED_CAST_EXPR(141),
+    PACK_EXPANSION_EXPR(142),
+    SIZE_OF_PACK_EXPR(143),
+    LAMBDA_EXPR(144),
+    OBJ_C_BOOL_LITERAL_EXPR(145),
+    OBJ_C_SELF_EXPR(146),
+    O_M_P_ARRAY_SECTION_EXPR(147),
+    OBJ_C_AVAILABILITY_CHECK_EXPR(148),
+    FIXED_POINT_LITERAL(149),
+    O_M_P_ARRAY_SHAPING_EXPR(150),
+    O_M_P_ITERATOR_EXPR(151),
+    C_X_X_ADDRSPACE_CAST_EXPR(152),
+    CONCEPT_SPECIALIZATION_EXPR(153),
+    REQUIRES_EXPR(154),
+    C_X_X_PAREN_LIST_INIT_EXPR(155),
+    FIRST_STMT(200),
+    UNEXPOSED_STMT(200),
+    LABEL_STMT(201),
+    COMPOUND_STMT(202),
+    CASE_STMT(203),
+    DEFAULT_STMT(204),
+    IF_STMT(205),
+    SWITCH_STMT(206),
+    WHILE_STMT(207),
+    DO_STMT(208),
+    FOR_STMT(209),
+    GOTO_STMT(210),
+    INDIRECT_GOTO_STMT(211),
+    CONTINUE_STMT(212),
+    BREAK_STMT(213),
+    RETURN_STMT(214),
+    G_C_C_ASM_STMT(215),
+    OBJ_C_AT_TRY_STMT(216),
+    OBJ_C_AT_CATCH_STMT(217),
+    OBJ_C_AT_FINALLY_STMT(218),
+    OBJ_C_AT_THROW_STMT(219),
+    OBJ_C_AT_SYNCHRONIZED_STMT(220),
+    OBJ_C_AUTORELEASE_POOL_STMT(221),
+    OBJ_C_FOR_COLLECTION_STMT(222),
+    C_X_X_CATCH_STMT(223),
+    C_X_X_TRY_STMT(224),
+    C_X_X_FOR_RANGE_STMT(225),
+    S_E_H_TRY_STMT(226),
+    S_E_H_EXCEPT_STMT(227),
+    S_E_H_FINALLY_STMT(228),
+    M_S_ASM_STMT(229),
+    NULL_STMT(230),
+    DECL_STMT(231),
+    O_M_P_PARALLEL_DIRECTIVE(232),
+    O_M_P_SIMD_DIRECTIVE(233),
+    O_M_P_FOR_DIRECTIVE(234),
+    O_M_P_SECTIONS_DIRECTIVE(235),
+    O_M_P_SECTION_DIRECTIVE(236),
+    O_M_P_SINGLE_DIRECTIVE(237),
+    O_M_P_PARALLEL_FOR_DIRECTIVE(238),
+    O_M_P_PARALLEL_SECTIONS_DIRECTIVE(239),
+    O_M_P_TASK_DIRECTIVE(240),
+    O_M_P_MASTER_DIRECTIVE(241),
+    O_M_P_CRITICAL_DIRECTIVE(242),
+    O_M_P_TASKYIELD_DIRECTIVE(243),
+    O_M_P_BARRIER_DIRECTIVE(244),
+    O_M_P_TASKWAIT_DIRECTIVE(245),
+    O_M_P_FLUSH_DIRECTIVE(246),
+    S_E_H_LEAVE_STMT(247),
+    O_M_P_ORDERED_DIRECTIVE(248),
+    O_M_P_ATOMIC_DIRECTIVE(249),
+    O_M_P_FOR_SIMD_DIRECTIVE(250),
+    O_M_P_PARALLEL_FOR_SIMD_DIRECTIVE(251),
+    O_M_P_TARGET_DIRECTIVE(252),
+    O_M_P_TEAMS_DIRECTIVE(253),
+    O_M_P_TASKGROUP_DIRECTIVE(254),
+    O_M_P_CANCELLATION_POINT_DIRECTIVE(255),
+    O_M_P_CANCEL_DIRECTIVE(256),
+    O_M_P_TARGET_DATA_DIRECTIVE(257),
+    O_M_P_TASK_LOOP_DIRECTIVE(258),
+    O_M_P_TASK_LOOP_SIMD_DIRECTIVE(259),
+    O_M_P_DISTRIBUTE_DIRECTIVE(260),
+    O_M_P_TARGET_ENTER_DATA_DIRECTIVE(261),
+    O_M_P_TARGET_EXIT_DATA_DIRECTIVE(262),
+    O_M_P_TARGET_PARALLEL_DIRECTIVE(263),
+    O_M_P_TARGET_PARALLEL_FOR_DIRECTIVE(264),
+    O_M_P_TARGET_UPDATE_DIRECTIVE(265),
+    O_M_P_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE(266),
+    O_M_P_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE(267),
+    O_M_P_DISTRIBUTE_SIMD_DIRECTIVE(268),
+    O_M_P_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE(269),
+    O_M_P_TARGET_SIMD_DIRECTIVE(270),
+    O_M_P_TEAMS_DISTRIBUTE_DIRECTIVE(271),
+    O_M_P_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE(272),
+    O_M_P_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE(273),
+    O_M_P_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE(274),
+    O_M_P_TARGET_TEAMS_DIRECTIVE(275),
+    O_M_P_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE(276),
+    O_M_P_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE(277),
+    O_M_P_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE(278),
+    O_M_P_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE(279),
+    BUILTIN_BIT_CAST_EXPR(280),
+    O_M_P_MASTER_TASK_LOOP_DIRECTIVE(281),
+    O_M_P_PARALLEL_MASTER_TASK_LOOP_DIRECTIVE(282),
+    O_M_P_MASTER_TASK_LOOP_SIMD_DIRECTIVE(283),
+    O_M_P_PARALLEL_MASTER_TASK_LOOP_SIMD_DIRECTIVE(284),
+    O_M_P_PARALLEL_MASTER_DIRECTIVE(285),
+    O_M_P_DEPOBJ_DIRECTIVE(286),
+    O_M_P_SCAN_DIRECTIVE(287),
+    O_M_P_TILE_DIRECTIVE(288),
+    O_M_P_CANONICAL_LOOP(289),
+    O_M_P_INTEROP_DIRECTIVE(290),
+    O_M_P_DISPATCH_DIRECTIVE(291),
+    O_M_P_MASKED_DIRECTIVE(292),
+    O_M_P_UNROLL_DIRECTIVE(293),
+    O_M_P_META_DIRECTIVE(294),
+    O_M_P_GENERIC_LOOP_DIRECTIVE(295),
+    O_M_P_TEAMS_GENERIC_LOOP_DIRECTIVE(296),
+    O_M_P_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE(297),
+    O_M_P_PARALLEL_GENERIC_LOOP_DIRECTIVE(298),
+    O_M_P_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE(299),
+    O_M_P_PARALLEL_MASKED_DIRECTIVE(300),
+    O_M_P_MASKED_TASK_LOOP_DIRECTIVE(301),
+    O_M_P_MASKED_TASK_LOOP_SIMD_DIRECTIVE(302),
+    O_M_P_PARALLEL_MASKED_TASK_LOOP_DIRECTIVE(303),
+    O_M_P_PARALLEL_MASKED_TASK_LOOP_SIMD_DIRECTIVE(304),
+    O_M_P_ERROR_DIRECTIVE(305),
+    TRANSLATION_UNIT(350),
+    FIRST_ATTR(400),
+    UNEXPOSED_ATTR(400),
+    I_B_ACTION_ATTR(401),
+    I_B_OUTLET_ATTR(402),
+    I_B_OUTLET_COLLECTION_ATTR(403),
+    C_X_X_FINAL_ATTR(404),
+    C_X_X_OVERRIDE_ATTR(405),
+    ANNOTATE_ATTR(406),
+    ASM_LABEL_ATTR(407),
+    PACKED_ATTR(408),
+    PURE_ATTR(409),
+    CONST_ATTR(410),
+    NO_DUPLICATE_ATTR(411),
+    C_U_D_A_CONSTANT_ATTR(412),
+    C_U_D_A_DEVICE_ATTR(413),
+    C_U_D_A_GLOBAL_ATTR(414),
+    C_U_D_A_HOST_ATTR(415),
+    C_U_D_A_SHARED_ATTR(416),
+    VISIBILITY_ATTR(417),
+    D_L_L_EXPORT(418),
+    D_L_L_IMPORT(419),
+    N_S_RETURNS_RETAINED(420),
+    N_S_RETURNS_NOT_RETAINED(421),
+    N_S_RETURNS_AUTORELEASED(422),
+    N_S_CONSUMES_SELF(423),
+    N_S_CONSUMED(424),
+    OBJ_C_EXCEPTION(425),
+    OBJ_C_N_S_OBJECT(426),
+    OBJ_C_INDEPENDENT_CLASS(427),
+    OBJ_C_PRECISE_LIFETIME(428),
+    OBJ_C_RETURNS_INNER_POINTER(429),
+    OBJ_C_REQUIRES_SUPER(430),
+    OBJ_C_ROOT_CLASS(431),
+    OBJ_C_SUBCLASSING_RESTRICTED(432),
+    OBJ_C_EXPLICIT_PROTOCOL_IMPL(433),
+    OBJ_C_DESIGNATED_INITIALIZER(434),
+    OBJ_C_RUNTIME_VISIBLE(435),
+    OBJ_C_BOXABLE(436),
+    FLAG_ENUM(437),
+    CONVERGENT_ATTR(438),
+    WARN_UNUSED_ATTR(439),
+    WARN_UNUSED_RESULT_ATTR(440),
+    ALIGNED_ATTR(441),
+    PREPROCESSING_DIRECTIVE(500),
+    MACRO_DEFINITION(501),
+    MACRO_EXPANSION(502),
+    INCLUSION_DIRECTIVE(503),
+    MODULE_IMPORT_DECL(600),
+    TYPE_ALIAS_TEMPLATE_DECL(601),
+    STATIC_ASSERT(602),
+    FRIEND_DECL(603),
+    CONCEPT_DECL(604),
+    OVERLOAD_CANDIDATE(700);
+
+    private static final Map<Integer, CursorKind> BY_VALUE = new HashMap<>();
+
+    private final int value;
+
+    CursorKind(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return this.value;
+    }
+
+    /**
+     * Determine whether the given cursor kind represents a declaration.
+     * Pure Java check on the value range (CXCursor_FirstDecl..CXCursor_LastDecl = 1..39).
+     */
+    public boolean isDeclaration() {
+        return this.value >= 1 && this.value <= 39;
+    }
+
+    /**
+     * Returns the CursorKind for the given integer value, or {@code null} if unknown.
+     */
+    public static CursorKind fromInteger(int value) {
+        return BY_VALUE.get(value);
+    }
+
+    static {
+        EnumSet.allOf(CursorKind.class).forEach(e -> BY_VALUE.put(e.value, e));
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Diagnostic.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Diagnostic.java
new file mode 100644
index 0000000000..c8b62de7d2
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Diagnostic.java
@@ -0,0 +1,71 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+
+/**
+ * A Diagnostic is a single instance of a Clang diagnostic. It includes the
+ * diagnostic severity, the message, the location the diagnostic occurred, as
+ * well as additional source ranges and associated fix-it hints.
+ * <p>
+ * Wraps an opaque {@code CXDiagnostic} pointer.
+ */
+public final class Diagnostic implements AutoCloseable {
+
+    /** CXDiagnosticSeverity constants */
+    public static final int SEVERITY_IGNORED = 0;
+    public static final int SEVERITY_NOTE = 1;
+    public static final int SEVERITY_WARNING = 2;
+    public static final int SEVERITY_ERROR = 3;
+    public static final int SEVERITY_FATAL = 4;
+
+    private MemorySegment pointer;
+    private final Arena arena;
+
+    Diagnostic(MemorySegment pointer, Arena arena) {
+        this.pointer = pointer;
+        this.arena = arena;
+    }
+
+    /**
+     * Returns the severity of this diagnostic.
+     *
+     * @return one of the SEVERITY_* constants
+     */
+    public int severity() {
+        return LibClang.getDiagnosticSeverity(pointer);
+    }
+
+    /**
+     * Format this diagnostic into a human-readable string using the given options.
+     *
+     * @param options diagnostic display option flags
+     * @return the formatted diagnostic string
+     */
+    public String format(int options) {
+        MemorySegment cxStr = LibClang.formatDiagnostic(arena, pointer, options);
+        return LibClang.extractString(arena, cxStr);
+    }
+
+    /**
+     * Format this diagnostic into a human-readable string using default display options.
+     *
+     * @return the formatted diagnostic string
+     */
+    public String format() {
+        return format(LibClang.defaultDiagnosticDisplayOptions());
+    }
+
+    @Override
+    public void close() {
+        if (pointer != null && !pointer.equals(MemorySegment.NULL)) {
+            LibClang.disposeDiagnostic(pointer);
+            pointer = null;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return format();
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Index.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Index.java
new file mode 100644
index 0000000000..e66c636476
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Index.java
@@ -0,0 +1,49 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.lang.foreign.MemorySegment;
+
+/**
+ * The Index type provides the primary interface to the Clang CIndex library,
+ * primarily by providing an interface for reading and parsing translation units.
+ * <p>
+ * Wraps an opaque {@code CXIndex} pointer. Implements {@link AutoCloseable}
+ * for deterministic resource cleanup.
+ */
+public final class Index implements AutoCloseable {
+    private MemorySegment pointer;
+
+    private Index(MemorySegment pointer) {
+        this.pointer = pointer;
+    }
+
+    /**
+     * Create a new Index.
+     *
+     * @param excludeDeclarationsFromPCH exclude local declarations from translation units
+     * @return the newly created index
+     */
+    public static Index create(boolean excludeDeclarationsFromPCH) {
+        return new Index(LibClang.createIndex(excludeDeclarationsFromPCH ? 1 : 0, 0));
+    }
+
+    /**
+     * Create a new Index with default options.
+     *
+     * @return the newly created index
+     */
+    public static Index create() {
+        return create(false);
+    }
+
+    MemorySegment getPointer() {
+        return pointer;
+    }
+
+    @Override
+    public void close() {
+        if (pointer != null && !pointer.equals(MemorySegment.NULL)) {
+            LibClang.disposeIndex(pointer);
+            pointer = null;
+        }
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/JavaVersionHelper.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/JavaVersionHelper.java
new file mode 100644
index 0000000000..ade944758a
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/JavaVersionHelper.java
@@ -0,0 +1,47 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.reflect.Method;
+import java.nio.charset.StandardCharsets;
+
+public class JavaVersionHelper {
+    public static final int JavaVersion = detectMajorVersion();
+
+    private static int detectMajorVersion() {
+        String version = System.getProperty("java.version");
+        if (version.startsWith("1.")) {
+            String[] parts = version.split("\\.");
+            return Integer.parseInt(parts[1]);
+        } else {
+            String[] parts = version.split("\\.");
+            return Integer.parseInt(parts[0]);
+        }
+    }
+
+    public static String getUtf8Safe(MemorySegment cStr) {
+        try {
+            if (JavaVersion > 21) {
+                return cStr.reinterpret(Long.MAX_VALUE).getString(0, StandardCharsets.UTF_8);
+            } else {
+                Method m = MemorySegment.class.getMethod("getUtf8String", long.class);
+                return (String) m.invoke(cStr.reinterpret(Long.MAX_VALUE), 0L);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static MemorySegment allocateUtf8Safe(Arena arena, String input) {
+        try {
+            if (JavaVersion > 21) {
+                return arena.allocateFrom(input, StandardCharsets.UTF_8);
+            } else {
+             Method m = Arena.class.getMethod("allocateUtf8String", long.class);
+	     return (MemorySegment) m.invoke(input);
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/LibClang.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/LibClang.java
new file mode 100644
index 0000000000..5fa5bf116d
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/LibClang.java
@@ -0,0 +1,955 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.io.File;
+import java.lang.foreign.*;
+import java.lang.invoke.MethodHandle;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+import ghidra.app.util.gcpp.clang.JavaVersionHelper;
+import ghidra.framework.Application;
+import ghidra.framework.Platform;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * Static utility class providing all native interactions with libclang via Panama FFI.
+ * All downcall handles and struct layouts are defined here.
+ */
+public final class LibClang extends JavaVersionHelper {
+    private LibClang() {}
+
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    // ========================================================================
+    // Struct Layouts
+    // ========================================================================
+
+    /** CXString: { void *data; unsigned private_flags; } = 16 bytes */
+    static final StructLayout CX_STRING = MemoryLayout.structLayout(
+        ValueLayout.ADDRESS.withName("data"),
+        ValueLayout.JAVA_INT.withName("private_flags"),
+        MemoryLayout.paddingLayout(4)
+    );
+
+    /** CXType: { enum CXTypeKind kind; void *data[2]; } = 24 bytes */
+    static final StructLayout CX_TYPE = MemoryLayout.structLayout(
+        ValueLayout.JAVA_INT.withName("kind"),
+        MemoryLayout.paddingLayout(4),
+        MemoryLayout.sequenceLayout(2, ValueLayout.ADDRESS).withName("data")
+    );
+
+    /** CXCursor: { enum CXCursorKind kind; int xdata; const void *data[3]; } = 32 bytes */
+    static final StructLayout CX_CURSOR = MemoryLayout.structLayout(
+        ValueLayout.JAVA_INT.withName("kind"),
+        ValueLayout.JAVA_INT.withName("xdata"),
+        MemoryLayout.sequenceLayout(3, ValueLayout.ADDRESS).withName("data")
+    );
+
+    /** CXSourceLocation: { const void *ptr_data[2]; unsigned int_data; } = 24 bytes */
+    static final StructLayout CX_SOURCE_LOCATION = MemoryLayout.structLayout(
+        MemoryLayout.sequenceLayout(2, ValueLayout.ADDRESS).withName("ptr_data"),
+        ValueLayout.JAVA_INT.withName("int_data"),
+        MemoryLayout.paddingLayout(4)
+    );
+
+    /** CXUnsavedFile: { const char *Filename; const char *Contents; unsigned long Length; } = 24 bytes */
+    static final StructLayout CX_UNSAVED_FILE = MemoryLayout.structLayout(
+        ValueLayout.ADDRESS.withName("Filename"),
+        ValueLayout.ADDRESS.withName("Contents"),
+        ValueLayout.JAVA_LONG.withName("Length")
+    );
+
+    /** Upcall descriptor for CXCursorVisitor callback */
+    static final FunctionDescriptor VISITOR_DESC = FunctionDescriptor.of(
+        ValueLayout.JAVA_INT,  // return: CXChildVisitResult (enum int)
+        CX_CURSOR,             // cursor (by value)
+        CX_CURSOR,             // parent (by value)
+        ValueLayout.ADDRESS    // client_data
+    );
+
+    // ========================================================================
+    // Library Loading
+    // ========================================================================
+
+    private static final Linker LINKER = Linker.nativeLinker();
+    private static final SymbolLookup LOOKUP;
+
+    static {
+        LOOKUP = loadLibClang();
+    }
+
+    private static SymbolLookup loadLibClang() {
+        // Try bundled library first (in extension's os/<platform>/ directory)
+        try {
+            File osFile = Application.getOSFile(
+                "libclang" + Platform.CURRENT_PLATFORM.getLibraryExtension());
+            LOGGER.debug("Trying bundled libclang: {}", osFile.getAbsolutePath());
+            SymbolLookup lookup = SymbolLookup.libraryLookup(osFile.toPath(), Arena.global());
+            LOGGER.info("Loaded bundled libclang from {}", osFile.getAbsolutePath());
+            return lookup;
+        } catch (Exception e) {
+            LOGGER.debug("Bundled libclang not available: {}", e.getMessage());
+        }
+
+        // Fall back to system-installed libclang
+        String osName = System.getProperty("os.name", "").toLowerCase();
+        LOGGER.debug("Searching for system-installed libclang (os.name={})", osName);
+
+        if (osName.contains("win")) {
+            return loadWindowsLibClang();
+        } else if (osName.contains("mac")) {
+            return loadMacLibClang();
+        } else {
+            return loadLinuxLibClang();
+        }
+    }
+
+    private static SymbolLookup loadWindowsLibClang() {
+        // Try standard library name on PATH
+        String[] names = { "libclang", "libclang.dll" };
+        for (String name : names) {
+            try {
+                LOGGER.debug("Trying Windows libclang: {}", name);
+                SymbolLookup lookup = SymbolLookup.libraryLookup(name, Arena.global());
+                LOGGER.info("Loaded libclang from system PATH: {}", name);
+                return lookup;
+            } catch (IllegalArgumentException | UnsatisfiedLinkError e) {
+                LOGGER.debug("Failed to load {}: {}", name, e.getMessage());
+            }
+        }
+        throw new RuntimeException(
+            "Could not load libclang on Windows. Ensure libclang.dll is on the system PATH.");
+    }
+
+    private static SymbolLookup loadMacLibClang() {
+        // Try Xcode path first
+        String xcodeClang = "/Applications/Xcode.app/Contents/Developer/Toolchains/" +
+            "XcodeDefault.xctoolchain/usr/lib/libclang.dylib";
+        try {
+            LOGGER.debug("Trying Xcode libclang: {}", xcodeClang);
+            SymbolLookup lookup = SymbolLookup.libraryLookup(xcodeClang, Arena.global());
+            LOGGER.info("Loaded libclang from Xcode: {}", xcodeClang);
+            return lookup;
+        } catch (IllegalArgumentException | UnsatisfiedLinkError e) {
+            LOGGER.debug("Xcode libclang not available: {}", e.getMessage());
+        }
+
+        // Try Homebrew LLVM
+        String[] brewPaths = {
+            "/opt/homebrew/opt/llvm/lib/libclang.dylib",
+            "/usr/local/opt/llvm/lib/libclang.dylib"
+        };
+        for (String path : brewPaths) {
+            try {
+                LOGGER.debug("Trying Homebrew libclang: {}", path);
+                SymbolLookup lookup = SymbolLookup.libraryLookup(path, Arena.global());
+                LOGGER.info("Loaded libclang from Homebrew: {}", path);
+                return lookup;
+            } catch (IllegalArgumentException | UnsatisfiedLinkError e) {
+                LOGGER.debug("Failed to load {}: {}", path, e.getMessage());
+            }
+        }
+
+        // Try system library name
+        try {
+            LOGGER.debug("Trying system libclang.dylib");
+            SymbolLookup lookup = SymbolLookup.libraryLookup("libclang.dylib", Arena.global());
+            LOGGER.info("Loaded system libclang.dylib");
+            return lookup;
+        } catch (IllegalArgumentException | UnsatisfiedLinkError e) {
+            LOGGER.debug("System libclang.dylib not available: {}", e.getMessage());
+        }
+
+        throw new RuntimeException(
+            "Could not load libclang on macOS. Install Xcode or LLVM (e.g. via Homebrew).");
+    }
+
+    private static SymbolLookup loadLinuxLibClang() {
+        // Try common versioned names first
+        String[] names = {
+            "libclang.so",
+            "libclang-18.so", "libclang-17.so", "libclang-16.so",
+            "libclang-15.so", "libclang-14.so"
+        };
+        for (String name : names) {
+            try {
+                LOGGER.debug("Trying Linux libclang: {}", name);
+                SymbolLookup lookup = SymbolLookup.libraryLookup(name, Arena.global());
+                LOGGER.info("Loaded libclang: {}", name);
+                return lookup;
+            } catch (IllegalArgumentException | UnsatisfiedLinkError e) {
+                LOGGER.debug("Failed to load {}: {}", name, e.getMessage());
+            }
+        }
+
+        // Search /usr/lib/llvm-*/lib/ directories
+        List<Path> candidates = new ArrayList<>();
+        try {
+            Path usrLib = Path.of("/usr/lib");
+            if (Files.isDirectory(usrLib)) {
+                try (DirectoryStream<Path> stream = Files.newDirectoryStream(usrLib, "llvm-*")) {
+                    for (Path llvmDir : stream) {
+                        Path libDir = llvmDir.resolve("lib");
+                        if (Files.isDirectory(libDir)) {
+                            try (DirectoryStream<Path> libs = Files.newDirectoryStream(libDir, "libclang.so*")) {
+                                for (Path lib : libs) {
+                                    candidates.add(lib);
+                                }
+                            }
+                            // Also check for libclang-*.so
+                            try (DirectoryStream<Path> libs = Files.newDirectoryStream(libDir, "libclang-*.so*")) {
+                                for (Path lib : libs) {
+                                    candidates.add(lib);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            LOGGER.debug("Error scanning /usr/lib/llvm-*/lib/: {}", e.getMessage());
+        }
+
+        // Also search /usr/lib64 and /usr/lib/x86_64-linux-gnu
+        String[] extraDirs = { "/usr/lib64", "/usr/lib/x86_64-linux-gnu" };
+        for (String dir : extraDirs) {
+            try {
+                Path dirPath = Path.of(dir);
+                if (Files.isDirectory(dirPath)) {
+                    try (DirectoryStream<Path> libs = Files.newDirectoryStream(dirPath, "libclang.so*")) {
+                        for (Path lib : libs) {
+                            candidates.add(lib);
+                        }
+                    }
+                    try (DirectoryStream<Path> libs = Files.newDirectoryStream(dirPath, "libclang-*.so*")) {
+                        for (Path lib : libs) {
+                            candidates.add(lib);
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                LOGGER.debug("Error scanning {}: {}", dir, e.getMessage());
+            }
+        }
+
+        // Sort by name descending to prefer higher versions
+        candidates.sort(Comparator.comparing(Path::toString).reversed());
+        LOGGER.debug("Found {} libclang candidates on Linux: {}", candidates.size(), candidates);
+
+        for (Path candidate : candidates) {
+            try {
+                LOGGER.debug("Trying candidate: {}", candidate);
+                SymbolLookup lookup = SymbolLookup.libraryLookup(candidate, Arena.global());
+                LOGGER.info("Loaded libclang from {}", candidate);
+                return lookup;
+            } catch (IllegalArgumentException | UnsatisfiedLinkError e) {
+                LOGGER.debug("Failed to load {}: {}", candidate, e.getMessage());
+            }
+        }
+
+        throw new RuntimeException(
+            "Could not load libclang on Linux. Install libclang (e.g. 'apt install libclang-dev' " +
+            "or 'dnf install clang-libs').");
+    }
+
+    // ========================================================================
+    // Downcall MethodHandles
+    // ========================================================================
+
+    private static MethodHandle downcall(String name, FunctionDescriptor desc) {
+        return LINKER.downcallHandle(
+            LOOKUP.find(name).orElseThrow(() ->
+                new RuntimeException("Symbol not found in libclang: " + name)),
+            desc
+        );
+    }
+
+    // --- Core lifecycle ---
+
+    private static final MethodHandle CLANG_CREATE_INDEX = downcall("clang_createIndex",
+        FunctionDescriptor.of(ValueLayout.ADDRESS, ValueLayout.JAVA_INT, ValueLayout.JAVA_INT));
+
+    private static final MethodHandle CLANG_DISPOSE_INDEX = downcall("clang_disposeIndex",
+        FunctionDescriptor.ofVoid(ValueLayout.ADDRESS));
+
+    private static final MethodHandle CLANG_PARSE_TRANSLATION_UNIT_2 = downcall("clang_parseTranslationUnit2",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT,
+            ValueLayout.ADDRESS,  // CXIndex
+            ValueLayout.ADDRESS,  // source_filename
+            ValueLayout.ADDRESS,  // command_line_args
+            ValueLayout.JAVA_INT, // num_command_line_args
+            ValueLayout.ADDRESS,  // unsaved_files
+            ValueLayout.JAVA_INT, // num_unsaved_files
+            ValueLayout.JAVA_INT, // options
+            ValueLayout.ADDRESS   // out_TU (CXTranslationUnit*)
+        ));
+
+    private static final MethodHandle CLANG_DISPOSE_TRANSLATION_UNIT = downcall("clang_disposeTranslationUnit",
+        FunctionDescriptor.ofVoid(ValueLayout.ADDRESS));
+
+    // --- String handling ---
+
+    private static final MethodHandle CLANG_GET_C_STRING = downcall("clang_getCString",
+        FunctionDescriptor.of(ValueLayout.ADDRESS, CX_STRING));
+
+    private static final MethodHandle CLANG_DISPOSE_STRING = downcall("clang_disposeString",
+        FunctionDescriptor.ofVoid(CX_STRING));
+
+    // --- Cursor operations ---
+
+    private static final MethodHandle CLANG_GET_TRANSLATION_UNIT_CURSOR = downcall("clang_getTranslationUnitCursor",
+        FunctionDescriptor.of(CX_CURSOR, ValueLayout.ADDRESS));
+
+    private static final MethodHandle CLANG_GET_CURSOR_KIND = downcall("clang_getCursorKind",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_CURSOR_SPELLING = downcall("clang_getCursorSpelling",
+        FunctionDescriptor.of(CX_STRING, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_CURSOR_DISPLAY_NAME = downcall("clang_getCursorDisplayName",
+        FunctionDescriptor.of(CX_STRING, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_CURSOR_TYPE = downcall("clang_getCursorType",
+        FunctionDescriptor.of(CX_TYPE, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_TYPEDEF_DECL_UNDERLYING_TYPE = downcall("clang_getTypedefDeclUnderlyingType",
+        FunctionDescriptor.of(CX_TYPE, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_ENUM_DECL_INTEGER_TYPE = downcall("clang_getEnumDeclIntegerType",
+        FunctionDescriptor.of(CX_TYPE, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_ENUM_CONSTANT_DECL_VALUE = downcall("clang_getEnumConstantDeclValue",
+        FunctionDescriptor.of(ValueLayout.JAVA_LONG, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_ENUM_CONSTANT_DECL_UNSIGNED_VALUE = downcall("clang_getEnumConstantDeclUnsignedValue",
+        FunctionDescriptor.of(ValueLayout.JAVA_LONG, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_CURSOR_LOCATION = downcall("clang_getCursorLocation",
+        FunctionDescriptor.of(CX_SOURCE_LOCATION, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_CURSOR_SEMANTIC_PARENT = downcall("clang_getCursorSemanticParent",
+        FunctionDescriptor.of(CX_CURSOR, CX_CURSOR));
+
+    private static final MethodHandle CLANG_VISIT_CHILDREN = downcall("clang_visitChildren",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR, ValueLayout.ADDRESS, ValueLayout.ADDRESS));
+
+    private static final MethodHandle CLANG_EQUAL_CURSORS = downcall("clang_equalCursors",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR, CX_CURSOR));
+
+    private static final MethodHandle CLANG_HASH_CURSOR = downcall("clang_hashCursor",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_CURSOR_IS_BIT_FIELD = downcall("clang_Cursor_isBitField",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_GET_FIELD_DECL_BIT_WIDTH = downcall("clang_getFieldDeclBitWidth",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_CURSOR_GET_OFFSET_OF_FIELD = downcall("clang_Cursor_getOffsetOfField",
+        FunctionDescriptor.of(ValueLayout.JAVA_LONG, CX_CURSOR));
+
+    private static final MethodHandle CLANG_CURSOR_IS_ANONYMOUS = downcall("clang_Cursor_isAnonymous",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_CURSOR_IS_ANONYMOUS_RECORD_DECL = downcall("clang_Cursor_isAnonymousRecordDecl",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_IS_DECLARATION = downcall("clang_isDeclaration",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.JAVA_INT));
+
+    private static final MethodHandle CLANG_CXX_METHOD_IS_VIRTUAL = downcall("clang_CXXMethod_isVirtual",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_CXX_METHOD_IS_PURE_VIRTUAL = downcall("clang_CXXMethod_isPureVirtual",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_CXX_METHOD_IS_STATIC = downcall("clang_CXXMethod_isStatic",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    private static final MethodHandle CLANG_IS_VIRTUAL_BASE = downcall("clang_isVirtualBase",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_CURSOR));
+
+    // --- Type operations ---
+
+    private static final MethodHandle CLANG_GET_TYPE_SPELLING = downcall("clang_getTypeSpelling",
+        FunctionDescriptor.of(CX_STRING, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_TYPE_DECLARATION = downcall("clang_getTypeDeclaration",
+        FunctionDescriptor.of(CX_CURSOR, CX_TYPE));
+
+    private static final MethodHandle CLANG_TYPE_GET_SIZE_OF = downcall("clang_Type_getSizeOf",
+        FunctionDescriptor.of(ValueLayout.JAVA_LONG, CX_TYPE));
+
+    private static final MethodHandle CLANG_TYPE_GET_ALIGN_OF = downcall("clang_Type_getAlignOf",
+        FunctionDescriptor.of(ValueLayout.JAVA_LONG, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_CANONICAL_TYPE = downcall("clang_getCanonicalType",
+        FunctionDescriptor.of(CX_TYPE, CX_TYPE));
+
+    private static final MethodHandle CLANG_TYPE_GET_NAMED_TYPE = downcall("clang_Type_getNamedType",
+        FunctionDescriptor.of(CX_TYPE, CX_TYPE));
+
+    private static final MethodHandle CLANG_TYPE_GET_MODIFIED_TYPE = downcall("clang_Type_getModifiedType",
+        FunctionDescriptor.of(CX_TYPE, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_POINTEE_TYPE = downcall("clang_getPointeeType",
+        FunctionDescriptor.of(CX_TYPE, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_ARRAY_ELEMENT_TYPE = downcall("clang_getArrayElementType",
+        FunctionDescriptor.of(CX_TYPE, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_ARRAY_SIZE = downcall("clang_getArraySize",
+        FunctionDescriptor.of(ValueLayout.JAVA_LONG, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_RESULT_TYPE = downcall("clang_getResultType",
+        FunctionDescriptor.of(CX_TYPE, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_NUM_ARG_TYPES = downcall("clang_getNumArgTypes",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_ARG_TYPE = downcall("clang_getArgType",
+        FunctionDescriptor.of(CX_TYPE, CX_TYPE, ValueLayout.JAVA_INT));
+
+    private static final MethodHandle CLANG_IS_FUNCTION_TYPE_VARIADIC = downcall("clang_isFunctionTypeVariadic",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_FUNCTION_TYPE_CALLING_CONV = downcall("clang_getFunctionTypeCallingConv",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_TYPE));
+
+    private static final MethodHandle CLANG_GET_TYPEDEF_NAME = downcall("clang_getTypedefName",
+        FunctionDescriptor.of(CX_STRING, CX_TYPE));
+
+    // --- Diagnostics ---
+
+    private static final MethodHandle CLANG_GET_NUM_DIAGNOSTICS = downcall("clang_getNumDiagnostics",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS));
+
+    private static final MethodHandle CLANG_GET_DIAGNOSTIC = downcall("clang_getDiagnostic",
+        FunctionDescriptor.of(ValueLayout.ADDRESS, ValueLayout.ADDRESS, ValueLayout.JAVA_INT));
+
+    private static final MethodHandle CLANG_DISPOSE_DIAGNOSTIC = downcall("clang_disposeDiagnostic",
+        FunctionDescriptor.ofVoid(ValueLayout.ADDRESS));
+
+    private static final MethodHandle CLANG_GET_DIAGNOSTIC_SEVERITY = downcall("clang_getDiagnosticSeverity",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS));
+
+    private static final MethodHandle CLANG_FORMAT_DIAGNOSTIC = downcall("clang_formatDiagnostic",
+        FunctionDescriptor.of(CX_STRING, ValueLayout.ADDRESS, ValueLayout.JAVA_INT));
+
+    private static final MethodHandle CLANG_DEFAULT_DIAGNOSTIC_DISPLAY_OPTIONS = downcall("clang_defaultDiagnosticDisplayOptions",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT));
+
+    // --- Source location ---
+
+    private static final MethodHandle CLANG_GET_FILE_LOCATION = downcall("clang_getFileLocation",
+        FunctionDescriptor.ofVoid(
+            CX_SOURCE_LOCATION,   // location (by value)
+            ValueLayout.ADDRESS,  // file*
+            ValueLayout.ADDRESS,  // line*
+            ValueLayout.ADDRESS,  // column*
+            ValueLayout.ADDRESS   // offset*
+        ));
+
+    private static final MethodHandle CLANG_GET_FILE_NAME = downcall("clang_getFileName",
+        FunctionDescriptor.of(CX_STRING, ValueLayout.ADDRESS));
+
+    private static final MethodHandle CLANG_LOCATION_IS_IN_SYSTEM_HEADER = downcall("clang_Location_isInSystemHeader",
+        FunctionDescriptor.of(ValueLayout.JAVA_INT, CX_SOURCE_LOCATION));
+
+    // ========================================================================
+    // CXString helper
+    // ========================================================================
+
+    /**
+     * Extracts a Java String from a CXString MemorySegment, then disposes the CXString.
+     * @param allocator allocator for temporary CXString storage
+     * @param cxString the CXString segment (must be CX_STRING.byteSize() bytes)
+     * @return the Java String, or empty string if the C string pointer is NULL
+     */
+    public static String extractString(SegmentAllocator allocator, MemorySegment cxString) {
+        try {
+            MemorySegment cStr = getCString(cxString);
+            if (cStr.equals(MemorySegment.NULL)) {
+                return "";
+            }
+            return getUtf8Safe(cStr);
+        } finally {
+            disposeString(cxString);
+        }
+    }
+
+    // ========================================================================
+    // Public static wrapper methods
+    // ========================================================================
+
+    // --- Core lifecycle ---
+
+    public static MemorySegment createIndex(int excludeDeclarationsFromPCH, int displayDiagnostics) {
+        try {
+            return (MemorySegment) CLANG_CREATE_INDEX.invokeExact(excludeDeclarationsFromPCH, displayDiagnostics);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_createIndex failed", t);
+        }
+    }
+
+    public static void disposeIndex(MemorySegment index) {
+        try {
+            CLANG_DISPOSE_INDEX.invokeExact(index);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_disposeIndex failed", t);
+        }
+    }
+
+    public static int parseTranslationUnit2(MemorySegment index, MemorySegment sourceFilename,
+            MemorySegment commandLineArgs, int numCommandLineArgs,
+            MemorySegment unsavedFiles, int numUnsavedFiles,
+            int options, MemorySegment outTU) {
+        try {
+            return (int) CLANG_PARSE_TRANSLATION_UNIT_2.invokeExact(
+                index, sourceFilename, commandLineArgs, numCommandLineArgs,
+                unsavedFiles, numUnsavedFiles, options, outTU);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_parseTranslationUnit2 failed", t);
+        }
+    }
+
+    public static void disposeTranslationUnit(MemorySegment tu) {
+        try {
+            CLANG_DISPOSE_TRANSLATION_UNIT.invokeExact(tu);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_disposeTranslationUnit failed", t);
+        }
+    }
+
+    // --- String handling ---
+
+    public static MemorySegment getCString(MemorySegment cxString) {
+        try {
+            return (MemorySegment) CLANG_GET_C_STRING.invokeExact(cxString);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCString failed", t);
+        }
+    }
+
+    public static void disposeString(MemorySegment cxString) {
+        try {
+            CLANG_DISPOSE_STRING.invokeExact(cxString);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_disposeString failed", t);
+        }
+    }
+
+    // --- Cursor operations ---
+
+    public static MemorySegment getTranslationUnitCursor(SegmentAllocator allocator, MemorySegment tu) {
+        try {
+            return (MemorySegment) CLANG_GET_TRANSLATION_UNIT_CURSOR.invokeExact(allocator, tu);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getTranslationUnitCursor failed", t);
+        }
+    }
+
+    public static int getCursorKind(MemorySegment cursor) {
+        try {
+            return (int) CLANG_GET_CURSOR_KIND.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCursorKind failed", t);
+        }
+    }
+
+    public static MemorySegment getCursorSpelling(SegmentAllocator allocator, MemorySegment cursor) {
+        try {
+            return (MemorySegment) CLANG_GET_CURSOR_SPELLING.invokeExact(allocator, cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCursorSpelling failed", t);
+        }
+    }
+
+    public static MemorySegment getCursorDisplayName(SegmentAllocator allocator, MemorySegment cursor) {
+        try {
+            return (MemorySegment) CLANG_GET_CURSOR_DISPLAY_NAME.invokeExact(allocator, cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCursorDisplayName failed", t);
+        }
+    }
+
+    public static MemorySegment getCursorType(SegmentAllocator allocator, MemorySegment cursor) {
+        try {
+            return (MemorySegment) CLANG_GET_CURSOR_TYPE.invokeExact(allocator, cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCursorType failed", t);
+        }
+    }
+
+    public static MemorySegment getTypedefDeclUnderlyingType(SegmentAllocator allocator, MemorySegment cursor) {
+        try {
+            return (MemorySegment) CLANG_GET_TYPEDEF_DECL_UNDERLYING_TYPE.invokeExact(allocator, cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getTypedefDeclUnderlyingType failed", t);
+        }
+    }
+
+    public static MemorySegment getEnumDeclIntegerType(SegmentAllocator allocator, MemorySegment cursor) {
+        try {
+            return (MemorySegment) CLANG_GET_ENUM_DECL_INTEGER_TYPE.invokeExact(allocator, cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getEnumDeclIntegerType failed", t);
+        }
+    }
+
+    public static long getEnumConstantDeclValue(MemorySegment cursor) {
+        try {
+            return (long) CLANG_GET_ENUM_CONSTANT_DECL_VALUE.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getEnumConstantDeclValue failed", t);
+        }
+    }
+
+    public static long getEnumConstantDeclUnsignedValue(MemorySegment cursor) {
+        try {
+            return (long) CLANG_GET_ENUM_CONSTANT_DECL_UNSIGNED_VALUE.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getEnumConstantDeclUnsignedValue failed", t);
+        }
+    }
+
+    public static MemorySegment getCursorLocation(SegmentAllocator allocator, MemorySegment cursor) {
+        try {
+            return (MemorySegment) CLANG_GET_CURSOR_LOCATION.invokeExact(allocator, cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCursorLocation failed", t);
+        }
+    }
+
+    public static MemorySegment getCursorSemanticParent(SegmentAllocator allocator, MemorySegment cursor) {
+        try {
+            return (MemorySegment) CLANG_GET_CURSOR_SEMANTIC_PARENT.invokeExact(allocator, cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCursorSemanticParent failed", t);
+        }
+    }
+
+    public static int visitChildren(MemorySegment parent, MemorySegment visitor, MemorySegment clientData) {
+        try {
+            return (int) CLANG_VISIT_CHILDREN.invokeExact(parent, visitor, clientData);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_visitChildren failed", t);
+        }
+    }
+
+    public static int equalCursors(MemorySegment c1, MemorySegment c2) {
+        try {
+            return (int) CLANG_EQUAL_CURSORS.invokeExact(c1, c2);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_equalCursors failed", t);
+        }
+    }
+
+    public static int hashCursor(MemorySegment cursor) {
+        try {
+            return (int) CLANG_HASH_CURSOR.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_hashCursor failed", t);
+        }
+    }
+
+    public static int cursorIsBitField(MemorySegment cursor) {
+        try {
+            return (int) CLANG_CURSOR_IS_BIT_FIELD.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Cursor_isBitField failed", t);
+        }
+    }
+
+    public static int getFieldDeclBitWidth(MemorySegment cursor) {
+        try {
+            return (int) CLANG_GET_FIELD_DECL_BIT_WIDTH.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getFieldDeclBitWidth failed", t);
+        }
+    }
+
+    public static long cursorGetOffsetOfField(MemorySegment cursor) {
+        try {
+            return (long) CLANG_CURSOR_GET_OFFSET_OF_FIELD.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Cursor_getOffsetOfField failed", t);
+        }
+    }
+
+    public static int cursorIsAnonymous(MemorySegment cursor) {
+        try {
+            return (int) CLANG_CURSOR_IS_ANONYMOUS.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Cursor_isAnonymous failed", t);
+        }
+    }
+
+    public static int cursorIsAnonymousRecordDecl(MemorySegment cursor) {
+        try {
+            return (int) CLANG_CURSOR_IS_ANONYMOUS_RECORD_DECL.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Cursor_isAnonymousRecordDecl failed", t);
+        }
+    }
+
+    public static int isDeclaration(int cursorKind) {
+        try {
+            return (int) CLANG_IS_DECLARATION.invokeExact(cursorKind);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_isDeclaration failed", t);
+        }
+    }
+
+    public static int cxxMethodIsVirtual(MemorySegment cursor) {
+        try {
+            return (int) CLANG_CXX_METHOD_IS_VIRTUAL.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_CXXMethod_isVirtual failed", t);
+        }
+    }
+
+    public static int cxxMethodIsPureVirtual(MemorySegment cursor) {
+        try {
+            return (int) CLANG_CXX_METHOD_IS_PURE_VIRTUAL.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_CXXMethod_isPureVirtual failed", t);
+        }
+    }
+
+    public static int cxxMethodIsStatic(MemorySegment cursor) {
+        try {
+            return (int) CLANG_CXX_METHOD_IS_STATIC.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_CXXMethod_isStatic failed", t);
+        }
+    }
+
+    public static int isVirtualBase(MemorySegment cursor) {
+        try {
+            return (int) CLANG_IS_VIRTUAL_BASE.invokeExact(cursor);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_isVirtualBase failed", t);
+        }
+    }
+
+    // --- Type operations ---
+
+    public static MemorySegment getTypeSpelling(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_GET_TYPE_SPELLING.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getTypeSpelling failed", t);
+        }
+    }
+
+    public static MemorySegment getTypeDeclaration(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_GET_TYPE_DECLARATION.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getTypeDeclaration failed", t);
+        }
+    }
+
+    public static long typeGetSizeOf(MemorySegment type) {
+        try {
+            return (long) CLANG_TYPE_GET_SIZE_OF.invokeExact(type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Type_getSizeOf failed", t);
+        }
+    }
+
+    public static long typeGetAlignOf(MemorySegment type) {
+        try {
+            return (long) CLANG_TYPE_GET_ALIGN_OF.invokeExact(type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Type_getAlignOf failed", t);
+        }
+    }
+
+    public static MemorySegment getCanonicalType(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_GET_CANONICAL_TYPE.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getCanonicalType failed", t);
+        }
+    }
+
+    public static MemorySegment typeGetNamedType(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_TYPE_GET_NAMED_TYPE.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Type_getNamedType failed", t);
+        }
+    }
+
+    public static MemorySegment typeGetModifiedType(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_TYPE_GET_MODIFIED_TYPE.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Type_getModifiedType failed", t);
+        }
+    }
+
+    public static MemorySegment getPointeeType(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_GET_POINTEE_TYPE.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getPointeeType failed", t);
+        }
+    }
+
+    public static MemorySegment getArrayElementType(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_GET_ARRAY_ELEMENT_TYPE.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getArrayElementType failed", t);
+        }
+    }
+
+    public static long getArraySize(MemorySegment type) {
+        try {
+            return (long) CLANG_GET_ARRAY_SIZE.invokeExact(type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getArraySize failed", t);
+        }
+    }
+
+    public static MemorySegment getResultType(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_GET_RESULT_TYPE.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getResultType failed", t);
+        }
+    }
+
+    public static int getNumArgTypes(MemorySegment type) {
+        try {
+            return (int) CLANG_GET_NUM_ARG_TYPES.invokeExact(type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getNumArgTypes failed", t);
+        }
+    }
+
+    public static MemorySegment getArgType(SegmentAllocator allocator, MemorySegment type, int index) {
+        try {
+            return (MemorySegment) CLANG_GET_ARG_TYPE.invokeExact(allocator, type, index);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getArgType failed", t);
+        }
+    }
+
+    public static int isFunctionTypeVariadic(MemorySegment type) {
+        try {
+            return (int) CLANG_IS_FUNCTION_TYPE_VARIADIC.invokeExact(type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_isFunctionTypeVariadic failed", t);
+        }
+    }
+
+    public static int getFunctionTypeCallingConv(MemorySegment type) {
+        try {
+            return (int) CLANG_GET_FUNCTION_TYPE_CALLING_CONV.invokeExact(type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getFunctionTypeCallingConv failed", t);
+        }
+    }
+
+    public static MemorySegment getTypedefName(SegmentAllocator allocator, MemorySegment type) {
+        try {
+            return (MemorySegment) CLANG_GET_TYPEDEF_NAME.invokeExact(allocator, type);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getTypedefName failed", t);
+        }
+    }
+
+    // --- Diagnostics ---
+
+    public static int getNumDiagnostics(MemorySegment tu) {
+        try {
+            return (int) CLANG_GET_NUM_DIAGNOSTICS.invokeExact(tu);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getNumDiagnostics failed", t);
+        }
+    }
+
+    public static MemorySegment getDiagnostic(MemorySegment tu, int index) {
+        try {
+            return (MemorySegment) CLANG_GET_DIAGNOSTIC.invokeExact(tu, index);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getDiagnostic failed", t);
+        }
+    }
+
+    public static void disposeDiagnostic(MemorySegment diag) {
+        try {
+            CLANG_DISPOSE_DIAGNOSTIC.invokeExact(diag);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_disposeDiagnostic failed", t);
+        }
+    }
+
+    public static int getDiagnosticSeverity(MemorySegment diag) {
+        try {
+            return (int) CLANG_GET_DIAGNOSTIC_SEVERITY.invokeExact(diag);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getDiagnosticSeverity failed", t);
+        }
+    }
+
+    public static MemorySegment formatDiagnostic(SegmentAllocator allocator, MemorySegment diag, int options) {
+        try {
+            return (MemorySegment) CLANG_FORMAT_DIAGNOSTIC.invokeExact(allocator, diag, options);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_formatDiagnostic failed", t);
+        }
+    }
+
+    public static int defaultDiagnosticDisplayOptions() {
+        try {
+            return (int) CLANG_DEFAULT_DIAGNOSTIC_DISPLAY_OPTIONS.invokeExact();
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_defaultDiagnosticDisplayOptions failed", t);
+        }
+    }
+
+    // --- Source location ---
+
+    public static void getFileLocation(MemorySegment location, MemorySegment file,
+            MemorySegment line, MemorySegment column, MemorySegment offset) {
+        try {
+            CLANG_GET_FILE_LOCATION.invokeExact(location, file, line, column, offset);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getFileLocation failed", t);
+        }
+    }
+
+    public static MemorySegment getFileName(SegmentAllocator allocator, MemorySegment file) {
+        try {
+            return (MemorySegment) CLANG_GET_FILE_NAME.invokeExact(allocator, file);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_getFileName failed", t);
+        }
+    }
+
+    public static int isInSystemHeader(MemorySegment location) {
+        try {
+            return (int) CLANG_LOCATION_IS_IN_SYSTEM_HEADER.invokeExact(location);
+        } catch (Throwable t) {
+            throw new RuntimeException("clang_Location_isInSystemHeader failed", t);
+        }
+    }
+
+    // ========================================================================
+    // Expose linker for upcall stubs
+    // ========================================================================
+
+    static Linker linker() {
+        return LINKER;
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/SourceLocation.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/SourceLocation.java
new file mode 100644
index 0000000000..c700076378
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/SourceLocation.java
@@ -0,0 +1,68 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+/**
+ * Represents a particular source location within a translation unit.
+ * <p>
+ * Wraps a {@code CXSourceLocation} struct (passed by value as a MemorySegment).
+ */
+public final class SourceLocation {
+
+    private final MemorySegment segment;
+    private final Arena arena;
+
+    /**
+     * A file location with filename, line, column, and byte offset.
+     */
+    public record FileLocation(String filename, int line, int column, int offset) {}
+
+    SourceLocation(MemorySegment segment, Arena arena) {
+        this.segment = segment;
+        this.arena = arena;
+    }
+
+    /**
+     * Returns whether this source location is in a system header.
+     */
+    public boolean isInSystemHeader() {
+        return LibClang.isInSystemHeader(segment) != 0;
+    }
+
+    /**
+     * Decompose this source location into file, line, column, and offset components.
+     *
+     * @return a {@link FileLocation} record with the decomposed location
+     */
+    public FileLocation getFileLocation() {
+        // Allocate output parameters
+        MemorySegment fileSeg = arena.allocate(ValueLayout.ADDRESS);
+        MemorySegment lineSeg = arena.allocate(ValueLayout.JAVA_INT);
+        MemorySegment columnSeg = arena.allocate(ValueLayout.JAVA_INT);
+        MemorySegment offsetSeg = arena.allocate(ValueLayout.JAVA_INT);
+
+        LibClang.getFileLocation(segment, fileSeg, lineSeg, columnSeg, offsetSeg);
+
+        int line = lineSeg.get(ValueLayout.JAVA_INT, 0);
+        int column = columnSeg.get(ValueLayout.JAVA_INT, 0);
+        int offset = offsetSeg.get(ValueLayout.JAVA_INT, 0);
+
+        // Extract filename from the CXFile pointer
+        MemorySegment filePtr = fileSeg.get(ValueLayout.ADDRESS, 0);
+        String filename = "";
+        if (filePtr != null && !filePtr.equals(MemorySegment.NULL)) {
+            MemorySegment cxStr = LibClang.getFileName(arena, filePtr);
+            filename = LibClang.extractString(arena, cxStr);
+        }
+
+        return new FileLocation(filename, line, column, offset);
+    }
+
+    @Override
+    public String toString() {
+        FileLocation loc = getFileLocation();
+        return loc.filename() + ":" + loc.line() + ":" + loc.column();
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TranslationUnit.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TranslationUnit.java
new file mode 100644
index 0000000000..7a8f841c50
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TranslationUnit.java
@@ -0,0 +1,231 @@
+package ghidra.app.util.gcpp.clang;
+
+import ghidra.app.util.gcpp.clang.error.ParseException;
+import ghidra.app.util.gcpp.clang.JavaVersionHelper;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+/**
+ * Represents a source code translation unit.
+ * <p>
+ * This is one of the main types in the API. Any time you wish to interact
+ * with Clang's representation of a source file, you typically start with a
+ * translation unit.
+ * <p>
+ * Owns a shared {@link Arena} used to allocate return-by-value struct segments
+ * for {@link Cursor} and {@link Type} objects produced by this TU.
+ */
+public final class TranslationUnit extends JavaVersionHelper implements AutoCloseable {
+
+    /** Parse flag: Indicates that the translation unit is incomplete (e.g. headers). */
+    public static final int INCOMPLETE = 0x02;
+
+    /** Parse flag: Do not parse function bodies. */
+    public static final int SKIP_FUNCTION_BODIES = 0x40;
+
+    /** Parse flag: Continue parsing even after fatal errors. */
+    public static final int KEEP_GOING = 0x200;
+
+    /** Parse flag: Include attributed types in the CXType results. */
+    public static final int INCLUDE_ATTRIBUTED_TYPES = 0x1000;
+
+    /** Parse flag: Visit implicit attributes attached to declarations. */
+    public static final int VISIT_IMPLICIT_ATTRIBUTES = 0x2000;
+
+    private MemorySegment pointer;
+    private final Arena arena;
+
+    // Hold a reference to prevent GC/close of Index while this TU is alive
+    @SuppressWarnings("unused")
+    private final Index index;
+
+    private TranslationUnit(MemorySegment pointer, Arena arena, Index index) {
+        this.pointer = pointer;
+        this.arena = arena;
+        this.index = index;
+    }
+
+    /**
+     * Returns the cursor representing the root of the translation unit's AST.
+     */
+    public Cursor cursor() {
+        MemorySegment cursorSeg = LibClang.getTranslationUnitCursor(arena, pointer);
+        return new Cursor(cursorSeg, arena);
+    }
+
+    /**
+     * Returns the number of diagnostics produced during parsing.
+     */
+    public int getNumDiagnostics() {
+        return LibClang.getNumDiagnostics(pointer);
+    }
+
+    /**
+     * Returns the diagnostic at the given index.
+     *
+     * @param index the zero-based diagnostic index
+     * @return the diagnostic (caller must close when done)
+     */
+    public Diagnostic getDiagnostic(int index) {
+        MemorySegment diagPtr = LibClang.getDiagnostic(pointer, index);
+        return new Diagnostic(diagPtr, arena);
+    }
+
+    /**
+     * Returns the shared Arena used by this translation unit for allocating
+     * struct segments (CXCursor, CXType, CXSourceLocation, CXString, etc.).
+     */
+    public Arena getArena() {
+        return arena;
+    }
+
+    MemorySegment getPointer() {
+        return pointer;
+    }
+
+    @Override
+    public void close() {
+        if (pointer != null && !pointer.equals(MemorySegment.NULL)) {
+            LibClang.disposeTranslationUnit(pointer);
+            pointer = null;
+        }
+        arena.close();
+    }
+
+    /**
+     * Builder for creating TranslationUnit instances with a fluent API.
+     */
+    public static class Builder {
+        private final String sourceFilename;
+        private String[] commandLineArgs;
+        private String unsavedFileName;
+        private String unsavedFileContents;
+        private int options;
+
+        public Builder(String sourceFilename) {
+            this.sourceFilename = sourceFilename;
+            this.options = 0;
+        }
+
+        /**
+         * Set command-line arguments passed to clang (e.g. "-Wall", "-I/path/to/include").
+         */
+        public Builder args(String... args) {
+            this.commandLineArgs = args;
+            return this;
+        }
+
+        /**
+         * Provide an unsaved file (virtual file contents in memory).
+         */
+        public Builder unsavedFile(String name, String contents) {
+            this.unsavedFileName = name;
+            this.unsavedFileContents = contents;
+            return this;
+        }
+
+        /**
+         * Indicates that the translation unit is incomplete (typically used for headers).
+         */
+        public Builder parseIncomplete() {
+            this.options |= INCOMPLETE;
+            return this;
+        }
+
+        /**
+         * Do not parse function bodies.
+         */
+        public Builder skipFunctionBodies() {
+            this.options |= SKIP_FUNCTION_BODIES;
+            return this;
+        }
+
+        /**
+         * Continue parsing even after fatal errors.
+         */
+        public Builder keepGoing() {
+            this.options |= KEEP_GOING;
+            return this;
+        }
+
+        /**
+         * Include attributed types in the CXType results.
+         */
+        public Builder includeAttributedTypes() {
+            this.options |= INCLUDE_ATTRIBUTED_TYPES;
+            return this;
+        }
+
+        /**
+         * Visit implicit attributes attached to declarations.
+         */
+        public Builder visitImplicitAttributes() {
+            this.options |= VISIT_IMPLICIT_ATTRIBUTES;
+            return this;
+        }
+
+        /**
+         * Build and parse the translation unit.
+         *
+         * @param index the Index to parse within
+         * @return the parsed TranslationUnit
+         * @throws ParseException if parsing fails
+         */
+        public TranslationUnit build(Index index) throws ParseException {
+            Arena arena = Arena.ofShared();
+            try {
+                // Allocate source filename as native string
+                MemorySegment filenameSeg = sourceFilename != null
+                    ? allocateUtf8Safe(arena, sourceFilename)
+                    : MemorySegment.NULL;
+
+                // Allocate command line args as array of pointers to strings
+                MemorySegment argsSeg = MemorySegment.NULL;
+                int numArgs = 0;
+                if (commandLineArgs != null && commandLineArgs.length > 0) {
+                    numArgs = commandLineArgs.length;
+                    argsSeg = arena.allocate(ValueLayout.ADDRESS, numArgs);
+                    for (int i = 0; i < numArgs; i++) {
+                        MemorySegment argStr = allocateUtf8Safe(arena, commandLineArgs[i]);
+                        argsSeg.setAtIndex(ValueLayout.ADDRESS, i, argStr);
+                    }
+                }
+
+                // Allocate unsaved files
+                MemorySegment unsavedSeg = MemorySegment.NULL;
+                int numUnsaved = 0;
+                if (unsavedFileName != null && unsavedFileContents != null) {
+                    numUnsaved = 1;
+                    unsavedSeg = arena.allocate(LibClang.CX_UNSAVED_FILE);
+                    MemorySegment nameStr = allocateUtf8Safe(arena, unsavedFileName);
+                    MemorySegment contentsStr = allocateUtf8Safe(arena, unsavedFileContents);
+                    unsavedSeg.set(ValueLayout.ADDRESS, 0, nameStr);
+                    unsavedSeg.set(ValueLayout.ADDRESS, 8, contentsStr);
+                    unsavedSeg.set(ValueLayout.JAVA_LONG, 16, (long) unsavedFileContents.length());
+                }
+
+                // Allocate output pointer for the translation unit
+                MemorySegment outTU = arena.allocate(ValueLayout.ADDRESS);
+
+                int result = LibClang.parseTranslationUnit2(
+                    index.getPointer(), filenameSeg, argsSeg, numArgs,
+                    unsavedSeg, numUnsaved, options, outTU);
+
+                if (result != 0) {
+                    arena.close();
+                    throw new ParseException(result);
+                }
+
+                MemorySegment tuPointer = outTU.get(ValueLayout.ADDRESS, 0);
+                return new TranslationUnit(tuPointer, arena, index);
+            } catch (ParseException e) {
+                throw e;
+            } catch (Throwable t) {
+                arena.close();
+                throw new RuntimeException("Failed to parse translation unit", t);
+            }
+        }
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Type.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Type.java
new file mode 100644
index 0000000000..14d2344f7a
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/Type.java
@@ -0,0 +1,199 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.lang.foreign.Arena;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+/**
+ * Represents a type in the Clang AST.
+ * <p>
+ * Wraps a {@code CXType} struct (passed by value as a MemorySegment).
+ */
+public final class Type {
+
+    private final MemorySegment segment;
+    private final Arena arena;
+
+    /**
+     * Creates a Type wrapping the given CXType segment.
+     *
+     * @param segment the CXType memory segment (must be CX_TYPE.byteSize() bytes)
+     * @param arena   the arena used for allocating return-by-value structs
+     */
+    Type(MemorySegment segment, Arena arena) {
+        this.segment = segment;
+        this.arena = arena;
+    }
+
+    /**
+     * Returns the underlying CXType memory segment.
+     */
+    MemorySegment getSegment() {
+        return segment;
+    }
+
+    // ========================================================================
+    // Type properties
+    // ========================================================================
+
+    /**
+     * Return the kind of this type.
+     */
+    public TypeKind kind() {
+        int kindVal = segment.get(ValueLayout.JAVA_INT, 0);
+        return TypeKind.fromInteger(kindVal);
+    }
+
+    /**
+     * Retrieve the spelling of this type.
+     */
+    public String spelling() {
+        MemorySegment cxStr = LibClang.getTypeSpelling(arena, segment);
+        return LibClang.extractString(arena, cxStr);
+    }
+
+    /**
+     * Unwraps elaborated and attributed type wrappers to get the underlying type.
+     * <p>
+     * If this type's kind is ELABORATED, returns the named type (unwrapped recursively).
+     * If this type's kind is ATTRIBUTED, returns the modified type (unwrapped recursively).
+     * Otherwise returns this type.
+     */
+    public Type unwrap() {
+        TypeKind k = kind();
+        if (k == TypeKind.ELABORATED) {
+            return namedType().unwrap();
+        }
+        if (k == TypeKind.ATTRIBUTED) {
+            return modifiedType().unwrap();
+        }
+        return this;
+    }
+
+    /**
+     * For pointer types, returns the type of the pointee.
+     */
+    public Type pointeeType() {
+        MemorySegment typeSeg = LibClang.getPointeeType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * For array types, returns the element type.
+     */
+    public Type arrayElementType() {
+        MemorySegment typeSeg = LibClang.getArrayElementType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * For constant array types, returns the number of elements.
+     */
+    public long arraySize() {
+        return LibClang.getArraySize(segment);
+    }
+
+    /**
+     * For function types, returns the return type.
+     */
+    public Type resultType() {
+        MemorySegment typeSeg = LibClang.getResultType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * For function types, returns the number of parameter types.
+     */
+    public int numArgTypes() {
+        return LibClang.getNumArgTypes(segment);
+    }
+
+    /**
+     * For function types, returns the parameter type at the given index.
+     */
+    public Type argType(int index) {
+        MemorySegment typeSeg = LibClang.getArgType(arena, segment, index);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * Returns whether this function type is variadic.
+     */
+    public boolean isFunctionVariadic() {
+        return LibClang.isFunctionTypeVariadic(segment) != 0;
+    }
+
+    /**
+     * For function types, returns the calling convention.
+     */
+    public CallingConvention callingConvention() {
+        int cc = LibClang.getFunctionTypeCallingConv(segment);
+        return CallingConvention.fromInteger(cc);
+    }
+
+    /**
+     * Returns the canonical type for this type.
+     * <p>
+     * Clang's type system considers types to be equivalent if they have
+     * the same canonical form.
+     */
+    public Type canonicalType() {
+        MemorySegment typeSeg = LibClang.getCanonicalType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * For elaborated types, returns the named type (the type that the
+     * elaborated type refers to).
+     */
+    public Type namedType() {
+        MemorySegment typeSeg = LibClang.typeGetNamedType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * For attributed types, returns the modified type (the type that the
+     * attribute modifies).
+     */
+    public Type modifiedType() {
+        MemorySegment typeSeg = LibClang.typeGetModifiedType(arena, segment);
+        return new Type(typeSeg, arena);
+    }
+
+    /**
+     * Retrieve the size of this type in bytes, or a negative value if the
+     * size cannot be determined.
+     */
+    public long sizeOf() {
+        return LibClang.typeGetSizeOf(segment);
+    }
+
+    /**
+     * Retrieve the alignment of this type in bytes, or a negative value if
+     * the alignment cannot be determined.
+     */
+    public long alignOf() {
+        return LibClang.typeGetAlignOf(segment);
+    }
+
+    /**
+     * Return the cursor for the declaration of this type.
+     */
+    public Cursor declaration() {
+        MemorySegment cursorSeg = LibClang.getTypeDeclaration(arena, segment);
+        return new Cursor(cursorSeg, arena);
+    }
+
+    /**
+     * Returns the typedef name of this type, or an empty string if not a typedef.
+     */
+    public String getTypedefName() {
+        MemorySegment cxStr = LibClang.getTypedefName(arena, segment);
+        return LibClang.extractString(arena, cxStr);
+    }
+
+    @Override
+    public String toString() {
+        return "Type{kind=" + kind() + ", spelling='" + spelling() + "'}";
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TypeKind.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TypeKind.java
new file mode 100644
index 0000000000..e0f816560f
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/TypeKind.java
@@ -0,0 +1,115 @@
+package ghidra.app.util.gcpp.clang;
+
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum TypeKind {
+    INVALID(0),
+    UNEXPOSED(1),
+    VOID(2),
+    BOOL(3),
+    CHAR_U(4),
+    U_CHAR(5),
+    CHAR16(6),
+    CHAR32(7),
+    U_SHORT(8),
+    U_INT(9),
+    U_LONG(10),
+    U_LONG_LONG(11),
+    U_INT128(12),
+    CHAR_S(13),
+    S_CHAR(14),
+    W_CHAR(15),
+    SHORT(16),
+    INT(17),
+    LONG(18),
+    LONG_LONG(19),
+    INT128(20),
+    FLOAT(21),
+    DOUBLE(22),
+    LONG_DOUBLE(23),
+    NULL_PTR(24),
+    OVERLOAD(25),
+    DEPENDENT(26),
+    OBJ_C_ID(27),
+    OBJ_C_CLASS(28),
+    OBJ_C_SEL(29),
+    FLOAT128(30),
+    HALF(31),
+    FLOAT16(32),
+    SHORT_ACCUM(33),
+    ACCUM(34),
+    LONG_ACCUM(35),
+    U_SHORT_ACCUM(36),
+    U_ACCUM(37),
+    U_LONG_ACCUM(38),
+    B_FLOAT16(39),
+    IBM128(40),
+    COMPLEX(100),
+    POINTER(101),
+    BLOCK_POINTER(102),
+    L_VALUE_REFERENCE(103),
+    R_VALUE_REFERENCE(104),
+    RECORD(105),
+    ENUM(106),
+    TYPEDEF(107),
+    OBJ_C_INTERFACE(108),
+    OBJ_C_OBJECT_POINTER(109),
+    FUNCTION_NO_PROTO(110),
+    FUNCTION_PROTO(111),
+    CONSTANT_ARRAY(112),
+    VECTOR(113),
+    INCOMPLETE_ARRAY(114),
+    VARIABLE_ARRAY(115),
+    DEPENDENT_SIZED_ARRAY(116),
+    MEMBER_POINTER(117),
+    AUTO(118),
+    ELABORATED(119),
+    PIPE(120),
+    O_C_L_SAMPLER(157),
+    O_C_L_EVENT(158),
+    O_C_L_QUEUE(159),
+    O_C_L_RESERVE_I_D(160),
+    OBJ_C_OBJECT(161),
+    OBJ_C_TYPE_PARAM(162),
+    ATTRIBUTED(163),
+    O_C_L_INTEL_SUBGROUP_A_V_C_MCE_PAYLOAD(164),
+    O_C_L_INTEL_SUBGROUP_A_V_C_IME_PAYLOAD(165),
+    O_C_L_INTEL_SUBGROUP_A_V_C_REF_PAYLOAD(166),
+    O_C_L_INTEL_SUBGROUP_A_V_C_SIC_PAYLOAD(167),
+    O_C_L_INTEL_SUBGROUP_A_V_C_MCE_RESULT(168),
+    O_C_L_INTEL_SUBGROUP_A_V_C_IME_RESULT(169),
+    O_C_L_INTEL_SUBGROUP_A_V_C_REF_RESULT(170),
+    O_C_L_INTEL_SUBGROUP_A_V_C_SIC_RESULT(171),
+    O_C_L_INTEL_SUBGROUP_A_V_C_IME_RESULT_SINGLE_REF_STREAMOUT(172),
+    O_C_L_INTEL_SUBGROUP_A_V_C_IME_RESULT_DUAL_REF_STREAMOUT(173),
+    O_C_L_INTEL_SUBGROUP_A_V_C_IME_SINGLE_REF_STREAMIN(174),
+    O_C_L_INTEL_SUBGROUP_A_V_C_IME_DUAL_REF_STREAMIN(175),
+    EXT_VECTOR(176),
+    ATOMIC(177),
+    B_T_F_TAG_ATTRIBUTED(178);
+
+    private static final Map<Integer, TypeKind> BY_VALUE = new HashMap<>();
+
+    private final int value;
+
+    TypeKind(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return this.value;
+    }
+
+    /**
+     * Returns the TypeKind for the given integer value, or {@code null} if unknown.
+     */
+    public static TypeKind fromInteger(int value) {
+        return BY_VALUE.get(value);
+    }
+
+    static {
+        EnumSet.allOf(TypeKind.class).forEach(e -> BY_VALUE.put(e.value, e));
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseErrorCode.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseErrorCode.java
new file mode 100644
index 0000000000..9a45dad0f6
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseErrorCode.java
@@ -0,0 +1,36 @@
+package ghidra.app.util.gcpp.clang.error;
+
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+
+public enum ParseErrorCode {
+    SUCCESS(0),
+    FAILURE(1),
+    CRASHED(2),
+    INVALID_ARGUMENTS(3),
+    AST_READ_ERROR(4);
+
+    private static final Map<Integer, ParseErrorCode> BY_CODE = new HashMap<>();
+
+    private final int code;
+
+    ParseErrorCode(int code) {
+        this.code = code;
+    }
+
+    public int getCode() {
+        return this.code;
+    }
+
+    public static ParseErrorCode fromInteger(int code) {
+        if (!BY_CODE.containsKey(code))
+            throw new RuntimeException("Unknown parse error " + code);
+
+        return BY_CODE.get(code);
+    }
+
+    static {
+        EnumSet.allOf(ParseErrorCode.class).forEach(e -> BY_CODE.put(e.code, e));
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseException.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseException.java
new file mode 100644
index 0000000000..3767dad5fb
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/clang/error/ParseException.java
@@ -0,0 +1,22 @@
+package ghidra.app.util.gcpp.clang.error;
+
+public class ParseException extends Exception {
+
+    public ParseException(ParseErrorCode code) {
+        super(getMessage(code));
+    }
+
+    public ParseException(int code) {
+        this(ParseErrorCode.fromInteger(code));
+    }
+
+    private static String getMessage(ParseErrorCode code) {
+        return switch (code) {
+            case SUCCESS -> "No libclang error occurred";
+            case FAILURE -> "A generic libclang error occurred";
+            case CRASHED -> "libclang crashed while performing the requested operation";
+            case INVALID_ARGUMENTS -> "The function detected that the arguments violate the function contract";
+            case AST_READ_ERROR -> "An AST deserialization error has occurred";
+        };
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ArchitectureMapping.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ArchitectureMapping.java
new file mode 100644
index 0000000000..aba7bb4b54
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ArchitectureMapping.java
@@ -0,0 +1,260 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.lang.*;
+import ghidra.program.util.DefaultLanguageService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Maps Ghidra LanguageID / CompilerSpecID pairs to clang command-line arguments.
+ * <p>
+ * Uses Ghidra's {@link DefaultLanguageService} to resolve {@link LanguageDescription}
+ * from a {@link LanguageID}, falling back to string parsing if the service is unavailable.
+ */
+public class ArchitectureMapping
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+    /**
+     * Maps Ghidra processor / endianness / address-size triples to clang
+     * target architecture names used in {@code --target} triples.
+     * <p>
+     * Each constant corresponds to one Ghidra {@link Processor} +
+     * {@link Endian} + size combination that this plugin knows how to target.
+     */
+    public enum ClangArch
+    {
+        X86_16      ("x86",        Endian.LITTLE, 16, "i386"),
+        X86_32      ("x86",        Endian.LITTLE, 32, "i386"),
+        X86_64      ("x86",        Endian.LITTLE, 64, "x86_64"),
+        ARM_LE      ("ARM",        Endian.LITTLE, 32, "arm"),
+        ARM_BE      ("ARM",        Endian.BIG,    32, "armeb"),
+        AARCH64_LE  ("AARCH64",    Endian.LITTLE, 64, "aarch64"),
+        AARCH64_BE  ("AARCH64",    Endian.BIG,    64, "aarch64_be"),
+        MIPS_BE_32  ("MIPS",       Endian.BIG,    32, "mips"),
+        MIPS_LE_32  ("MIPS",       Endian.LITTLE, 32, "mipsel"),
+        MIPS_BE_64  ("MIPS",       Endian.BIG,    64, "mips64"),
+        MIPS_LE_64  ("MIPS",       Endian.LITTLE, 64, "mips64el"),
+        PPC_BE_32   ("PowerPC",    Endian.BIG,    32, "powerpc"),
+        PPC_BE_64   ("PowerPC",    Endian.BIG,    64, "powerpc64"),
+        PPC_LE_64   ("PowerPC",    Endian.LITTLE, 64, "powerpc64le"),
+        SPARC_32    ("sparc",      Endian.BIG,    32, "sparc"),
+        SPARC_64    ("sparc",      Endian.BIG,    64, "sparc64"),
+        RISCV_32    ("RISCV",      Endian.LITTLE, 32, "riscv32"),
+        RISCV_64    ("RISCV",      Endian.LITTLE, 64, "riscv64"),
+        M68K        ("68000",      Endian.BIG,    32, "m68k"),
+        AVR         ("AVR8",       Endian.LITTLE, 16, "avr"),
+        LOONGARCH64 ("Loongarch",  Endian.LITTLE, 64, "loongarch64"),
+        LOONGARCH32 ("Loongarch",  Endian.LITTLE, 32, "loongarch32"),
+        S390X       ("S-390",      Endian.BIG,    64, "s390x"),
+        S390        ("S-390",      Endian.BIG,    32, "s390");
+
+        private final String processor;
+        private final Endian endian;
+        private final int size;
+        private final String clangArch;
+
+        ClangArch(String processor, Endian endian, int size, String clangArch)
+        {
+            this.processor = processor;
+            this.endian = endian;
+            this.size = size;
+            this.clangArch = clangArch;
+        }
+
+        /** Clang target architecture name (e.g. {@code "x86_64"}, {@code "aarch64"}). */
+        public String clangArch()  { return clangArch; }
+        /** Ghidra processor name as it appears in the LanguageID. */
+        public String processor()  { return processor; }
+        /** Expected endianness. */
+        public Endian endian()     { return endian; }
+        /** Address size in bits (16, 32, 64). */
+        public int size()          { return size; }
+
+        /**
+         * Finds the matching {@code ClangArch} for a Ghidra {@link LanguageDescription}.
+         *
+         * @return the matching constant, or {@code null} if no mapping exists
+         */
+        public static ClangArch find(LanguageDescription desc)
+        {
+            return find(desc.getProcessor().toString(), desc.getEndian(), desc.getSize());
+        }
+
+        /**
+         * Finds the matching {@code ClangArch} for a processor name, endianness, and address size.
+         *
+         * @return the matching constant, or {@code null} if no mapping exists
+         */
+        public static ClangArch find(String processor, Endian endian, int size)
+        {
+            for (ClangArch arch : values())
+                if (arch.processor.equals(processor) && arch.endian == endian && arch.size == size)
+                    return arch;
+            return null;
+        }
+    }
+
+    /**
+     * Determines the target environment (OS, vendor, ABI) from a Ghidra
+     * {@link CompilerSpecID} string, similar to how Ghidra's LLDB debugger agent
+     * uses separate {@code compiler_map} / {@code x86_compiler_map} dicts.
+     * <p>
+     * Each constant defines the vendor and OS-ABI portions of the clang target
+     * triple, plus any extra compiler-compatibility flags needed for parsing.
+     *
+     * @see <a href="https://github.com/NationalSecurityAgency/ghidra/blob/master/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/arch.py">
+     *      Ghidra LLDB agent arch.py</a>
+     */
+    public enum TargetEnvironment
+    {
+        LINUX  ("unknown", "linux-gnu",    List.of("-fgnuc-version=12.0.0")),
+        WINDOWS("pc",      "windows-msvc", List.of(
+            "-fms-extensions", "-fms-compatibility", "-fdeclspec",
+            // Match MSVC 2022 17.10 — enables proper typedef redefinition tolerance
+            // and MSVC-specific parsing behaviors (e.g. enum forward declarations)
+            "-fms-compatibility-version=19.40",
+            "-fdelayed-template-parsing"
+        )),
+        MACOS  ("apple",   "darwin",       List.of("-fgnuc-version=12.0.0"));
+
+        private final String vendor;
+        private final String osSuffix;
+        private final List<String> extraArgs;
+
+        TargetEnvironment(String vendor, String osSuffix, List<String> extraArgs)
+        {
+            this.vendor = vendor;
+            this.osSuffix = osSuffix;
+            this.extraArgs = extraArgs;
+        }
+
+        /** Builds the full clang target triple for the given architecture. */
+        public String buildTriple(String clangArch)
+        {
+            return clangArch + "-" + vendor + "-" + osSuffix;
+        }
+
+        /** Additional clang flags needed for this environment's ABI/extensions. */
+        public List<String> extraArgs() { return extraArgs; }
+
+        /**
+         * Resolves a Ghidra {@link CompilerSpecID} string to a target environment.
+         * <p>
+         * Mirrors the {@code compiler_map} pattern from Ghidra's LLDB agent:
+         * {@code "windows"} and MSVC-family specs map to {@link #WINDOWS},
+         * macOS-related specs map to {@link #MACOS}, everything else defaults
+         * to {@link #LINUX}.
+         */
+        public static TargetEnvironment fromCompilerSpec(String compilerSpecId)
+        {
+            if (compilerSpecId == null)
+                return LINUX;
+            String lower = compilerSpecId.toLowerCase();
+            if (lower.equals("windows") || lower.equals("visual studio")
+                || lower.contains("msvc") || lower.contains("borland")
+                || lower.contains("delphi"))
+                return WINDOWS;
+            if (lower.contains("mac") || lower.contains("clang") || lower.contains("swift"))
+                return MACOS;
+            return LINUX;
+        }
+    }
+
+    /**
+     * Builds the full list of clang arguments for a given Ghidra language/compiler pair.
+     * Includes {@code --target} triple and compiler-specific flags.
+     *
+     * @param languageId   Ghidra LanguageID string (e.g. {@code "x86:LE:64:default"}), may be null
+     * @param compilerSpec Ghidra CompilerSpecID string (e.g. {@code "gcc"}, {@code "windows"}), may be null
+     * @return list of clang arguments, possibly empty if the architecture is unmapped
+     */
+    public static List<String> getClangArgs(String languageId, String compilerSpec)
+    {
+        ClangArch arch = resolveArch(languageId);
+        if (arch == null) {
+            LOGGER.warn("No clang architecture mapping for languageId '{}' — returning empty args", languageId);
+            return List.of();
+        }
+
+        TargetEnvironment env = TargetEnvironment.fromCompilerSpec(compilerSpec);
+        String triple = env.buildTriple(arch.clangArch());
+        LOGGER.debug("Mapped languageId='{}' compilerSpec='{}' -> target={}, env={}", languageId, compilerSpec, triple, env);
+
+        List<String> args = new ArrayList<>();
+        args.add("--target=" + triple);
+        args.addAll(env.extraArgs());
+        return args;
+    }
+
+    /**
+     * Returns just the target triple, or {@code null} if unmapped.
+     */
+    public static String getTargetTriple(String languageId, String compilerSpec)
+    {
+        ClangArch arch = resolveArch(languageId);
+        if (arch == null)
+            return null;
+        return TargetEnvironment.fromCompilerSpec(compilerSpec).buildTriple(arch.clangArch());
+    }
+
+    /**
+     * Resolves a Ghidra LanguageID string to a {@link ClangArch}.
+     * <p>
+     * Tries {@link DefaultLanguageService} first to get a proper
+     * {@link LanguageDescription} with typed {@link Processor}, {@link Endian},
+     * and size. Falls back to parsing the {@code "processor:endian:size:variant"}
+     * string directly if the service is unavailable or the language is unknown.
+     */
+    private static ClangArch resolveArch(String languageId)
+    {
+        if (languageId == null || languageId.isEmpty())
+            return null;
+
+        // Primary path: use Ghidra's language service for proper resolution
+        try
+        {
+            LanguageService svc = DefaultLanguageService.getLanguageService();
+            LanguageDescription desc = svc.getLanguageDescription(new LanguageID(languageId));
+            ClangArch arch = ClangArch.find(desc);
+            if (arch != null) {
+                LOGGER.debug("Resolved '{}' via LanguageService -> {}", languageId, arch);
+            } else {
+                LOGGER.debug("LanguageService found '{}' but no ClangArch mapping for processor={}, endian={}, size={}",
+                    languageId, desc.getProcessor(), desc.getEndian(), desc.getSize());
+            }
+            return arch;
+        }
+        catch (Exception e)
+        {
+            LOGGER.debug("LanguageService lookup failed for '{}': {}, falling back to manual parsing", languageId, e.getMessage());
+        }
+
+        // Fallback: parse "processor:endian:size[:variant]" manually
+        String[] parts = languageId.split(":");
+        if (parts.length < 3) {
+            LOGGER.warn("Cannot parse languageId '{}': expected at least 3 colon-separated parts", languageId);
+            return null;
+        }
+
+        try
+        {
+            Endian endian = Endian.toEndian(parts[1]);
+            int size = Integer.parseInt(parts[2]);
+            ClangArch arch = ClangArch.find(parts[0], endian, size);
+            if (arch != null) {
+                LOGGER.debug("Resolved '{}' via manual parsing -> {}", languageId, arch);
+            } else {
+                LOGGER.warn("No ClangArch mapping for processor='{}', endian={}, size={}", parts[0], endian, size);
+            }
+            return arch;
+        }
+        catch (IllegalArgumentException e)
+        {
+            LOGGER.warn("Failed to parse languageId '{}': {}", languageId, e.getMessage());
+            return null;
+        }
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedEnum.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedEnum.java
new file mode 100644
index 0000000000..515c609e15
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedEnum.java
@@ -0,0 +1,27 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.*;
+import java.util.*;
+
+public class ParsedEnum extends ParsedType {
+    private final int size;
+    private final LinkedHashMap<String, Long> values;
+
+    public ParsedEnum(String name, int size, LinkedHashMap<String, Long> values, CategoryPath categoryPath) {
+        super(name, categoryPath);
+        this.size = size;
+        this.values = new LinkedHashMap<>(values);
+    }
+
+    @Override
+    public DataType createDataType(TypePool pool) {
+        var enumDt = new EnumDataType(getCategoryPath(), getName(), size, pool.getDataTypeManager());
+        values.forEach((name, value) -> enumDt.add(name, value));
+        return enumDt;
+    }
+
+    @Override
+    public List<String> getDependencies() {
+        return List.of();
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedFunctionType.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedFunctionType.java
new file mode 100644
index 0000000000..c46ceb4c5d
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedFunctionType.java
@@ -0,0 +1,71 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ParsedFunctionType extends ParsedType {
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    public record ParamInfo(String name, String typeName) {}
+
+    private final String returnTypeName;
+    private final List<ParamInfo> params;
+    private final boolean isVariadic;
+    private final String callingConvention;
+
+    public ParsedFunctionType(String name, String returnTypeName, List<ParamInfo> params,
+                              boolean isVariadic, String callingConvention,
+                              CategoryPath categoryPath) {
+        super(name, categoryPath);
+        this.returnTypeName = returnTypeName;
+        this.params = List.copyOf(params);
+        this.isVariadic = isVariadic;
+        this.callingConvention = callingConvention;
+    }
+
+    @Override
+    public DataType createDataType(TypePool pool) {
+        CategoryPath funcCategory = new CategoryPath(getCategoryPath(), "functions");
+        var funcDef = new FunctionDefinitionDataType(funcCategory, getName(), pool.getDataTypeManager());
+
+        DataType retType = pool.getType(returnTypeName);
+        if (retType != null) {
+            funcDef.setReturnType(retType);
+        }
+
+        List<ParameterDefinition> paramDefs = new ArrayList<>();
+        for (var param : params) {
+            DataType paramType = pool.getType(param.typeName());
+            if (paramType != null) {
+                paramDefs.add(new ParameterDefinitionImpl(
+                    param.name() != null && !param.name().isEmpty() ? param.name() : null,
+                    paramType, null));
+            }
+        }
+        funcDef.setArguments(paramDefs.toArray(new ParameterDefinition[0]));
+        funcDef.setVarArgs(isVariadic);
+
+        if (callingConvention != null) {
+            try {
+                funcDef.setCallingConvention(callingConvention);
+            } catch (Exception e) {
+                LOGGER.warn("Invalid calling convention '{}' for function '{}': {}", callingConvention, getName(), e.getMessage());
+            }
+        }
+
+        return funcDef;
+    }
+
+    @Override
+    public List<String> getDependencies() {
+        var deps = new ArrayList<String>();
+        deps.add(returnTypeName);
+        deps.addAll(params.stream().map(ParamInfo::typeName).collect(Collectors.toList()));
+        return deps;
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedStructure.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedStructure.java
new file mode 100644
index 0000000000..0a11c3df83
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedStructure.java
@@ -0,0 +1,81 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ParsedStructure extends ParsedType {
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    public record FieldInfo(
+        String name,
+        String typeName,
+        boolean isBitField,
+        int bitFieldWidth,
+        boolean isAnonymous,
+        ParsedType anonymousType
+    ) {}
+
+    private final List<FieldInfo> fields;
+    private final boolean isPacked;
+    private final int explicitPackValue;
+
+    public ParsedStructure(String name, List<FieldInfo> fields, boolean isPacked,
+                           int explicitPackValue, CategoryPath categoryPath) {
+        super(name, categoryPath);
+        this.fields = List.copyOf(fields);
+        this.isPacked = isPacked;
+        this.explicitPackValue = explicitPackValue;
+    }
+
+    @Override
+    public DataType createDataType(TypePool pool) {
+        var struct = new StructureDataType(getCategoryPath(), getName(), 0, pool.getDataTypeManager());
+        struct.setPackingEnabled(true);
+        if (isPacked) {
+            struct.setExplicitPackingValue(1);
+        } else if (explicitPackValue > 0) {
+            struct.setExplicitPackingValue(explicitPackValue);
+        }
+
+        for (var field : fields) {
+            if (field.isBitField()) {
+                DataType fieldType = pool.getType(field.typeName());
+                if (fieldType != null) {
+                    try {
+                        struct.addBitField(fieldType, field.bitFieldWidth(), field.name(), null);
+                    } catch (InvalidDataTypeException e) {
+                        LOGGER.warn("Bit-field failed for '{}.{}' (width={}), falling back to regular field: {}",
+                            getName(), field.name(), field.bitFieldWidth(), e.getMessage());
+                        struct.add(fieldType, field.name(), null);
+                    }
+                }
+            } else if (field.isAnonymous() && field.anonymousType() != null) {
+                DataType anonDt = field.anonymousType().createDataType(pool);
+                if (anonDt != null) {
+                    struct.add(anonDt, "", null);
+                }
+            } else {
+                DataType fieldType = pool.getType(field.typeName());
+                if (fieldType != null) {
+                    struct.add(fieldType, field.name(), null);
+                }
+            }
+        }
+
+        return struct;
+    }
+
+    @Override
+    public List<String> getDependencies() {
+        return fields.stream()
+            .filter(f -> f.typeName() != null && !f.isAnonymous())
+            .map(FieldInfo::typeName)
+            .collect(Collectors.toList());
+    }
+
+    public List<FieldInfo> getFields() { return fields; }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedType.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedType.java
new file mode 100644
index 0000000000..c434bcd62a
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedType.java
@@ -0,0 +1,20 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.CategoryPath;
+import ghidra.program.model.data.DataType;
+import java.util.List;
+
+public abstract class ParsedType {
+    private final String name;
+    private final CategoryPath categoryPath;
+
+    protected ParsedType(String name, CategoryPath categoryPath) {
+        this.name = name;
+        this.categoryPath = categoryPath;
+    }
+
+    public String getName() { return name; }
+    public CategoryPath getCategoryPath() { return categoryPath; }
+    public abstract DataType createDataType(TypePool pool);
+    public abstract List<String> getDependencies();
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedTypedef.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedTypedef.java
new file mode 100644
index 0000000000..75629ad63d
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedTypedef.java
@@ -0,0 +1,27 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.*;
+import java.util.List;
+
+public class ParsedTypedef extends ParsedType {
+    private final String typeName;
+
+    public ParsedTypedef(String name, String typeName, CategoryPath categoryPath) {
+        super(name, categoryPath);
+        this.typeName = typeName;
+    }
+
+    @Override
+    public DataType createDataType(TypePool pool) {
+        DataType dt = pool.getType(typeName);
+        if (dt != null) {
+            return new TypedefDataType(getCategoryPath(), getName(), dt, pool.getDataTypeManager());
+        }
+        return null;
+    }
+
+    @Override
+    public List<String> getDependencies() {
+        return List.of(typeName);
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedUnion.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedUnion.java
new file mode 100644
index 0000000000..6e1da1cd10
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedUnion.java
@@ -0,0 +1,60 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ParsedUnion extends ParsedType {
+    private static final Logger LOGGER = LogManager.getLogger();
+    // Uses same FieldInfo from ParsedStructure
+    private final List<ParsedStructure.FieldInfo> fields;
+
+    public ParsedUnion(String name, List<ParsedStructure.FieldInfo> fields, CategoryPath categoryPath) {
+        super(name, categoryPath);
+        this.fields = List.copyOf(fields);
+    }
+
+    @Override
+    public DataType createDataType(TypePool pool) {
+        var union = new UnionDataType(getCategoryPath(), getName(), pool.getDataTypeManager());
+        union.setPackingEnabled(true);
+
+        for (var field : fields) {
+            if (field.isBitField()) {
+                DataType fieldType = pool.getType(field.typeName());
+                if (fieldType != null) {
+                    try {
+                        union.addBitField(fieldType, field.bitFieldWidth(), field.name(), null);
+                    } catch (InvalidDataTypeException e) {
+                        LOGGER.warn("Bit-field failed for '{}.{}' (width={}), falling back to regular field: {}",
+                            getName(), field.name(), field.bitFieldWidth(), e.getMessage());
+                        union.add(fieldType, field.name(), null);
+                    }
+                }
+            } else if (field.isAnonymous() && field.anonymousType() != null) {
+                DataType anonDt = field.anonymousType().createDataType(pool);
+                if (anonDt != null) {
+                    union.add(anonDt, "", null);
+                }
+            } else {
+                DataType fieldType = pool.getType(field.typeName());
+                if (fieldType != null) {
+                    union.add(fieldType, field.name(), null);
+                }
+            }
+        }
+
+        return union;
+    }
+
+    @Override
+    public List<String> getDependencies() {
+        return fields.stream()
+            .filter(f -> f.typeName() != null && !f.isAnonymous())
+            .map(ParsedStructure.FieldInfo::typeName)
+            .collect(Collectors.toList());
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedVtable.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedVtable.java
new file mode 100644
index 0000000000..de8c219e4f
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/ParsedVtable.java
@@ -0,0 +1,93 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents a C++ vtable as a struct of typed function pointers.
+ * <p>
+ * Each virtual method in the class becomes a function pointer entry in the vtable struct.
+ * The function signatures include an explicit {@code this} pointer as the first parameter,
+ * matching the actual calling convention at the binary level.
+ */
+public class ParsedVtable extends ParsedType {
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    public record VtableEntry(
+        String name,
+        String returnTypeName,
+        List<ParsedFunctionType.ParamInfo> params,
+        boolean isVariadic,
+        String callingConvention
+    ) {}
+
+    private final List<VtableEntry> entries;
+    private final String className;
+
+    public ParsedVtable(String name, List<VtableEntry> entries, String className,
+                        CategoryPath categoryPath) {
+        super(name, categoryPath);
+        this.entries = List.copyOf(entries);
+        this.className = className;
+    }
+
+    @Override
+    public DataType createDataType(TypePool pool) {
+        var vtable = new StructureDataType(getCategoryPath(), getName(), 0, pool.getDataTypeManager());
+        vtable.setPackingEnabled(true);
+
+        for (var entry : entries) {
+            var funcDef = new FunctionDefinitionDataType(
+                new CategoryPath(getCategoryPath(), "functions"),
+                className + "::" + entry.name(),
+                pool.getDataTypeManager()
+            );
+
+            DataType retType = pool.getType(entry.returnTypeName());
+            if (retType != null) {
+                funcDef.setReturnType(retType);
+            }
+
+            List<ParameterDefinition> paramDefs = new ArrayList<>();
+            for (var param : entry.params()) {
+                DataType paramType = pool.getType(param.typeName());
+                if (paramType != null) {
+                    paramDefs.add(new ParameterDefinitionImpl(
+                        param.name() != null && !param.name().isEmpty() ? param.name() : null,
+                        paramType, null));
+                }
+            }
+            funcDef.setArguments(paramDefs.toArray(new ParameterDefinition[0]));
+            funcDef.setVarArgs(entry.isVariadic());
+
+            if (entry.callingConvention() != null) {
+                try {
+                    funcDef.setCallingConvention(entry.callingConvention());
+                } catch (Exception e) {
+                    LOGGER.warn("Invalid calling convention '{}' for vtable entry '{}::{}': {}",
+                        entry.callingConvention(), className, entry.name(), e.getMessage());
+                }
+            }
+
+            var funcPtr = new PointerDataType(funcDef, pool.getDataTypeManager());
+            vtable.add(funcPtr, entry.name(), null);
+        }
+
+        return vtable;
+    }
+
+    /**
+     * Returns an empty dependency list. Vtable entries are all function pointers
+     * (fixed pointer size regardless of signature), so the vtable struct can always
+     * be created immediately. Individual function signatures gracefully handle
+     * missing param/return types in {@link #createDataType}.
+     */
+    @Override
+    public List<String> getDependencies() {
+        return List.of();
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/SourceParser.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/SourceParser.java
new file mode 100644
index 0000000000..33c3d1daa6
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/SourceParser.java
@@ -0,0 +1,625 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.CategoryPath;
+import ghidra.app.util.gcpp.clang.*;
+import ghidra.app.util.gcpp.clang.error.ParseException;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
+/**
+ * Parses C/C++ source files through libclang and populates a {@link TypePool}
+ * with extracted type declarations.
+ * <p>
+ * Unlike the original GhidraClangTypes implementation, this uses a
+ * <b>single recursive pass</b> over the AST. Panama FFI upcalls can nest
+ * freely (JNA callbacks could not), so the two-pass workaround is no longer needed.
+ * <p>
+ * Features over the original:
+ * <ul>
+ *   <li>Bit-field support (via clang_Cursor_isBitField / clang_getFieldDeclBitWidth)</li>
+ *   <li>Packed struct detection (via PACKED_ATTR cursor)</li>
+ *   <li>Function signature extraction (return type, params, varargs, calling convention)</li>
+ *   <li>Header filename &rarr; CategoryPath mapping (matches stock Ghidra parser)</li>
+ *   <li>C++ namespace &rarr; CategoryPath subcategory</li>
+ *   <li>System header filtering</li>
+ *   <li>No hardcoded preamble typedefs</li>
+ * </ul>
+ */
+public class SourceParser {
+
+    private static final Logger LOGGER = LogManager.getLogger();
+    private static final String UMBRELLA_FILENAME = "__gcpp_umbrella.hpp";
+
+    /**
+     * Parse source files from disk through clang.
+     * Generates a synthetic umbrella header that #includes all source files,
+     * passes include paths and options as clang command-line args.
+     *
+     * @return list of diagnostic messages from clang (errors only)
+     */
+    public List<String> parseFiles(TypePool typePool, String[] sourceFiles,
+                                   String[] includePaths, String options,
+                                   String languageId, String compilerSpec) throws ParseException {
+        typePool.clearParsedTypes();
+
+        // Build synthetic umbrella header
+        StringBuilder source = new StringBuilder();
+        for (String file : sourceFiles) {
+            String trimmed = file.trim();
+            if (!trimmed.isEmpty() && !trimmed.startsWith("#"))
+                source.append("#include \"").append(trimmed).append("\"\n");
+        }
+
+        // Build clang args from architecture + compiler
+        List<String> args = new ArrayList<>(ArchitectureMapping.getClangArgs(languageId, compilerSpec));
+
+        // Don't stop parsing after 20 errors -- we want as many types as possible
+        args.add("-ferror-limit=0");
+        // Suppress noisy warnings that don't affect type extraction
+        args.add("-Wno-macro-redefined");
+        args.add("-Wno-nonportable-include-path");
+        args.add("-Wno-pragma-pack");
+        args.add("-Wno-ignored-attributes");
+        args.add("-Wno-ignored-pragma-intrinsic");
+        args.add("-Wno-typedef-redefinition");
+        args.add("-Wno-microsoft-redecl-typedef");
+
+        // Include paths
+        for (String path : includePaths) {
+            String trimmed = path.trim();
+            if (!trimmed.isEmpty())
+                args.add("-I" + trimmed);
+        }
+
+        // Clean and filter profile parse options
+        if (options != null) {
+            for (String line : options.split("\\R")) {
+                String cleaned = cleanProfileOption(line);
+                if (cleaned != null)
+                    args.add(cleaned);
+            }
+        }
+
+        // Override defines AFTER user options (last -D wins).
+        // Attribute-based SAL uses __declspec annotations that clang doesn't support,
+        // causing hundreds of "undeclared identifier 'Name'" errors. Force macro-based SAL.
+        args.add("-D_USE_ATTRIBUTES_FOR_SAL=0");
+
+        // Windows SDK-specific defines to improve header compatibility.
+        // Detect MSVC target from the args list (ArchitectureMapping sets --target=...-windows-msvc).
+        if (args.stream().anyMatch(a -> a.contains("windows-msvc"))) {
+            // Use C-style COM interfaces instead of C++ class inheritance.
+            // Avoids "expected class name" errors from unresolved base classes (IUnknown etc.)
+            // and produces struct definitions with explicit vtable pointers — more useful for RE.
+            args.add("-DCINTERFACE");
+            args.add("-DCOBJMACROS");
+            // ntlsa.h and ntsecapi.h both define LSA types (POLICY_AUDIT_EVENT_TYPE, etc.)
+            // MSVC allows identical struct redefinitions; clang doesn't. Setting _NTLSA_
+            // tells ntsecapi.h that ntlsa.h was already included, preventing duplicates.
+            args.add("-D_NTLSA_");
+        }
+
+        LOGGER.info("Parsing {} source file(s) with language={}, compiler={}", sourceFiles.length, languageId, compilerSpec);
+        LOGGER.debug("Clang args: {}", args);
+
+        List<String> diagnostics = new ArrayList<>();
+
+        try (var index = Index.create(true);
+             var tu = new TranslationUnit.Builder(UMBRELLA_FILENAME)
+                 .unsavedFile(UMBRELLA_FILENAME, source.toString())
+                 .args(args.toArray(new String[0]))
+                 .parseIncomplete()
+                 .skipFunctionBodies()
+                 .keepGoing()
+                 .includeAttributedTypes()
+                 .visitImplicitAttributes()
+                 .build(index)) {
+
+            // Collect only error-level diagnostics (skip warnings/notes)
+            int totalDiags = tu.getNumDiagnostics();
+            for (int i = 0; i < totalDiags; i++) {
+                try (var d = tu.getDiagnostic(i)) {
+                    if (d.severity() >= Diagnostic.SEVERITY_ERROR)
+                        diagnostics.add(d.format());
+                }
+            }
+            if (!diagnostics.isEmpty()) {
+                LOGGER.warn("Clang reported {} error(s) out of {} diagnostics", diagnostics.size(), totalDiags);
+            }
+
+            // Single recursive pass -- Panama upcalls nest freely
+            visitDeclarations(tu.cursor(), CategoryPath.ROOT, typePool);
+        }
+
+        LOGGER.info("Parse complete: {} error diagnostic(s)", diagnostics.size());
+        return diagnostics;
+    }
+
+    // ========================================================================
+    // Recursive AST traversal
+    // ========================================================================
+
+    /**
+     * Recursively visit declarations in the AST, creating ParsedType objects
+     * and adding them to the TypePool.
+     */
+    private void visitDeclarations(Cursor cursor, CategoryPath category, TypePool pool) {
+        cursor.visitChildren((child, parent) -> {
+            // Skip declarations from system headers
+            if (child.location().isInSystemHeader()) {
+                return Cursor.ChildVisitResult.CONTINUE;
+            }
+
+            // Determine category from the source file's header name
+            CategoryPath childCategory = getCategoryForCursor(child, category);
+
+            CursorKind kind = child.kind();
+            if (kind == null) {
+                return Cursor.ChildVisitResult.CONTINUE;
+            }
+
+            switch (kind) {
+                case STRUCT_DECL, CLASS_DECL -> {
+                    parseStruct(pool, child, childCategory);
+                    return Cursor.ChildVisitResult.CONTINUE;
+                }
+                case UNION_DECL -> {
+                    parseUnion(pool, child, childCategory);
+                    return Cursor.ChildVisitResult.CONTINUE;
+                }
+                case ENUM_DECL -> {
+                    parseEnum(pool, child, childCategory);
+                    return Cursor.ChildVisitResult.CONTINUE;
+                }
+                case TYPEDEF_DECL, TYPE_ALIAS_DECL -> {
+                    parseTypedef(pool, child, childCategory);
+                    return Cursor.ChildVisitResult.CONTINUE;
+                }
+                case FUNCTION_DECL -> {
+                    parseFunction(pool, child, childCategory);
+                    return Cursor.ChildVisitResult.CONTINUE;
+                }
+                case NAMESPACE -> {
+                    String nsName = child.spelling();
+                    CategoryPath nsCategory = (nsName == null || nsName.isEmpty())
+                        ? childCategory
+                        : new CategoryPath(childCategory, nsName);
+                    visitDeclarations(child, nsCategory, pool);
+                    return Cursor.ChildVisitResult.CONTINUE;
+                }
+                case UNEXPOSED_DECL, LINKAGE_SPEC -> {
+                    return Cursor.ChildVisitResult.RECURSE;
+                }
+                default -> {
+                    return Cursor.ChildVisitResult.CONTINUE;
+                }
+            }
+        });
+    }
+
+    /**
+     * Determines the CategoryPath for a cursor based on its source file location.
+     * Uses the header filename as the category name (matching stock Ghidra parser behavior).
+     */
+    private CategoryPath getCategoryForCursor(Cursor cursor, CategoryPath fallback) {
+        try {
+            var loc = cursor.location();
+            var fileLoc = loc.getFileLocation();
+            String filename = fileLoc.filename();
+            if (filename != null && !filename.isEmpty()) {
+                String basename = Path.of(filename).getFileName().toString();
+                // Skip our synthetic umbrella header
+                if (!UMBRELLA_FILENAME.equals(basename)) {
+                    return new CategoryPath(CategoryPath.ROOT, basename);
+                }
+            }
+        } catch (Exception e) {
+            LOGGER.debug("Could not determine category for cursor: {}", e.getMessage());
+        }
+        return fallback;
+    }
+
+    // ========================================================================
+    // Type parsing methods
+    // ========================================================================
+
+    private void parseEnum(TypePool pool, Cursor enumCursor, CategoryPath category) {
+        String name = enumCursor.spelling();
+        if (name == null || name.isEmpty())
+            return; // Skip anonymous enums
+
+        long size = enumCursor.enumType().sizeOf();
+        if (size <= 0)
+            return; // Skip forward-declared / incomplete enums
+
+        LinkedHashMap<String, Long> enumValues = new LinkedHashMap<>();
+
+        enumCursor.visitChildren((cursor, parent) -> {
+            if (cursor.kind() == CursorKind.ENUM_CONSTANT_DECL)
+                enumValues.put(cursor.spelling(), cursor.enumValue());
+            return Cursor.ChildVisitResult.CONTINUE;
+        });
+
+        pool.addParsedType(new ParsedEnum(name, (int) size, enumValues, category));
+    }
+
+    private void parseTypedef(TypePool pool, Cursor cursor, CategoryPath category) {
+        String name = cursor.spelling();
+        if (name == null || name.isEmpty())
+            return;
+
+        pool.addParsedType(new ParsedTypedef(name, cursor.underlyingTypedefType().spelling(), category));
+    }
+
+    private void parseStruct(TypePool pool, Cursor structCursor, CategoryPath category) {
+        String name = structCursor.spelling();
+        if (name == null || name.isEmpty())
+            return; // Skip anonymous structs (they'll be handled inline as field types)
+
+        List<ParsedStructure.FieldInfo> fields = new ArrayList<>();
+        boolean[] packed = {false};
+        List<String[]> baseClasses = new ArrayList<>(); // [fieldName, typeName]
+        List<ParsedVtable.VtableEntry> virtualMethods = new ArrayList<>();
+
+        structCursor.visitChildren((cursor, parent) -> {
+            CursorKind kind = cursor.kind();
+            if (kind == null) return Cursor.ChildVisitResult.CONTINUE;
+
+            switch (kind) {
+                case FIELD_DECL -> {
+                    boolean isBitField = cursor.isBitField();
+                    int bitWidth = isBitField ? cursor.getBitFieldWidth() : 0;
+                    boolean isAnon = cursor.isAnonymous();
+
+                    // For anonymous struct/union fields, recursively parse the inner type
+                    ParsedType anonType = null;
+                    if (isAnon) {
+                        Type fieldType = cursor.type().unwrap();
+                        TypeKind typeKind = fieldType.kind();
+                        if (typeKind == TypeKind.RECORD) {
+                            Cursor anonDecl = fieldType.declaration();
+                            CursorKind anonKind = anonDecl.kind();
+                            if (anonKind == CursorKind.STRUCT_DECL || anonKind == CursorKind.CLASS_DECL) {
+                                anonType = parseAnonymousStruct(pool, anonDecl, category);
+                            } else if (anonKind == CursorKind.UNION_DECL) {
+                                anonType = parseAnonymousUnion(pool, anonDecl, category);
+                            }
+                        }
+                    }
+
+                    fields.add(new ParsedStructure.FieldInfo(
+                        cursor.spelling(),
+                        cursor.type().spelling(),
+                        isBitField,
+                        bitWidth,
+                        isAnon,
+                        anonType
+                    ));
+                }
+                case PACKED_ATTR -> packed[0] = true;
+
+                // C++ base classes — embedded as the first fields in the struct
+                case C_X_X_BASE_SPECIFIER -> {
+                    Type baseType = cursor.type();
+                    String baseTypeName = baseType.spelling();
+                    String baseDeclName = baseType.declaration().spelling();
+                    if (baseTypeName != null && !baseTypeName.isEmpty()) {
+                        String fieldName = (baseDeclName != null && !baseDeclName.isEmpty())
+                            ? "super_" + baseDeclName : "super_" + baseTypeName;
+                        baseClasses.add(new String[]{fieldName, baseTypeName});
+                    }
+                }
+
+                // C++ methods — virtual ones go to vtable, all get registered as function defs
+                case C_X_X_METHOD -> {
+                    if (cursor.isVirtualMethod()) {
+                        virtualMethods.add(extractVtableEntry(cursor, name));
+                    }
+                    parseMethodAsFunction(pool, cursor, name, category);
+                }
+
+                // Constructors — registered as function definitions with this* param
+                case CONSTRUCTOR -> {
+                    parseMethodAsFunction(pool, cursor, name, category);
+                }
+
+                // Destructors — virtual ones also go to vtable
+                case DESTRUCTOR -> {
+                    if (cursor.isVirtualMethod()) {
+                        virtualMethods.add(extractVtableEntry(cursor, name));
+                    }
+                    parseMethodAsFunction(pool, cursor, name, category);
+                }
+
+                // Nested type declarations within classes
+                case STRUCT_DECL, CLASS_DECL -> parseStruct(pool, cursor, category);
+                case UNION_DECL -> parseUnion(pool, cursor, category);
+                case ENUM_DECL -> parseEnum(pool, cursor, category);
+                case TYPEDEF_DECL, TYPE_ALIAS_DECL -> parseTypedef(pool, cursor, category);
+
+                default -> {}
+            }
+            return Cursor.ChildVisitResult.CONTINUE;
+        });
+
+        // Build final field list: vptr first, then base classes, then regular fields
+        List<ParsedStructure.FieldInfo> allFields = new ArrayList<>();
+
+        if (!virtualMethods.isEmpty()) {
+            String vtableName = name + "_vtable";
+            pool.addParsedType(new ParsedVtable(vtableName, virtualMethods, name, category));
+            allFields.add(new ParsedStructure.FieldInfo(
+                "vptr", vtableName + " *", false, 0, false, null));
+            LOGGER.debug("Class '{}': created vtable with {} virtual method(s)", name, virtualMethods.size());
+        }
+
+        for (String[] base : baseClasses) {
+            allFields.add(new ParsedStructure.FieldInfo(
+                base[0], base[1], false, 0, false, null));
+        }
+
+        allFields.addAll(fields);
+
+        pool.addParsedType(new ParsedStructure(name, allFields, packed[0], 0, category));
+    }
+
+    private void parseUnion(TypePool pool, Cursor unionCursor, CategoryPath category) {
+        String name = unionCursor.spelling();
+        if (name == null || name.isEmpty())
+            return; // Skip anonymous unions
+
+        List<ParsedStructure.FieldInfo> fields = new ArrayList<>();
+
+        unionCursor.visitChildren((cursor, parent) -> {
+            if (cursor.kind() == CursorKind.FIELD_DECL) {
+                boolean isBitField = cursor.isBitField();
+                int bitWidth = isBitField ? cursor.getBitFieldWidth() : 0;
+                boolean isAnon = cursor.isAnonymous();
+
+                ParsedType anonType = null;
+                if (isAnon) {
+                    Type fieldType = cursor.type().unwrap();
+                    TypeKind typeKind = fieldType.kind();
+                    if (typeKind == TypeKind.RECORD) {
+                        Cursor anonDecl = fieldType.declaration();
+                        CursorKind anonKind = anonDecl.kind();
+                        if (anonKind == CursorKind.STRUCT_DECL || anonKind == CursorKind.CLASS_DECL) {
+                            anonType = parseAnonymousStruct(pool, anonDecl, category);
+                        } else if (anonKind == CursorKind.UNION_DECL) {
+                            anonType = parseAnonymousUnion(pool, anonDecl, category);
+                        }
+                    }
+                }
+
+                fields.add(new ParsedStructure.FieldInfo(
+                    cursor.spelling(),
+                    cursor.type().spelling(),
+                    isBitField,
+                    bitWidth,
+                    isAnon,
+                    anonType
+                ));
+            }
+            return Cursor.ChildVisitResult.CONTINUE;
+        });
+
+        pool.addParsedType(new ParsedUnion(name, fields, category));
+    }
+
+    private void parseFunction(TypePool pool, Cursor funcCursor, CategoryPath category) {
+        String name = funcCursor.spelling();
+        if (name == null || name.isEmpty())
+            return;
+
+        Type funcType = funcCursor.type();
+
+        // Extract return type
+        String returnTypeName = funcType.resultType().spelling();
+
+        // Extract parameters
+        int numArgs = funcType.numArgTypes();
+        List<ParsedFunctionType.ParamInfo> params = new ArrayList<>();
+        for (int i = 0; i < numArgs; i++) {
+            Type argType = funcType.argType(i);
+            // Try to get parameter name from the cursor's children
+            String paramName = getParamName(funcCursor, i);
+            params.add(new ParsedFunctionType.ParamInfo(paramName, argType.spelling()));
+        }
+
+        boolean isVariadic = funcType.isFunctionVariadic();
+
+        // Get calling convention
+        CallingConvention cc = funcType.callingConvention();
+        String ccName = (cc != null) ? cc.getGhidraName() : null;
+
+        pool.addParsedType(new ParsedFunctionType(name, returnTypeName, params,
+            isVariadic, ccName, category));
+    }
+
+    // ========================================================================
+    // C++ method helpers
+    // ========================================================================
+
+    /**
+     * Extract a vtable entry from a virtual method or virtual destructor cursor.
+     * The entry includes an explicit {@code this} pointer as the first parameter.
+     */
+    private ParsedVtable.VtableEntry extractVtableEntry(Cursor methodCursor, String className) {
+        String methodName = methodCursor.spelling();
+        Type methodType = methodCursor.type();
+
+        String returnTypeName = methodType.resultType().spelling();
+
+        // Build parameter list with explicit 'this' pointer
+        List<ParsedFunctionType.ParamInfo> params = new ArrayList<>();
+        params.add(new ParsedFunctionType.ParamInfo("this", className + " *"));
+
+        int numArgs = methodType.numArgTypes();
+        for (int i = 0; i < numArgs; i++) {
+            String paramName = getParamName(methodCursor, i);
+            params.add(new ParsedFunctionType.ParamInfo(paramName, methodType.argType(i).spelling()));
+        }
+
+        boolean isVariadic = methodType.isFunctionVariadic();
+        CallingConvention cc = methodType.callingConvention();
+        String ccName = (cc != null) ? cc.getGhidraName() : null;
+
+        return new ParsedVtable.VtableEntry(methodName, returnTypeName, params, isVariadic, ccName);
+    }
+
+    /**
+     * Register a C++ method, constructor, or destructor as a {@link ParsedFunctionType}
+     * in the pool. Non-static methods get an explicit {@code this} pointer as the first
+     * parameter. The function is named {@code ClassName::methodName}.
+     */
+    private void parseMethodAsFunction(TypePool pool, Cursor methodCursor,
+                                       String className, CategoryPath category) {
+        String methodName = methodCursor.spelling();
+        if (methodName == null || methodName.isEmpty())
+            return;
+
+        Type methodType = methodCursor.type();
+        String returnTypeName = methodType.resultType().spelling();
+
+        List<ParsedFunctionType.ParamInfo> params = new ArrayList<>();
+
+        // Add implicit 'this' pointer for non-static methods
+        if (!methodCursor.isStaticMethod()) {
+            params.add(new ParsedFunctionType.ParamInfo("this", className + " *"));
+        }
+
+        int numArgs = methodType.numArgTypes();
+        for (int i = 0; i < numArgs; i++) {
+            String paramName = getParamName(methodCursor, i);
+            params.add(new ParsedFunctionType.ParamInfo(paramName, methodType.argType(i).spelling()));
+        }
+
+        boolean isVariadic = methodType.isFunctionVariadic();
+        CallingConvention cc = methodType.callingConvention();
+        String ccName = (cc != null) ? cc.getGhidraName() : null;
+
+        String fullName = className + "::" + methodName;
+        pool.addParsedType(new ParsedFunctionType(fullName, returnTypeName, params,
+            isVariadic, ccName, category));
+    }
+
+    // ========================================================================
+    // Anonymous type helpers
+    // ========================================================================
+
+    /**
+     * Parse an anonymous struct declaration into a ParsedStructure without
+     * registering it in the TypePool (it will be embedded inline).
+     */
+    private ParsedStructure parseAnonymousStruct(TypePool pool, Cursor structCursor, CategoryPath category) {
+        List<ParsedStructure.FieldInfo> fields = new ArrayList<>();
+        boolean[] packed = {false};
+
+        structCursor.visitChildren((cursor, parent) -> {
+            CursorKind kind = cursor.kind();
+            if (kind == CursorKind.FIELD_DECL) {
+                boolean isBitField = cursor.isBitField();
+                int bitWidth = isBitField ? cursor.getBitFieldWidth() : 0;
+                fields.add(new ParsedStructure.FieldInfo(
+                    cursor.spelling(), cursor.type().spelling(),
+                    isBitField, bitWidth, false, null));
+            } else if (kind == CursorKind.PACKED_ATTR) {
+                packed[0] = true;
+            }
+            return Cursor.ChildVisitResult.CONTINUE;
+        });
+
+        // Use a synthetic name for the anonymous struct
+        String anonName = "anon_struct_" + Integer.toHexString(structCursor.hashCode());
+        return new ParsedStructure(anonName, fields, packed[0], 0, category);
+    }
+
+    /**
+     * Parse an anonymous union declaration into a ParsedUnion without
+     * registering it in the TypePool.
+     */
+    private ParsedUnion parseAnonymousUnion(TypePool pool, Cursor unionCursor, CategoryPath category) {
+        List<ParsedStructure.FieldInfo> fields = new ArrayList<>();
+
+        unionCursor.visitChildren((cursor, parent) -> {
+            if (cursor.kind() == CursorKind.FIELD_DECL) {
+                boolean isBitField = cursor.isBitField();
+                int bitWidth = isBitField ? cursor.getBitFieldWidth() : 0;
+                fields.add(new ParsedStructure.FieldInfo(
+                    cursor.spelling(), cursor.type().spelling(),
+                    isBitField, bitWidth, false, null));
+            }
+            return Cursor.ChildVisitResult.CONTINUE;
+        });
+
+        String anonName = "anon_union_" + Integer.toHexString(unionCursor.hashCode());
+        return new ParsedUnion(anonName, fields, category);
+    }
+
+    // ========================================================================
+    // Utility methods
+    // ========================================================================
+
+    /**
+     * Try to extract the parameter name from a function declaration cursor.
+     * Falls back to empty string if the parameter at the given index has no name.
+     */
+    private String getParamName(Cursor funcCursor, int paramIndex) {
+        String[] names = {""};
+        int[] currentIndex = {0};
+
+        funcCursor.visitChildren((cursor, parent) -> {
+            if (cursor.kind() == CursorKind.PARM_DECL) {
+                if (currentIndex[0] == paramIndex) {
+                    String spelling = cursor.spelling();
+                    names[0] = (spelling != null) ? spelling : "";
+                    return Cursor.ChildVisitResult.BREAK;
+                }
+                currentIndex[0]++;
+            }
+            return Cursor.ChildVisitResult.CONTINUE;
+        });
+
+        return names[0];
+    }
+
+    /**
+     * Cleans a single option line from a Ghidra .prf profile for use with clang.
+     * Handles Ghidra-specific formatting (quoted options with trailing commas,
+     * escaped quotes) and filters out Ghidra-specific options that clang doesn't understand.
+     *
+     * @return the cleaned option string, or null if the line should be skipped
+     */
+    private static String cleanProfileOption(String raw) {
+        String s = raw.trim();
+        if (s.isEmpty())
+            return null;
+
+        // Strip trailing comma (Ghidra profile format quirk)
+        if (s.endsWith(","))
+            s = s.substring(0, s.length() - 1).trim();
+
+        // Strip outer double quotes: "-Dfoo=\"bar\"" -> -Dfoo=\"bar\"
+        if (s.length() >= 2 && s.startsWith("\"") && s.endsWith("\""))
+            s = s.substring(1, s.length() - 1);
+
+        // Unescape inner quotes: \" -> "
+        s = s.replace("\\\"", "\"");
+
+        if (s.isEmpty())
+            return null;
+
+        // Filter out Ghidra-specific options that clang doesn't understand
+        // -v0, -v1, -v2 etc. are Ghidra C parser verbosity flags
+        if (s.matches("-v\\d+"))
+            return null;
+
+        return s;
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/TypePool.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/TypePool.java
new file mode 100644
index 0000000000..efe6dfbdc2
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/processing/TypePool.java
@@ -0,0 +1,319 @@
+package ghidra.app.util.gcpp.processing;
+
+import ghidra.program.model.data.*;
+import ghidra.util.data.DataTypeParser;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+public class TypePool {
+    private static final Logger LOGGER = LogManager.getLogger();
+    private final DataTypeManager[] openArchives;
+
+    private final Map<String, ParsedType> parsedTypes = new HashMap<>();
+    private final StandAloneDataTypeManager dtm;
+    private final DataTypeParser typeParser;
+
+    // Pattern to match trailing array dimensions, e.g. "[10]", "[0]"
+    private static final Pattern ARRAY_SUFFIX = Pattern.compile("^(.+)\\[(\\d+)]$");
+
+    /**
+     * @param openArchives additional DTMs to search for existing types (may be null)
+     */
+    public TypePool(DataTypeManager[] openArchives) {
+        this.openArchives = openArchives;
+
+        this.dtm = new StandAloneDataTypeManager(CategoryPath.ROOT.getName());
+        // Pass null for DataTypeManagerService to avoid interactive per-type chooser dialogs.
+        // Open archives are searched explicitly in getType() instead.
+        this.typeParser = new DataTypeParser(this.dtm, this.dtm, null, DataTypeParser.AllowedDataTypes.FIXED_LENGTH);
+    }
+
+    public ResolutionResult resolve() {
+        LOGGER.debug("Starting type resolution for {} parsed types", parsedTypes.size());
+        int transaction = this.dtm.startTransaction("Process clang types");
+
+        // Pre-register forward declarations for all structs and unions.
+        // This allows pointer-to-struct/union dependencies to resolve before
+        // the actual type is fully defined — critical for self-referential
+        // types (e.g. linked list nodes) and cross-referential struct pointers.
+        int forwardDecls = 0;
+        for (ParsedType pt : this.parsedTypes.values()) {
+            if (pt instanceof ParsedStructure) {
+                this.dtm.addDataType(
+                    new StructureDataType(pt.getCategoryPath(), pt.getName(), 0, dtm),
+                    DataTypeConflictHandler.REPLACE_HANDLER);
+                forwardDecls++;
+            } else if (pt instanceof ParsedUnion) {
+                this.dtm.addDataType(
+                    new UnionDataType(pt.getCategoryPath(), pt.getName(), dtm),
+                    DataTypeConflictHandler.REPLACE_HANDLER);
+                forwardDecls++;
+            } else if (pt instanceof ParsedVtable) {
+                this.dtm.addDataType(
+                    new StructureDataType(pt.getCategoryPath(), pt.getName(), 0, dtm),
+                    DataTypeConflictHandler.REPLACE_HANDLER);
+                forwardDecls++;
+            }
+        }
+        LOGGER.debug("Registered {} forward declarations", forwardDecls);
+
+        Set<ParsedType> outstandingParsedTypes = new HashSet<>(this.parsedTypes.values());
+
+        // Iteratively create data types as their dependencies are fulfilled.
+        // When no more progress can be made, skip unresolvable types rather than
+        // failing entirely — system headers commonly reference types from unparsed
+        // headers, function pointers, etc. that can't be resolved.
+        int iteration = 0;
+        while (!outstandingParsedTypes.isEmpty()) {
+            boolean hasResolved = false;
+            int resolvedThisPass = 0;
+
+            for (var it = outstandingParsedTypes.iterator(); it.hasNext(); ) {
+                var parsedType = it.next();
+
+                if (this.checkDependenciesFulfilled(parsedType)) {
+                    try {
+                        var dt = parsedType.createDataType(this);
+                        if (dt != null) {
+                            this.dtm.addDataType(dt, DataTypeConflictHandler.REPLACE_HANDLER);
+                        }
+                    } catch (Exception e) {
+                        LOGGER.warn("Failed to create type '{}': {}", parsedType.getName(), e.getMessage());
+                    }
+                    it.remove();
+                    hasResolved = true;
+                    resolvedThisPass++;
+                }
+            }
+
+            iteration++;
+            LOGGER.debug("Resolution pass {}: resolved {} types, {} remaining",
+                iteration, resolvedThisPass, outstandingParsedTypes.size());
+
+            // No more progress — remaining types have unresolvable dependencies
+            if (!hasResolved)
+                break;
+        }
+
+        this.dtm.endTransaction(transaction, true);
+
+        // Collect what we resolved
+        Set<String> unresolvedDependencies = Set.of();
+        if (!outstandingParsedTypes.isEmpty()) {
+            unresolvedDependencies = outstandingParsedTypes.stream()
+                .flatMap(parsedType -> this.getUnfulfilledDependencies(parsedType).stream())
+                .collect(Collectors.toSet());
+            LOGGER.warn("{} types could not be resolved due to unfulfilled dependencies: {}",
+                outstandingParsedTypes.size(),
+                outstandingParsedTypes.stream().map(ParsedType::getName).collect(Collectors.joining(", ")));
+        }
+
+        List<DataType> allTypes = new ArrayList<>();
+        this.dtm.getAllDataTypes(allTypes);
+        LOGGER.debug("Type resolution complete: {} types resolved in {} passes", allTypes.size(), iteration);
+        return new ResolutionResult(List.copyOf(allTypes), Set.copyOf(unresolvedDependencies));
+    }
+
+    public void addParsedType(ParsedType type) {
+        this.parsedTypes.put(type.getName(), type);
+    }
+
+    public void clearParsedTypes() {
+        this.parsedTypes.clear();
+    }
+
+    public DataTypeManager getDataTypeManager() {
+        return this.dtm;
+    }
+
+    /**
+     * Closes the internal StandAloneDataTypeManager, releasing resources.
+     * Call this when the TypePool is no longer needed.
+     */
+    public void close() {
+        this.dtm.close();
+    }
+
+    public DataType getType(String name) {
+        // Try direct resolution first
+        DataType dt = resolveType(name);
+        if (dt != null)
+            return dt;
+
+        // Normalize: strip CV qualifiers and elaborated type specifiers.
+        // Clang may spell types as "const struct _FOO *" but we register them as "_FOO".
+        // Ghidra's DataTypeParser doesn't understand const/volatile qualifiers.
+        String normalized = normalizeTypeName(name);
+        if (normalized != null) {
+            dt = resolveType(normalized);
+            if (dt != null)
+                return dt;
+
+            // Try pointer/array/function-pointer handling on the normalized name too
+            dt = resolveComposite(normalized);
+            if (dt != null)
+                return dt;
+        }
+
+        // Try pointer, array, and function pointer handling on the original name
+        dt = resolveComposite(name);
+        if (dt != null)
+            return dt;
+
+        return null;
+    }
+
+    /**
+     * Handles pointer types (trailing *), array types (trailing [N]),
+     * and function pointers (contains (*) or (^)).
+     */
+    private DataType resolveComposite(String name) {
+        // Handle pointer types: if name ends with *, strip it, resolve base, wrap in PointerDataType
+        if (name.endsWith("*")) {
+            String baseName = name.substring(0, name.length() - 1).trim();
+            DataType baseType = getType(baseName);
+            if (baseType != null) {
+                return new PointerDataType(baseType, this.dtm);
+            }
+            // Unknown base — return a generic void pointer
+            return new PointerDataType(this.dtm);
+        }
+
+        // Handle array types: if name ends with [N], extract N, strip it, resolve element type
+        Matcher arrayMatcher = ARRAY_SUFFIX.matcher(name.trim());
+        if (arrayMatcher.matches()) {
+            String elementName = arrayMatcher.group(1).trim();
+            int count = Integer.parseInt(arrayMatcher.group(2));
+            DataType elementType = getType(elementName);
+            if (elementType != null) {
+                return new ArrayDataType(elementType, count, elementType.getLength(), this.dtm);
+            }
+        }
+
+        // Handle function pointers: if name contains (*) or (^), look up in parsed types
+        // first, then fall back to generic PointerDataType
+        if (name.contains("(*)") || name.contains("(^)")) {
+            // Check if we have a parsed function type that matches
+            ParsedType parsed = parsedTypes.get(name);
+            if (parsed instanceof ParsedFunctionType) {
+                DataType funcDt = parsed.createDataType(this);
+                if (funcDt != null) {
+                    return new PointerDataType(funcDt, this.dtm);
+                }
+            }
+            return new PointerDataType(this.dtm);
+        }
+
+        return null;
+    }
+
+    private DataType resolveType(String name) {
+        // Check our internal StandAloneDataTypeManager (built-in + already resolved types)
+        try {
+            DataType dt = typeParser.parse(name);
+            if (dt != null)
+                return dt;
+        } catch (Exception ignored) {}
+
+        // Then check the open archives the user chose to use
+        if (openArchives != null) {
+            for (DataTypeManager archive : openArchives) {
+                DataType dt = findTypeByName(archive, name);
+                if (dt != null) {
+                    // Copy it into our DTM so it's available for future resolution
+                    return dtm.addDataType(dt, DataTypeConflictHandler.REPLACE_HANDLER);
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private static final String[] CV_QUALIFIERS = {"const ", "volatile ", "restrict ", "__unaligned "};
+    private static final String[] ELABORATED_PREFIXES = {"struct ", "union ", "enum ", "class "};
+
+    /**
+     * Strips C/C++ CV qualifiers and elaborated type specifiers from a type name.
+     * Handles "const struct _FOO *", "volatile DWORD", "const volatile int *", etc.
+     * Ghidra data types don't model const/volatile, so these are safe to strip.
+     * Returns the normalized name, or null if no changes were made.
+     */
+    private static String normalizeTypeName(String name) {
+        String s = name;
+        boolean changed = false;
+
+        // Strip leading CV qualifiers (may be stacked: "const volatile struct _FOO")
+        boolean stripped;
+        do {
+            stripped = false;
+            for (String q : CV_QUALIFIERS) {
+                if (s.startsWith(q)) {
+                    s = s.substring(q.length());
+                    changed = true;
+                    stripped = true;
+                    break;
+                }
+            }
+        } while (stripped);
+
+        // Strip elaborated type specifiers (struct/union/enum/class prefix)
+        for (String p : ELABORATED_PREFIXES) {
+            if (s.startsWith(p)) {
+                s = s.substring(p.length());
+                changed = true;
+                break;
+            }
+        }
+
+        return changed ? s : null;
+    }
+
+    private DataType findTypeByName(DataTypeManager mgr, String name) {
+        // Try direct lookup first (handles fully qualified names)
+        List<DataType> results = new ArrayList<>();
+        mgr.findDataTypes(name, results);
+        if (!results.isEmpty())
+            return results.get(0);
+        return null;
+    }
+
+    private boolean hasType(String name) {
+        return this.getType(name) != null;
+    }
+
+    private boolean checkDependenciesFulfilled(ParsedType type) {
+        for (var dependency : type.getDependencies()) {
+            if (!this.hasType(dependency))
+                return false;
+        }
+        return true;
+    }
+
+    private List<String> getUnfulfilledDependencies(ParsedType type) {
+        return type.getDependencies().stream().filter(s -> !this.hasType(s)).toList();
+    }
+
+    public static class ResolutionResult {
+        private final List<DataType> dataTypes;
+        private final Set<String> unresolvedDependencies;
+
+        ResolutionResult(List<DataType> dataTypes, Set<String> unresolvedDependencies) {
+            this.dataTypes = dataTypes;
+            this.unresolvedDependencies = unresolvedDependencies;
+        }
+
+        public List<DataType> getDataTypes() {
+            return this.dataTypes;
+        }
+
+        public Set<String> getUnresolvedDependencies() {
+            return this.unresolvedDependencies;
+        }
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/task/ClangParseTask.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/task/ClangParseTask.java
new file mode 100644
index 0000000000..d82266d457
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/task/ClangParseTask.java
@@ -0,0 +1,212 @@
+/**
+ * Copyright 2024 playday3008
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+ * provided that the above copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+package ghidra.app.util.gcpp.task;
+
+import ghidra.app.util.gcpp.GCPPPlugin;
+
+import javax.swing.SwingUtilities;
+import java.io.File;
+import java.io.IOException;
+
+import docking.widgets.dialogs.MultiLineMessageDialog;
+import ghidra.program.database.data.ProgramDataTypeManager;
+import ghidra.program.model.data.DataTypeManager;
+import ghidra.program.model.data.FileDataTypeManager;
+import ghidra.util.Msg;
+import ghidra.util.task.Task;
+import ghidra.util.task.TaskMonitor;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+/**
+ * Background task to parse C/C++ files using libclang.
+ * Supports both "Parse to Program" (existing DTM) and "Parse to File" (new archive).
+ */
+public class ClangParseTask extends Task
+{
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    private final GCPPPlugin plugin;
+
+    private String[] filenames;
+    private String[] includePaths;
+    private String options;
+
+    private String languageId;
+    private String compilerSpecId;
+    private DataTypeManager[] openArchives;
+
+    private final DataTypeManager dataTypeManager;
+    private final File dataFile;
+
+    /**
+     * Parse to a new archive file.
+     */
+    public ClangParseTask(GCPPPlugin plugin, String dataFileName)
+    {
+        super("Parsing C/C++ Files (Clang Powered)", true, false, false);
+        this.plugin = plugin;
+        this.dataTypeManager = null;
+        this.dataFile = new File(dataFileName);
+    }
+
+    /**
+     * Parse to an existing DataTypeManager (e.g. the current program's).
+     */
+    public ClangParseTask(GCPPPlugin plugin, DataTypeManager dataTypeManager)
+    {
+        super("Parsing C/C++ Files (Clang Powered)", true, false, false);
+        this.plugin = plugin;
+        this.dataTypeManager = dataTypeManager;
+        this.dataFile = null;
+    }
+
+    public ClangParseTask setFileNames(String[] names)
+    {
+        this.filenames = names.clone();
+        return this;
+    }
+
+    public ClangParseTask setIncludePaths(String[] paths)
+    {
+        this.includePaths = paths.clone();
+        return this;
+    }
+
+    public ClangParseTask setOptions(String options)
+    {
+        this.options = options;
+        return this;
+    }
+
+    public ClangParseTask setLanguageID(String languageId)
+    {
+        this.languageId = languageId;
+        return this;
+    }
+
+    public ClangParseTask setCompilerID(String compilerSpecId)
+    {
+        this.compilerSpecId = compilerSpecId;
+        return this;
+    }
+
+    public ClangParseTask setOpenArchives(DataTypeManager[] openArchives)
+    {
+        this.openArchives = openArchives;
+        return this;
+    }
+
+    @Override
+    public void run(TaskMonitor monitor)
+    {
+        LOGGER.info("Starting clang parse task: {} source file(s)", filenames != null ? filenames.length : 0);
+
+        FileDataTypeManager fileDtMgr = null;
+
+        if (dataFile != null)
+        {
+            try
+            {
+                LOGGER.debug("Creating archive file: {}", dataFile.getAbsolutePath());
+                fileDtMgr = FileDataTypeManager.createFileArchive(dataFile, languageId, compilerSpecId);
+            }
+            catch (IOException e)
+            {
+                LOGGER.error("Failed to create archive: {}", dataFile.getAbsolutePath(), e);
+                showError("Archive Failure", "Failed to create archive: " + e.getMessage());
+                return;
+            }
+        }
+
+        DataTypeManager dtMgr = fileDtMgr != null ? fileDtMgr : dataTypeManager;
+        int initialDtCount = dtMgr.getDataTypeCount(true);
+
+        try
+        {
+            String langId = languageId;
+            String compSpec = compilerSpecId;
+            if (plugin.getProgram() != null)
+            {
+                var lcsPair = plugin.getProgram().getLanguageCompilerSpecPair();
+                if (langId == null)
+                    langId = lcsPair.languageID.getIdAsString();
+                if (compSpec == null)
+                    compSpec = lcsPair.compilerSpecID.getIdAsString();
+            }
+
+            LOGGER.debug("Parse target: {}, language={}, compiler={}", getParseDestination(dtMgr), langId, compSpec);
+            String diagnostics = plugin.parseWithClang(filenames, includePaths, options, dtMgr, langId, compSpec, openArchives, monitor);
+
+            if (fileDtMgr != null && dtMgr.getDataTypeCount(true) != 0)
+                fileDtMgr.save();
+
+            int added = dtMgr.getDataTypeCount(true) - initialDtCount;
+            String destination = getParseDestination(dtMgr);
+            LOGGER.info("Parse completed successfully: {} data types added to {}", added, destination);
+            showSuccess(added, destination, diagnostics);
+        }
+        catch (Exception e)
+        {
+            int added = dtMgr.getDataTypeCount(true) - initialDtCount;
+            LOGGER.error("Parse failed ({} types added before failure)", added, e);
+            String countMsg = added > 0 ? added + " data types added before failure.\n\n" : "";
+            showError("Clang Parse Failed", countMsg + e.getMessage());
+        }
+        finally
+        {
+            if (fileDtMgr != null)
+            {
+                boolean empty = fileDtMgr.getDataTypeCount(true) == 0;
+                fileDtMgr.close();
+                if (empty) {
+                    LOGGER.debug("Deleting empty archive: {}", dataFile.getAbsolutePath());
+                    dataFile.delete();
+                }
+            }
+        }
+    }
+
+    private String getParseDestination(DataTypeManager dtMgr)
+    {
+        if (dtMgr instanceof ProgramDataTypeManager)
+            return "Program " + dtMgr.getName();
+        if (dtMgr instanceof FileDataTypeManager fileDtm)
+            return "Archive File: " + fileDtm.getFilename();
+        return dtMgr.getName();
+    }
+
+    private void showSuccess(int addedCount, String destination, String diagnostics)
+    {
+        String countMsg = (addedCount == 0 ? "No" : Integer.toString(addedCount)) + " data types added.";
+        StringBuilder sb = new StringBuilder("<html><b>").append(countMsg).append("</b>");
+        if (diagnostics != null && !diagnostics.isEmpty())
+        {
+            sb.append("<br><br><b>Clang Diagnostics:</b><br>");
+            sb.append(diagnostics.replace("&", "&amp;").replace("<", "&lt;").replace("\n", "<br>"));
+        }
+
+        SwingUtilities.invokeLater(() ->
+            MultiLineMessageDialog.showModalMessageDialog(
+                plugin.getDialog().getComponent(),
+                "Clang Parse Completed",
+                "Parsed header file(s) to " + destination,
+                sb.toString(),
+                MultiLineMessageDialog.INFORMATION_MESSAGE));
+    }
+
+    private void showError(String title, String message)
+    {
+        SwingUtilities.invokeLater(() ->
+            Msg.showError(this, plugin.getDialog().getComponent(), title, message));
+    }
+}
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/ui/ClangParseDialog.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/ui/ClangParseDialog.java
new file mode 100644
index 0000000000..922812cdb1
--- /dev/null
+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/gcpp/ui/ClangParseDialog.java
@@ -0,0 +1,1005 @@
+/**
+ * Copyright 2024 playday3008
+ * Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+ * provided that the above copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+package ghidra.app.util.gcpp.ui;
+
+import ghidra.app.util.gcpp.GCPPPlugin;
+
+import java.awt.*;
+import java.awt.event.ItemEvent;
+import java.awt.event.ItemListener;
+import java.io.*;
+import java.util.*;
+import java.util.List;
+
+import javax.swing.*;
+import javax.swing.event.*;
+import javax.swing.table.TableModel;
+
+import docking.*;
+import docking.action.*;
+import docking.widgets.OptionDialog;
+import docking.widgets.button.BrowseButton;
+import docking.widgets.combobox.GhidraComboBox;
+import docking.widgets.dialogs.InputDialog;
+import docking.widgets.filechooser.GhidraFileChooser;
+import docking.widgets.filechooser.GhidraFileChooserMode;
+import docking.widgets.label.GLabel;
+import docking.widgets.pathmanager.PathnameTablePanel;
+import docking.widgets.table.GTableCellRenderer;
+import docking.widgets.table.GTableCellRenderingData;
+import generic.jar.ResourceFile;
+import generic.theme.Gui;
+import ghidra.app.plugin.core.processors.SetLanguageDialog;
+import ghidra.framework.Application;
+import ghidra.framework.options.SaveState;
+import ghidra.framework.preferences.Preferences;
+import ghidra.framework.store.db.PackedDatabase;
+import ghidra.program.model.data.FileDataTypeManager;
+import ghidra.program.model.lang.CompilerSpecID;
+import ghidra.program.model.lang.LanguageID;
+import ghidra.util.Msg;
+import ghidra.util.filechooser.ExtensionFileFilter;
+import resources.Icons;
+
+/**
+ * Dialog for parsing C/C++ source files using clang. Closely mirrors Ghidra's built-in
+ * ParseDialog for "Parse C Source" but uses libclang as the parsing backend.
+ *
+ * Uses the same .prf profile format and directories as the built-in C parser.
+ */
+public class ClangParseDialog extends ReusableDialogComponentProvider
+{
+    static final String PROFILE_DIR = "parserprofiles";
+    private static final String FILE_EXTENSION = ".prf";
+
+    private static final String CURRENT_PROFILE = "GCPPCurrentProfile";
+    private static final String USER_DEFINED = "GCPPIsUserDefined";
+    private static final String LAST_IMPORT_C_DIRECTORY = "LastImportCDirectory";
+
+    private JPanel mainPanel;
+    private final GCPPPlugin plugin;
+    private JButton parseButton;
+    private JButton parseToFileButton;
+
+    private PathnameTablePanel pathPanel;
+    private JTextArea parseOptionsField;
+
+    private JComponent languagePanel;
+    private JTextField languageTextField;
+    private JButton languageButton;
+    private String languageIDString = null;
+    private String compilerIDString = null;
+
+    private GhidraComboBox<ComboBoxItem> comboBox;
+    private DefaultComboBoxModel<ComboBoxItem> comboModel;
+    private DockingAction saveAction;
+    private DockingAction saveAsAction;
+    private DockingAction clearAction;
+    private DockingAction deleteAction;
+    private DockingAction refreshAction;
+    private DocumentListener docListener;
+    private TableModelListener tableListener;
+    private ItemListener comboItemListener;
+    private TableModel tableModel;
+
+    private PathnameTablePanel includePathPanel;
+    private TableModel parsePathTableModel;
+    private TableModelListener parsePathTableListener;
+
+    private List<ComboBoxItem> itemList;
+    private ComboBoxItemComparator comparator;
+    private ResourceFile parentUserFile;
+    private boolean saveAsInProgress;
+    private boolean initialBuild = true;
+
+    private boolean userDefined = false;
+    private String currentProfileName = null;
+
+    public ClangParseDialog(GCPPPlugin plugin)
+    {
+        super("Parse C/C++ Source (Clang Powered)", false, true, true, false);
+        this.plugin = plugin;
+    }
+
+    public void setupForDisplay()
+    {
+        if (!initialBuild)
+        {
+            toFront();
+            return;
+        }
+
+        itemList = new ArrayList<>();
+        comparator = new ComboBoxItemComparator();
+        addWorkPanel(buildMainPanel());
+        addDismissButton();
+        createActions();
+        notifyContextChanged();
+
+        // Restore saved profile selection
+        if (currentProfileName != null)
+        {
+            for (int i = 0; i < itemList.size(); i++)
+            {
+                ComboBoxItem item = itemList.get(i);
+                if (userDefined == item.isUserDefined &&
+                    currentProfileName.equals(item.file.getName()))
+                {
+                    comboBox.setSelectedIndex(i);
+                    break;
+                }
+            }
+        }
+    }
+
+    public void writeState(SaveState saveState)
+    {
+        if (!initialBuild)
+        {
+            ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+            currentProfileName = item.file.getName();
+            userDefined = item.isUserDefined;
+        }
+        saveState.putString(CURRENT_PROFILE, currentProfileName);
+        saveState.putBoolean(USER_DEFINED, userDefined);
+    }
+
+    public void readState(SaveState saveState)
+    {
+        currentProfileName = saveState.getString(CURRENT_PROFILE, null);
+        if (currentProfileName != null)
+            userDefined = saveState.getBoolean(USER_DEFINED, true);
+    }
+
+    public void closeProfile()
+    {
+        if (initialBuild)
+            return;
+        ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+        if (item != null && item.isChanged)
+            processItemChanged(item);
+    }
+
+    @Override
+    protected TaskScheduler getTaskScheduler()
+    {
+        return super.getTaskScheduler();
+    }
+
+    private JPanel buildMainPanel()
+    {
+        initialBuild = true;
+
+        mainPanel = new JPanel(new BorderLayout(10, 5));
+
+        comboModel = new DefaultComboBoxModel<>();
+        populateComboBox();
+
+        comboBox = new GhidraComboBox<>(comboModel);
+        comboItemListener = this::selectionChanged;
+        comboBox.getAccessibleContext().setAccessibleName("Parse Configurations");
+        comboBox.addItemListener(comboItemListener);
+
+        JPanel cPanel = new JPanel(new BorderLayout());
+        cPanel.setBorder(BorderFactory.createTitledBorder("Parse Configuration"));
+        cPanel.add(comboBox);
+        JPanel comboPanel = new JPanel(new BorderLayout());
+        comboPanel.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
+        comboPanel.add(cPanel);
+
+        // Source files panel — editable, add to bottom, ordered
+        pathPanel = new PathnameTablePanel(null, true, false, true);
+        pathPanel.setBorder(BorderFactory.createTitledBorder("Source files to parse"));
+        String importDir = Preferences.getProperty(LAST_IMPORT_C_DIRECTORY);
+        if (importDir == null)
+        {
+            importDir = Preferences.getProperty(Preferences.LAST_PATH_DIRECTORY);
+            if (importDir != null)
+                Preferences.setProperty(LAST_IMPORT_C_DIRECTORY, importDir);
+        }
+        pathPanel.setFileChooserProperties("Choose Source Files", LAST_IMPORT_C_DIRECTORY,
+            GhidraFileChooserMode.FILES_AND_DIRECTORIES, true,
+            new ExtensionFileFilter(new String[]{"h"}, "C Header Files"));
+
+        // Render missing files in red
+        pathPanel.getTable().setDefaultRenderer(String.class, new GTableCellRenderer()
+        {
+            @Override
+            public Component getTableCellRendererComponent(GTableCellRenderingData data)
+            {
+                JLabel label = (JLabel) super.getTableCellRendererComponent(data);
+                Object value = data.getValue();
+                String pathName = (value == null ? "" : ((String) value).trim());
+
+                if (pathName.isEmpty() || pathName.startsWith("#"))
+                    return label;
+
+                boolean fileExists = new File(pathName).exists();
+                if (!fileExists)
+                    fileExists = doesFileExist(pathName);
+
+                label.setText(pathName);
+                if (!fileExists)
+                    label.setForeground(getErrorForegroundColor(data.isSelected()));
+
+                return label;
+            }
+        });
+
+        tableListener = e -> {
+            ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+            item.isChanged = !initialBuild;
+            notifyContextChanged();
+        };
+        tableModel = pathPanel.getTable().getModel();
+        tableModel.addTableModelListener(tableListener);
+
+        // Include paths panel — editable, add to bottom, ordered
+        includePathPanel = new PathnameTablePanel(null, true, false, true);
+        includePathPanel.setBorder(BorderFactory.createTitledBorder("Include paths"));
+        includePathPanel.setFileChooserProperties("Choose Include Directory", LAST_IMPORT_C_DIRECTORY,
+            GhidraFileChooserMode.DIRECTORIES_ONLY, true, null);
+
+        parsePathTableListener = e -> {
+            ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+            item.isChanged = !initialBuild;
+            notifyContextChanged();
+            pathPanel.getTable().repaint();
+        };
+        parsePathTableModel = includePathPanel.getTable().getModel();
+        parsePathTableModel.addTableModelListener(parsePathTableListener);
+
+        // Parse options panel
+        JPanel optionsPanel = new JPanel(new BorderLayout());
+        optionsPanel.setBorder(BorderFactory.createTitledBorder("Parse Options"));
+        parseOptionsField = new JTextArea(5, 70);
+        JScrollPane pane = new JScrollPane(parseOptionsField);
+        pane.getViewport().setPreferredSize(new Dimension(300, 200));
+        optionsPanel.add(pane, BorderLayout.CENTER);
+
+        // Architecture panel
+        JPanel archPanel = new JPanel(new BorderLayout());
+        archPanel.setBorder(BorderFactory.createTitledBorder("Program Architecture:"));
+        archPanel.add(new GLabel(" ", SwingConstants.RIGHT));
+        languagePanel = buildLanguagePanel();
+        archPanel.add(languagePanel);
+
+        // Parse buttons
+        parseButton = new JButton("Parse to Program");
+        parseButton.addActionListener(ev -> doParse(false));
+        parseButton.setToolTipText("Parse files and add data types to current program");
+        addButton(parseButton);
+
+        parseToFileButton = new JButton("Parse to File...");
+        parseToFileButton.addActionListener(ev -> doParse(true));
+        parseToFileButton.setToolTipText("Parse files and output to archive file");
+        addButton(parseToFileButton);
+
+        // Assemble layout
+        mainPanel.add(comboPanel, BorderLayout.NORTH);
+
+        includePathPanel.setPreferredSize(new Dimension(pathPanel.getPreferredSize().width, 200));
+        JSplitPane optionsPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, includePathPanel, optionsPanel);
+        optionsPane.setResizeWeight(0.50);
+
+        pathPanel.setPreferredSize(new Dimension(pathPanel.getPreferredSize().width, 200));
+        JSplitPane outerPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, pathPanel, optionsPane);
+        outerPane.setResizeWeight(0.50);
+
+        mainPanel.add(outerPane, BorderLayout.CENTER);
+        mainPanel.add(archPanel, BorderLayout.SOUTH);
+
+        if (comboBox.getSelectedItem() != null)
+            loadProfile();
+
+        initialBuild = false;
+        return mainPanel;
+    }
+
+    private boolean doesFileExist(String pathName)
+    {
+        String[] paths = includePathPanel.getPaths();
+        for (String path : paths)
+        {
+            File file = new File(path, pathName);
+            if (file.exists())
+                return true;
+        }
+        return false;
+    }
+
+    private JComponent buildLanguagePanel()
+    {
+        languageTextField = new JTextField();
+        languageTextField.setEditable(false);
+        languageTextField.setFocusable(false);
+
+        languageButton = new BrowseButton();
+        languageButton.addActionListener(e -> {
+            SetLanguageDialog dialog = new SetLanguageDialog(plugin.getTool(), languageIDString,
+                compilerIDString, "Select Program Architecture for File DataType Archive");
+            LanguageID languageId = dialog.getLanguageDescriptionID();
+            CompilerSpecID compilerSpecId = dialog.getCompilerSpecDescriptionID();
+            if (languageId == null || compilerSpecId == null)
+                return;
+
+            String newLanguageIDString = languageId.getIdAsString();
+            String newCompilerIDString = compilerSpecId.getIdAsString();
+
+            if (!Objects.equals(newLanguageIDString, languageIDString) ||
+                !Objects.equals(newCompilerIDString, compilerIDString))
+            {
+                itemChanged();
+            }
+
+            languageIDString = newLanguageIDString;
+            compilerIDString = newCompilerIDString;
+            updateArchitectureDescription();
+        });
+
+        updateArchitectureDescription();
+
+        languageButton.setName("Set Processor Architecture");
+        Gui.registerFont(languageButton, Font.BOLD);
+
+        JPanel panel = new JPanel(new BorderLayout());
+        panel.add(languageTextField, BorderLayout.CENTER);
+        panel.add(languageButton, BorderLayout.EAST);
+        return panel;
+    }
+
+    private void updateArchitectureDescription()
+    {
+        String description = "64/32 (primarily for backward compatibility)";
+
+        if (languageIDString != null)
+        {
+            StringBuilder buf = new StringBuilder();
+            buf.append(languageIDString);
+            buf.append("  /  ");
+            buf.append(compilerIDString != null ? compilerIDString : "none");
+            description = buf.toString();
+        }
+
+        languageTextField.setText(description);
+    }
+
+    private void selectionChanged(ItemEvent e)
+    {
+        if (e.getStateChange() == ItemEvent.SELECTED)
+        {
+            loadProfile();
+            return;
+        }
+
+        ComboBoxItem item = (ComboBoxItem) e.getItem();
+        if (!item.isChanged || saveAsInProgress || initialBuild)
+            return;
+
+        if (item.isUserDefined)
+        {
+            if (OptionDialog.showOptionDialog(rootPanel, "Save Changes to Profile?",
+                "Profile " + item.file.getName() + " has changed.\nDo you want to save your changes?",
+                "Yes", OptionDialog.QUESTION_MESSAGE) == OptionDialog.OPTION_ONE)
+            {
+                save(item);
+            }
+        }
+        else
+        {
+            if (OptionDialog.showOptionDialog(rootPanel, "Save Changes to Another Profile?",
+                "You have made changes to the default profile " + item.file.getName() +
+                    ",\nhowever, updating default profiles is not allowed." +
+                    "\nDo you want to save your changes to another profile?",
+                "Yes", OptionDialog.QUESTION_MESSAGE) == OptionDialog.OPTION_ONE)
+            {
+                saveAs(item);
+            }
+        }
+    }
+
+    private void processItemChanged(ComboBoxItem item)
+    {
+        if (item.isUserDefined)
+        {
+            if (OptionDialog.showOptionDialog(rootPanel, "Save Changes to Profile?",
+                "Profile " + item.file.getName() + " has changed.\nDo you want to save your changes?",
+                "Yes", OptionDialog.QUESTION_MESSAGE) == OptionDialog.OPTION_ONE)
+            {
+                save(item);
+            }
+        }
+        else
+        {
+            if (OptionDialog.showOptionDialog(rootPanel, "Save Changes to Another Profile?",
+                "You have made changes to the default profile " + item.file.getName() +
+                    ",\nhowever, updating default profiles is not allowed." +
+                    "\nDo you want to save your changes to another profile?",
+                "Yes", OptionDialog.QUESTION_MESSAGE) == OptionDialog.OPTION_ONE)
+            {
+                saveAs(item);
+            }
+        }
+    }
+
+    private void addDocumentListener()
+    {
+        if (docListener == null)
+        {
+            docListener = new DocumentListener()
+            {
+                @Override
+                public void changedUpdate(DocumentEvent e) { itemChanged(); }
+
+                @Override
+                public void insertUpdate(DocumentEvent e) { itemChanged(); }
+
+                @Override
+                public void removeUpdate(DocumentEvent e) { itemChanged(); }
+            };
+        }
+        parseOptionsField.getDocument().addDocumentListener(docListener);
+    }
+
+    private void itemChanged()
+    {
+        ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+        if (item == null)
+            return;
+        item.isChanged = true;
+        notifyContextChanged();
+    }
+
+    private void createActions()
+    {
+        saveAction = new DockingAction("Save Profile", plugin.getName())
+        {
+            @Override
+            public void actionPerformed(ActionContext context)
+            {
+                save((ComboBoxItem) comboBox.getSelectedItem());
+            }
+
+            @Override
+            public boolean isEnabledForContext(ActionContext context)
+            {
+                ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+                return item != null && item.isChanged && item.isUserDefined;
+            }
+        };
+        Icon icon = Icons.SAVE_ICON;
+        String saveGroup = "save";
+        saveAction.setMenuBarData(new MenuData(new String[]{"Save"}, icon, saveGroup));
+        saveAction.setToolBarData(new ToolBarData(icon, saveGroup));
+        saveAction.setDescription("Save profile");
+        addAction(saveAction);
+
+        saveAsAction = new DockingAction("Save Profile As", plugin.getName())
+        {
+            @Override
+            public void actionPerformed(ActionContext context)
+            {
+                saveAs((ComboBoxItem) comboBox.getSelectedItem());
+            }
+
+            @Override
+            public boolean isEnabledForContext(ActionContext context)
+            {
+                return true;
+            }
+        };
+        icon = Icons.SAVE_AS_ICON;
+        saveAsAction.setMenuBarData(new MenuData(new String[]{"Save As..."}, icon, saveGroup));
+        saveAsAction.setToolBarData(new ToolBarData(icon, saveGroup));
+        saveAsAction.setDescription("Save profile to new name");
+        addAction(saveAsAction);
+
+        clearAction = new DockingAction("Clear Profile", plugin.getName())
+        {
+            @Override
+            public void actionPerformed(ActionContext context) { clear(); }
+
+            @Override
+            public boolean isEnabledForContext(ActionContext context) { return true; }
+        };
+        icon = Icons.CLEAR_ICON;
+        String clearGroup = "clear";
+        clearAction.setMenuBarData(new MenuData(new String[]{"Clear Profile"}, icon, clearGroup));
+        clearAction.setToolBarData(new ToolBarData(icon, clearGroup));
+        clearAction.setDescription("Clear profile");
+        addAction(clearAction);
+
+        refreshAction = new DockingAction("Refresh User Profiles", plugin.getName())
+        {
+            @Override
+            public void actionPerformed(ActionContext context) { refresh(); }
+
+            @Override
+            public boolean isEnabledForContext(ActionContext context) { return true; }
+        };
+        icon = Icons.REFRESH_ICON;
+        String refreshGroup = "refresh";
+        refreshAction.setMenuBarData(new MenuData(new String[]{"Refresh"}, icon, refreshGroup));
+        refreshAction.setToolBarData(new ToolBarData(icon, refreshGroup));
+        refreshAction.setDescription("Refresh list of user profiles");
+        addAction(refreshAction);
+
+        deleteAction = new DockingAction("Delete Profile", plugin.getName())
+        {
+            @Override
+            public void actionPerformed(ActionContext context) { delete(); }
+
+            @Override
+            public boolean isEnabledForContext(ActionContext context)
+            {
+                ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+                return item != null && item.isUserDefined;
+            }
+        };
+        icon = Icons.DELETE_ICON;
+        String deleteGroup = "Xdelete";
+        deleteAction.setMenuBarData(new MenuData(new String[]{"Delete"}, icon, deleteGroup));
+        deleteAction.setToolBarData(new ToolBarData(icon, deleteGroup));
+        deleteAction.setDescription("Delete profile");
+        addAction(deleteAction);
+    }
+
+    private void refresh()
+    {
+        ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+        if (item != null && item.isChanged)
+            processItemChanged(item);
+        comboBox.removeItemListener(comboItemListener);
+        itemList.clear();
+        comboModel.removeAllElements();
+        populateComboBox();
+        comboBox.addItemListener(comboItemListener);
+        if (itemList.contains(item))
+            comboBox.setSelectedItem(item);
+        else
+            loadProfile();
+    }
+
+    private void clear()
+    {
+        pathPanel.clear();
+        includePathPanel.clear();
+        parseOptionsField.setText("");
+        ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+        if (item != null)
+            item.isChanged = true;
+    }
+
+    private void save(ComboBoxItem item)
+    {
+        if (!item.isUserDefined)
+        {
+            saveAs(item);
+        }
+        else
+        {
+            writeProfile(item.file);
+            item.isChanged = false;
+            notifyContextChanged();
+        }
+    }
+
+    private void saveAs(ComboBoxItem item)
+    {
+        InputDialog d = new InputDialog("Enter Profile Name", "Profile Name");
+        plugin.getTool().showDialog(d, getComponent());
+
+        String name = d.getValue();
+        if (name != null && !name.isEmpty())
+        {
+            if (!name.endsWith(FILE_EXTENSION))
+                name = name + FILE_EXTENSION;
+
+            ResourceFile file = new ResourceFile(parentUserFile, name);
+            if (file.equals(item.file))
+            {
+                save(item);
+                return;
+            }
+
+            if (file.exists())
+            {
+                if (OptionDialog.showOptionDialog(rootPanel, "Overwrite Existing File?",
+                    "The file " + file.getAbsolutePath() +
+                        " already exists.\nDo you want to overwrite it?",
+                    "Yes", OptionDialog.QUESTION_MESSAGE) != OptionDialog.OPTION_ONE)
+                {
+                    return;
+                }
+                file.delete();
+            }
+
+            saveAsInProgress = true;
+            ComboBoxItem newItem = new ComboBoxItem(file, true);
+            if (itemList.contains(newItem))
+            {
+                itemList.remove(newItem);
+                comboModel.removeElement(newItem);
+            }
+            int index = Collections.binarySearch(itemList, newItem, comparator);
+            if (index < 0)
+                index = -index - 1;
+
+            itemList.add(index, newItem);
+            writeProfile(newItem.file);
+            newItem.isChanged = false;
+            item.isChanged = false;
+            try
+            {
+                comboModel.insertElementAt(newItem, index);
+                comboBox.setSelectedIndex(index);
+            }
+            finally
+            {
+                saveAsInProgress = false;
+            }
+            notifyContextChanged();
+        }
+    }
+
+    private void loadProfile()
+    {
+        ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+        if (item == null)
+            return;
+
+        if (docListener != null)
+            parseOptionsField.getDocument().removeDocumentListener(docListener);
+        tableModel.removeTableModelListener(tableListener);
+        parsePathTableModel.removeTableModelListener(parsePathTableListener);
+
+        item.isChanged = false;
+
+        StringBuilder sb = new StringBuilder();
+        List<String> pathList = new ArrayList<>();
+        List<String> includeList = new ArrayList<>();
+        String langString = null;
+        String compileString = null;
+
+        try
+        {
+            BufferedReader br = new BufferedReader(new InputStreamReader(item.file.getInputStream()));
+            String line;
+
+            // Section 1: Source files
+            while ((line = br.readLine()) != null && !line.trim().isEmpty())
+                pathList.add(line.trim());
+
+            // Section 2: Parse options
+            while ((line = br.readLine()) != null && !line.trim().isEmpty())
+                sb.append(line.trim()).append("\n");
+
+            // Section 3: Include paths
+            while ((line = br.readLine()) != null && !line.trim().isEmpty())
+                includeList.add(line.trim());
+
+            // Section 4: Language ID
+            while ((line = br.readLine()) != null)
+            {
+                line = line.trim();
+                if (!line.isEmpty())
+                {
+                    langString = line;
+                    break;
+                }
+            }
+
+            // Section 5: Compiler spec ID
+            while ((line = br.readLine()) != null)
+            {
+                line = line.trim();
+                if (!line.isEmpty())
+                {
+                    compileString = line;
+                    break;
+                }
+            }
+
+            br.close();
+
+            pathPanel.setPaths(pathList.toArray(new String[0]));
+            includePathPanel.setPaths(includeList.toArray(new String[0]));
+            parseOptionsField.setText(sb.toString());
+            languageIDString = langString;
+            compilerIDString = compileString;
+            updateArchitectureDescription();
+        }
+        catch (FileNotFoundException e)
+        {
+            Msg.showInfo(getClass(), getComponent(), "File Not Found",
+                "Could not find file\n" + item.file.getAbsolutePath());
+        }
+        catch (IOException e)
+        {
+            Msg.showError(this, getComponent(), "Error Loading Profile",
+                "Exception occurred while reading file\n" + item.file.getAbsolutePath() + ": " + e);
+        }
+        finally
+        {
+            addDocumentListener();
+            tableModel.addTableModelListener(tableListener);
+            parsePathTableModel.addTableModelListener(parsePathTableListener);
+            notifyContextChanged();
+        }
+    }
+
+    private void writeProfile(ResourceFile outputFile)
+    {
+        try
+        {
+            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputFile.getOutputStream()));
+
+            // Section 1: Source files
+            for (String path : pathPanel.getPaths())
+            {
+                writer.write(path.trim());
+                writer.newLine();
+            }
+            writer.newLine();
+
+            // Section 2: Parse options
+            String optStr = parseOptionsField.getText();
+            StringTokenizer st = new StringTokenizer(optStr, "\n");
+            while (st.hasMoreTokens())
+            {
+                writer.write(st.nextToken());
+                writer.newLine();
+            }
+            writer.newLine();
+
+            // Section 3: Include paths
+            for (String path : includePathPanel.getPaths())
+            {
+                writer.write(path.trim());
+                writer.newLine();
+            }
+            writer.newLine();
+
+            // Section 4: Language ID
+            if (languageIDString != null)
+                writer.write(languageIDString);
+            writer.newLine();
+            writer.newLine();
+
+            // Section 5: Compiler spec ID
+            if (compilerIDString != null)
+                writer.write(compilerIDString);
+            writer.newLine();
+            writer.newLine();
+
+            writer.close();
+        }
+        catch (IOException e)
+        {
+            Msg.showError(this, getComponent(), "Error Writing Profile",
+                "Writing profile " + outputFile.getName() + " failed", e);
+        }
+    }
+
+    private void delete()
+    {
+        ComboBoxItem item = (ComboBoxItem) comboBox.getSelectedItem();
+        if (item.isUserDefined)
+        {
+            if (OptionDialog.showOptionDialog(getComponent(), "Delete Profile?",
+                "Are you sure you want to delete profile " + item.getName(), "Delete",
+                OptionDialog.QUESTION_MESSAGE) == OptionDialog.OPTION_ONE)
+            {
+                item.file.delete();
+                itemList.remove(item);
+                comboModel.removeElement(item);
+            }
+        }
+    }
+
+    private void doParse(boolean parseToFile)
+    {
+        clearStatusText();
+        String options = parseOptionsField.getText();
+        String[] includePaths = includePathPanel.getPaths();
+        String[] paths = pathPanel.getPaths();
+
+        if (paths.length == 0)
+        {
+            Msg.showInfo(getClass(), rootPanel, "Source Files Not Specified",
+                "Please specify source files to parse.");
+            return;
+        }
+
+        if (parseToFile)
+        {
+            if (languageIDString == null || compilerIDString == null)
+            {
+                Msg.showWarn(getClass(), rootPanel, "Program Architecture not Specified",
+                    "A Program Architecture must be specified in order to parse to a file.");
+                return;
+            }
+
+            File file = getSaveFile();
+            if (file != null)
+            {
+                plugin.parse(paths, includePaths, options, languageIDString, compilerIDString,
+                    file.getAbsolutePath());
+            }
+            return;
+        }
+
+        plugin.parse(paths, includePaths, options);
+    }
+
+    private void populateComboBox()
+    {
+        // Find built-in profiles from Ghidra's Base module (not our extension module)
+        ResourceFile systemProfileDir = findSystemProfileDir();
+        if (systemProfileDir != null)
+            addToComboModel(systemProfileDir, false);
+
+        parentUserFile = new ResourceFile(plugin.getUserProfileDir());
+        addToComboModel(parentUserFile, true);
+    }
+
+    /**
+     * Searches Ghidra application root directories for the Base module's
+     * parserprofiles data directory. We can't use Application.getModuleDataSubDirectory()
+     * because that only searches the current extension module.
+     */
+    private ResourceFile findSystemProfileDir()
+    {
+        for (ResourceFile root : Application.getApplicationRootDirectories())
+        {
+            ResourceFile profileDir = new ResourceFile(root, "Features/Base/data/" + PROFILE_DIR);
+            if (profileDir.isDirectory())
+                return profileDir;
+        }
+        // Fallback: try the current module in case profiles are bundled with the extension
+        try
+        {
+            return Application.getModuleDataSubDirectory(PROFILE_DIR);
+        }
+        catch (IOException e)
+        {
+            return null;
+        }
+    }
+
+    private void addToComboModel(ResourceFile parent, boolean isUserDefined)
+    {
+        ResourceFile[] children = parent.listFiles();
+        if (children == null)
+            return;
+
+        List<ResourceFile> sorted = Arrays.asList(children);
+        Collections.sort(sorted);
+        for (ResourceFile resourceFile : sorted)
+        {
+            if (resourceFile.getName().startsWith("."))
+                continue;
+            ComboBoxItem item = new ComboBoxItem(resourceFile, isUserDefined);
+            comboModel.addElement(item);
+            itemList.add(item);
+        }
+    }
+
+    private File getSaveFile()
+    {
+        GhidraFileChooser fileChooser = new GhidraFileChooser(rootPanel);
+        fileChooser.setTitle("Choose Save Archive File");
+        fileChooser.setApproveButtonText("Choose Save Archive File");
+        fileChooser.setApproveButtonToolTipText("Choose filename for archive");
+        fileChooser.setLastDirectoryPreference(Preferences.LAST_EXPORT_DIRECTORY);
+
+        File file = fileChooser.getSelectedFile();
+        fileChooser.dispose();
+        if (file == null)
+            return null;
+
+        File parent = file.getParentFile();
+        if (parent != null)
+            Preferences.setProperty(Preferences.LAST_EXPORT_DIRECTORY, parent.getAbsolutePath());
+
+        String name = file.getName();
+        if (!name.endsWith(FileDataTypeManager.SUFFIX))
+            file = new File(file.getParentFile(), name + FileDataTypeManager.SUFFIX);
+
+        if (!file.exists())
+            return file;
+
+        int choice = OptionDialog.showOptionDialog(rootPanel, "Overwrite Existing File?",
+            "The file " + file.getAbsolutePath() +
+                " already exists.\nDo you want to overwrite it?",
+            "Yes", OptionDialog.QUESTION_MESSAGE);
+
+        if (choice != OptionDialog.OPTION_ONE)
+            return null;
+
+        try
+        {
+            PackedDatabase.delete(file);
+        }
+        catch (IOException e)
+        {
+            Msg.showError(this, mainPanel, "Archive Overwrite Failed", e.getMessage());
+            return null;
+        }
+        return file;
+    }
+
+    @Override
+    protected void dismissCallback()
+    {
+        close();
+    }
+
+    @Override
+    public void close()
+    {
+        cancelCurrentTask();
+        super.close();
+    }
+
+    // Inner classes
+
+    static class ComboBoxItem
+    {
+        final ResourceFile file;
+        final boolean isUserDefined;
+        boolean isChanged;
+
+        ComboBoxItem(ResourceFile file, boolean isUserDefined)
+        {
+            this.file = file;
+            this.isUserDefined = isUserDefined;
+        }
+
+        @Override
+        public String toString()
+        {
+            return file.getName() + (isUserDefined ? "" : " (Default)");
+        }
+
+        public String getName()
+        {
+            return file.getName();
+        }
+
+        @Override
+        public boolean equals(Object obj)
+        {
+            if (this == obj) return true;
+            if (obj == null || getClass() != obj.getClass()) return false;
+            ComboBoxItem item = (ComboBoxItem) obj;
+            return file.equals(item.file) && isUserDefined == item.isUserDefined;
+        }
+
+        @Override
+        public int hashCode()
+        {
+            return Objects.hash(file, isUserDefined);
+        }
+    }
+
+    private static class ComboBoxItemComparator implements Comparator<ComboBoxItem>
+    {
+        @Override
+        public int compare(ComboBoxItem item1, ComboBoxItem item2)
+        {
+            if (item1.isUserDefined == item2.isUserDefined)
+                return item1.getName().compareToIgnoreCase(item2.getName());
+            return item1.isUserDefined ? 1 : -1;
+        }
+    }
+}
diff --git a/Ghidra/RuntimeScripts/support/launch.properties b/Ghidra/RuntimeScripts/support/launch.properties
index 4608a4bbad..9855cd4470 100644
--- a/Ghidra/RuntimeScripts/support/launch.properties
+++ b/Ghidra/RuntimeScripts/support/launch.properties
@@ -175,3 +175,9 @@ VMARGS=--sun-misc-unsafe-memory-access=allow
 # Prevents PyGhidra from restoring sys.modules to its original state after a PyGhidra script is run.
 # Used to help debug potential issues that might arise from mucking with sys.modules.
 #VMARGS=-Dpyghidra.sys.modules.restore.disable=true
+
+# Panama FFI upcalls crash with JIT compilation — libclang's visitor pattern uses native-to-Java
+# callbacks (upcalls) that are incompatible with JIT-compiled code on all tested JDK versions.
+# The workaround is -Xint (interpreter mode), which makes Ghidra noticeably slower.
+# This is a JDK bug, not something we can fix on our side.
+#VMARGS=-Xint
-- 
2.45.1