tools/offsets-tool/MonoAotOffsetsDumper.cs

   1 // -*- indent-tabs-mode:nil -*-
   2 using System;
   3 using System.Collections.Generic;
   4 using System.IO;
   5 using System.Linq;
   6 using System.Text.RegularExpressions;
   7 using CppSharp.AST;
   8 using CppSharp.AST.Extensions;
   9 using CppSharp.Parser;
  10
  11 namespace CppSharp
  12 {
  13     /**
  14      * This tool dumps the offsets of structures used in the Mono VM needed
  15      * by the AOT compiler for cross-compiling code to target platforms
  16      * different than the host the compiler is being invoked on.
  17      */
  18     static class MonoAotOffsetsDumper
  19     {
  20         static string MonoDir = @"";
  21
  22         static List<string> Abis = new List<string> ();
  23         static string OutputDir;
  24         static string OutputFile;
  25
  26         static string AndroidNdkPath = @"";
  27         static string EmscriptenSdkPath = @"";
  28         static string TargetDir = @"";
  29         static bool GenIOS;
  30         static bool GenAndroid;
  31
  32         public enum TargetPlatform
  33         {
  34             Android,
  35             iOS,
  36             WatchOS,
  37             OSX,
  38             WASM
  39         }
  40
  41         public class Target
  42         {
  43             public Target()
  44             {
  45                 Defines = new List<string>();
  46                 Arguments = new List<string>();
  47             }
  48
  49             public Target(Target target)
  50             {
  51                 Platform = target.Platform;
  52                 Triple = target.Triple;
  53                 Build = target.Build;
  54                 Defines = target.Defines;
  55                 Arguments = target.Arguments;
  56             }
  57
  58             public TargetPlatform Platform;
  59             public string Triple;
  60             public string Build;
  61             public List<string> Defines;
  62             public List<string> Arguments;
  63         };
  64
  65         public static List<Target> Targets = new List<Target>();
  66
  67         public static IEnumerable<Target> AndroidTargets
  68         {
  69             get { return Targets.Where ((t) => t.Platform == TargetPlatform.Android); }
  70         }
  71
  72         public static IEnumerable<Target> DarwinTargets
  73         {
  74             get
  75             {
  76                 return Targets.Where ((t) => t.Platform == TargetPlatform.iOS ||
  77                     t.Platform == TargetPlatform.WatchOS ||
  78                                       t.Platform == TargetPlatform.OSX);
  79             }
  80         }
  81
  82         public static IEnumerable<Target> iOSTargets
  83         {
  84             get
  85             {
  86                 return Targets.Where ((t) => t.Platform == TargetPlatform.iOS);
  87             }
  88         }
  89
  90         public static void SetupAndroidTargets()
  91         {
  92             Targets.Add (new Target {
  93                 Platform = TargetPlatform.Android,
  94                 Triple = "i686-none-linux-android",
  95                 Defines = { "TARGET_X86" }
  96             });
  97
  98             Targets.Add (new Target {
  99                 Platform = TargetPlatform.Android,
 100                 Triple = "x86_64-none-linux-android",
 101                 Defines = { "TARGET_AMD64" }
 102             });
 103
 104             Targets.Add (new Target {
 105                 Platform = TargetPlatform.Android,
 106                 Triple = "armv5-none-linux-androideabi",
 107                 Defines = { "TARGET_ARM", "ARM_FPU_VFP", "HAVE_ARMV5" }
 108             });
 109
 110             Targets.Add (new Target {
 111                 Platform = TargetPlatform.Android,
 112                 Triple = "armv7-none-linux-androideabi",
 113                 Defines = { "TARGET_ARM", "ARM_FPU_VFP", "HAVE_ARMV5", "HAVE_ARMV6",
 114                     "HAVE_ARMV7"
 115                 }
 116             });
 117
 118             Targets.Add (new Target {
 119                 Platform = TargetPlatform.Android,
 120                 Triple = "aarch64-v8a-linux-android",
 121                 Defines = { "TARGET_ARM64" }
 122             });
 123
 124             /*Targets.Add(new Target {
 125                     Platform = TargetPlatform.Android,
 126                     Triple = "mipsel-none-linux-android",
 127                     Defines = { "TARGET_MIPS", "__mips__" }
 128                 });*/
 129
 130             foreach (var target in AndroidTargets)
 131                 target.Defines.AddRange (new string[] { "HOST_ANDROID",
 132                     "TARGET_ANDROID", "MONO_CROSS_COMPILE", "USE_MONO_CTX"
 133                 });
 134         }
 135
 136         public static void SetupiOSTargets()
 137         {
 138             Targets.Add(new Target {
 139                 Platform = TargetPlatform.iOS,
 140                 Triple = "arm-apple-darwin10",
 141                 Build = "target7",
 142                 Defines = { "TARGET_ARM", "ARM_FPU_VFP", "HAVE_ARMV5" }
 143             });
 144
 145             Targets.Add(new Target {
 146                 Platform = TargetPlatform.iOS,
 147                 Triple = "aarch64-apple-darwin10",
 148                 Build = "target64",
 149                 Defines = { "TARGET_ARM64" }
 150             });
 151
 152             foreach (var target in iOSTargets) {
 153                 target.Defines.AddRange (new string[] { "HOST_DARWIN",
 154                     "TARGET_IOS", "TARGET_MACH", "MONO_CROSS_COMPILE", "USE_MONO_CTX",
 155                     "_XOPEN_SOURCE"
 156                 });
 157             }
 158
 159             Targets.Add(new Target {
 160                 Platform = TargetPlatform.WatchOS,
 161                 Triple = "armv7k-apple-darwin",
 162                 Build = "targetwatch",
 163                 Defines = { "TARGET_ARM", "ARM_FPU_VFP", "HAVE_ARMV5" }
 164             });
 165
 166             foreach (var target in DarwinTargets) {
 167                 target.Defines.AddRange (new string[] { "HOST_DARWIN",
 168                     "TARGET_IOS", "TARGET_MACH", "MONO_CROSS_COMPILE", "USE_MONO_CTX",
 169                     "_XOPEN_SOURCE"
 170                 });
 171             }
 172         }
 173
 174         public static void SetupOtherTargets()
 175         {
 176             if (Abis.Count != 1) {
 177                 Console.WriteLine ("Exactly --abi= argument is required.");
 178                 Environment.Exit (1);
 179             }
 180             string abi = Abis [0];
 181             if (abi == "i386-apple-darwin13.0.0") {
 182                 Targets.Add(new Target {
 183                         Platform = TargetPlatform.OSX,
 184                         Triple = "i386-apple-darwin13.0.0",
 185                         Build = "",
 186                         Defines = { "TARGET_X86" },
 187                 });
 188             } else if (abi == "wasm32-unknown-unknown") {
 189                 Targets.Add(new Target {
 190                         Platform = TargetPlatform.WASM,
 191                         Triple = "wasm32-wasm32-unknown-unknown",
 192                         Build = "",
 193                         Defines = { "TARGET_WASM" },
 194                 });
 195             } else {
 196                 Console.WriteLine ($"Unsupported abi: {abi}.");
 197                 Environment.Exit (1);
 198             }
 199         }
 200
 201         static bool GetParentSubDirectoryPath(string parent, out string subdir)
 202         {
 203             var directory = Directory.GetParent(Directory.GetCurrentDirectory());
 204
 205             while (directory != null) {
 206                 var path = Path.Combine(directory.FullName, parent);
 207
 208                 if (Directory.Exists (path)) {
 209                     subdir = path;
 210                     return true;
 211                 }
 212
 213                 directory = directory.Parent;
 214             }
 215
 216             subdir = null;
 217             return false;
 218         }
 219
 220         public static int Main(string[] args)
 221         {
 222             ParseCommandLineArgs(args);
 223
 224             if (GenAndroid)
 225                 SetupAndroidTargets();
 226
 227             if (GenIOS)
 228                 SetupiOSTargets();
 229
 230             if (Targets.Count == 0)
 231                 SetupOtherTargets ();
 232
 233             foreach (var target in Targets)
 234              {
 235                 if (Abis.Any() && !Abis.Any (target.Triple.Contains))
 236                     continue;
 237
 238                 Console.WriteLine();
 239                 Console.WriteLine("Processing triple: {0}", target.Triple);
 240
 241                 var options = new DriverOptions();
 242
 243                 var driver = new Driver(options);
 244
 245                 Setup(driver, target);
 246                 driver.Setup();
 247
 248                 BuildParseOptions(driver, target);
 249                 if (!driver.ParseCode())
 250                     return 1;
 251
 252                 Dump(driver.Context.ASTContext, driver.Context.TargetInfo, target);
 253             }
 254             return 0;
 255         }
 256
 257         static void BuildParseOptions(Driver driver, Target target)
 258         {
 259             foreach (var header in driver.Options.Headers)
 260             {
 261                 var source = driver.Project.AddFile(header);
 262                 source.Options = driver.BuildParserOptions(source);
 263
 264                 if (header.Contains ("mini"))
 265                     continue;
 266
 267                 source.Options.AddDefines ("HAVE_SGEN_GC");
 268                 source.Options.AddDefines ("HAVE_MOVING_COLLECTOR");
 269                 source.Options.AddDefines("MONO_GENERATING_OFFSETS");
 270             }
 271         }
 272
 273         static void ParseCommandLineArgs(string[] args)
 274         {
 275             var showHelp = false;
 276
 277             var options = new Mono.Options.OptionSet () {
 278                 { "abi=", "ABI triple to generate", v => Abis.Add(v) },
 279                 { "o|out=", "output directory", v => OutputDir = v },
 280                 { "outfile=", "output directory", v => OutputFile = v },
 281                 { "android-ndk=", "Path to Android NDK", v => AndroidNdkPath = v },
 282                 { "emscripten-sdk=", "Path to emscripten sdk", v => EmscriptenSdkPath = v },
 283                 { "targetdir=", "Path to the directory containing the mono build", v =>TargetDir = v },
 284                 { "mono=", "include directory", v => MonoDir = v },
 285                 { "gen-ios", "generate iOS offsets", v => GenIOS = v != null },
 286                 { "gen-android", "generate Android offsets", v => GenAndroid = v != null },
 287                 { "h|help",  "show this message and exit",  v => showHelp = v != null },
 288             };
 289
 290             try {
 291                 options.Parse (args);
 292             }
 293             catch (Mono.Options.OptionException e) {
 294                 Console.WriteLine (e.Message);
 295                 Environment.Exit(0);
 296             }
 297
 298             if (showHelp)
 299             {
 300                 // Print usage and exit.
 301                 Console.WriteLine("{0} <options>",
 302                     AppDomain.CurrentDomain.FriendlyName);
 303                 options.WriteOptionDescriptions (Console.Out);
 304                 Environment.Exit(0);
 305             }
 306         }
 307
 308         static void Setup(Driver driver, Target target)
 309         {
 310             var options = driver.Options;
 311             options.DryRun = true;
 312             options.LibraryName = "Mono";
 313
 314             var parserOptions = driver.ParserOptions;
 315             parserOptions.Verbose = false;
 316             parserOptions.MicrosoftMode = false;
 317             parserOptions.AddArguments("-xc");
 318             parserOptions.AddArguments("-std=gnu99");
 319             parserOptions.AddDefines("CPPSHARP");
 320             parserOptions.AddDefines("MONO_GENERATING_OFFSETS");
 321
 322             foreach (var define in target.Defines)
 323                 parserOptions.AddDefines(define);
 324
 325             SetupToolchainPaths(driver, target);
 326
 327             SetupMono(driver, target);
 328         }
 329
 330         static void SetupMono(Driver driver, Target target)
 331         {
 332             string targetBuild;
 333             switch (target.Platform) {
 334             case TargetPlatform.Android:
 335                 if (string.IsNullOrEmpty (TargetDir)) {
 336                     Console.Error.WriteLine ("The --targetdir= option is required when targeting android.");
 337                     Environment.Exit (1);
 338                 }
 339                 if (string.IsNullOrEmpty (MonoDir)) {
 340                     Console.Error.WriteLine ("The --mono= option is required when targeting android.");
 341                     Environment.Exit (1);
 342                 }
 343                 if (string.IsNullOrEmpty(AndroidNdkPath)) {
 344                     Console.WriteLine("The --android-ndk= option is required when targeting android");
 345                     Environment.Exit (1);
 346                 }
 347                 if (Abis.Count != 1) {
 348                     Console.Error.WriteLine ("Exactly one --abi= argument is required when targeting android.");
 349                     Environment.Exit (1);
 350                 }
 351                 targetBuild = TargetDir;
 352                 break;
 353             case TargetPlatform.WatchOS:
 354             case TargetPlatform.iOS: {
 355                 if (string.IsNullOrEmpty (TargetDir)) {
 356                     Console.Error.WriteLine ("The --targetdir= option is required when targeting ios.");
 357                     Environment.Exit (1);
 358                 }
 359                 if (string.IsNullOrEmpty (MonoDir)) {
 360                     Console.Error.WriteLine ("The --mono= option is required when targeting ios.");
 361                     Environment.Exit (1);
 362                 }
 363                 targetBuild = TargetDir;
 364                 break;
 365             }
 366             case TargetPlatform.OSX:
 367             case TargetPlatform.WASM:
 368                 if (MonoDir == "") {
 369                     Console.Error.WriteLine ("The --mono= option is required when targeting osx.");
 370                     Environment.Exit (1);
 371                 }
 372                 if (!string.IsNullOrEmpty (TargetDir)) {
 373                     targetBuild = TargetDir;
 374                 } else {
 375                     targetBuild = ".";
 376                 }
 377                 break;
 378             default:
 379                 throw new ArgumentOutOfRangeException ();
 380             }
 381
 382             if (!Directory.Exists(targetBuild))
 383                 throw new Exception(string.Format("Could not find the target build directory: {0}", targetBuild));
 384
 385             var includeDirs = new[]
 386             {
 387                 targetBuild,
 388                 Path.Combine(targetBuild, "mono", "eglib"),
 389                 MonoDir,
 390                 Path.Combine(MonoDir, "mono"),
 391                 Path.Combine(MonoDir, "mono", "mini"),
 392                 Path.Combine(MonoDir, "mono", "eglib")
 393             };
 394
 395             foreach (var inc in includeDirs)
 396                 driver.ParserOptions.AddIncludeDirs(inc);
 397
 398             var filesToParse = new[]
 399             {
 400                 Path.Combine(MonoDir, "mono", "metadata", "metadata-cross-helpers.c"),
 401                 Path.Combine(MonoDir, "mono", "mini", "mini-cross-helpers.c"),
 402             };
 403
 404             foreach (var file in filesToParse)
 405                 driver.Options.Headers.Add(file);
 406         }
 407
 408         static void SetupMSVC(Driver driver, string triple)
 409         {
 410             var parserOptions = driver.ParserOptions;
 411
 412             parserOptions.Abi = Parser.AST.CppAbi.Microsoft;
 413             parserOptions.MicrosoftMode = true;
 414
 415             var systemIncludeDirs = new[]
 416             {
 417                 @"C:\Program Files (x86)\Windows Kits\8.1\Include\um",
 418                 @"C:\Program Files (x86)\Windows Kits\8.1\Include\shared"
 419             };
 420
 421             foreach (var inc in systemIncludeDirs)
 422                 parserOptions.AddSystemIncludeDirs(inc);
 423
 424             parserOptions.AddDefines("HOST_WIN32");
 425         }
 426
 427         static void SetupToolchainPaths(Driver driver, Target target)
 428         {
 429             switch (target.Platform) {
 430             case TargetPlatform.Android:
 431                 SetupAndroidNDK(driver, target);
 432                 break;
 433             case TargetPlatform.iOS:
 434             case TargetPlatform.WatchOS:
 435             case TargetPlatform.OSX:
 436                 SetupXcode(driver, target);
 437                 break;
 438             case TargetPlatform.WASM:
 439                 if (EmscriptenSdkPath == "") {
 440                     Console.Error.WriteLine ("The --emscripten-sdk= option is required when targeting wasm.");
 441                     Environment.Exit (1);
 442                 }
 443                 string include_dir = Path.Combine (EmscriptenSdkPath, "system", "include", "libc");
 444                 if (!Directory.Exists (include_dir)) {
 445                     Console.Error.WriteLine ($"emscripten include directory {include_dir} does not exist.");
 446                     Environment.Exit (1);
 447                 }
 448                 var parserOptions = driver.ParserOptions;
 449                 parserOptions.NoBuiltinIncludes = true;
 450                 parserOptions.NoStandardIncludes = true;
 451                 parserOptions.TargetTriple = target.Triple;
 452                 parserOptions.AddSystemIncludeDirs(include_dir);
 453                 break;
 454             default:
 455                 throw new ArgumentOutOfRangeException ();
 456             }
 457         }
 458
 459         static string GetArchFromTriple(string triple)
 460         {
 461             if (triple.Contains("mips"))
 462                 return "mips";
 463
 464             if (triple.Contains("arm64") || triple.Contains("aarch64"))
 465                 return "arm64";
 466
 467             if (triple.Contains("arm"))
 468                 return "arm";
 469
 470             if (triple.Contains("i686"))
 471                 return "x86";
 472
 473             if (triple.Contains("x86_64"))
 474                 return "x86_64";
 475
 476             throw  new Exception("Unknown architecture from triple: " + triple);
 477         }
 478
 479         static string GetXcodeToolchainPath()
 480         {
 481             var toolchains = Directory.EnumerateDirectories("/Applications", "Xcode*")
 482                 .ToList();
 483             toolchains.Sort();
 484
 485             var toolchainPath = toolchains.LastOrDefault();
 486             if (toolchainPath == null)
 487                 throw new Exception("Could not find a valid Xcode SDK");
 488
 489             return toolchainPath;
 490         }
 491
 492         static string GetXcodeBuiltinIncludesFolder()
 493         {
 494             var toolchainPath = GetXcodeToolchainPath();
 495
 496             var toolchains = Directory.EnumerateDirectories(Path.Combine(toolchainPath,
 497                 "Contents/Developer/Toolchains")).ToList();
 498             toolchains.Sort();
 499
 500             toolchainPath = toolchains.LastOrDefault();
 501             if (toolchainPath == null)
 502                 throw new Exception("Could not find a valid Xcode toolchain");
 503
 504             var includePaths = Directory.EnumerateDirectories(Path.Combine(toolchainPath,
 505                 "usr/lib/clang")).ToList();
 506             var includePath = includePaths.LastOrDefault();
 507
 508             if (includePath == null)
 509                 throw new Exception("Could not find a valid Clang include folder");
 510
 511             return Path.Combine(includePath, "include");
 512         }
 513
 514         static string GetXcodeiOSIncludesFolder()
 515         {
 516             var toolchainPath = GetXcodeToolchainPath();
 517
 518             var sdkPaths = Directory.EnumerateDirectories(Path.Combine(toolchainPath,
 519                 "Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs")).ToList();
 520             var sdkPath = sdkPaths.LastOrDefault();
 521
 522             if (sdkPath == null)
 523                 throw new Exception("Could not find a valid iPhone SDK");
 524
 525             return Path.Combine(sdkPath, "usr/include");
 526         }
 527
 528         static string GetXcodeOSXIncludesFolder()
 529         {
 530             var toolchainPath = GetXcodeToolchainPath();
 531
 532             var sdkPaths = Directory.EnumerateDirectories(Path.Combine(toolchainPath,
 533                 "Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs")).ToList();
 534             var sdkPath = sdkPaths.LastOrDefault();
 535
 536             if (sdkPath == null)
 537                 throw new Exception("Could not find a valid OSX SDK");
 538
 539             return Path.Combine(sdkPath, "usr/include");
 540         }
 541
 542         static string GetXcodeWatchOSIncludesFolder()
 543         {
 544             var toolchainPath = GetXcodeToolchainPath();
 545
 546             var sdkPaths = Directory.EnumerateDirectories(Path.Combine(toolchainPath,
 547                 "Contents/Developer/Platforms/WatchOS.platform/Developer/SDKs")).ToList();
 548             var sdkPath = sdkPaths.LastOrDefault();
 549
 550             if (sdkPath == null)
 551                 throw new Exception("Could not find a valid WatchOS SDK");
 552
 553             return Path.Combine(sdkPath, "usr/include");
 554         }
 555
 556         static void SetupXcode(Driver driver, Target target)
 557         {
 558             var parserOptions = driver.ParserOptions;
 559
 560             var builtinsPath = GetXcodeBuiltinIncludesFolder();
 561             string includePath;
 562
 563             switch (target.Platform) {
 564             case TargetPlatform.iOS:
 565                 includePath = GetXcodeiOSIncludesFolder();
 566                 break;
 567             case TargetPlatform.WatchOS:
 568                 includePath = GetXcodeWatchOSIncludesFolder();
 569                 break;
 570             case TargetPlatform.OSX:
 571                 includePath = GetXcodeOSXIncludesFolder();
 572                 break;
 573             default:
 574                 throw new ArgumentOutOfRangeException ();
 575             }
 576
 577             parserOptions.AddSystemIncludeDirs(builtinsPath);
 578             parserOptions.AddSystemIncludeDirs(includePath);
 579
 580             parserOptions.NoBuiltinIncludes = true;
 581             parserOptions.NoStandardIncludes = true;
 582             parserOptions.TargetTriple = target.Triple;
 583         }
 584
 585         static string GetAndroidHostToolchainPath()
 586         {
 587             var toolchains = Directory.EnumerateDirectories(
 588                 Path.Combine(AndroidNdkPath, "toolchains"), "llvm*").ToList();
 589             toolchains.Sort();
 590
 591             var toolchainPath = toolchains.LastOrDefault();
 592             if (toolchainPath == null)
 593                 throw new Exception("Could not find a valid NDK host toolchain");
 594
 595             toolchains = Directory.EnumerateDirectories(Path.Combine(toolchainPath,
 596                 "prebuilt")).ToList();
 597             toolchains.Sort();
 598
 599             toolchainPath = toolchains.LastOrDefault();
 600             if (toolchainPath == null)
 601                 throw new Exception("Could not find a valid NDK host toolchain");
 602
 603             return toolchainPath;
 604         }
 605
 606         static string GetAndroidBuiltinIncludesFolder()
 607         {
 608             var toolchainPath = GetAndroidHostToolchainPath();
 609
 610             string clangToolchainPath = Path.Combine(toolchainPath, "lib64", "clang");
 611             if (!Directory.Exists (clangToolchainPath))
 612                 clangToolchainPath = Path.Combine(toolchainPath, "lib", "clang");
 613
 614             string includePath = null;
 615             if (Directory.Exists (clangToolchainPath)) {
 616                 var includePaths = Directory.EnumerateDirectories(clangToolchainPath).ToList();
 617                 includePath = includePaths.LastOrDefault();
 618             }
 619             if (includePath == null)
 620                 throw new Exception("Could not find a valid Clang include folder");
 621
 622             return Path.Combine(includePath, "include");
 623         }
 624
 625         static void SetupAndroidNDK(Driver driver, Target target)
 626         {
 627             var options = driver.Options;
 628             var parserOptions = driver.ParserOptions;
 629
 630             var builtinsPath = GetAndroidBuiltinIncludesFolder();
 631             parserOptions.AddSystemIncludeDirs(builtinsPath);
 632
 633             const int androidNdkApiLevel = 21;
 634
 635             var toolchainPath = Path.Combine(AndroidNdkPath, "platforms",
 636                 "android-" + androidNdkApiLevel, "arch-" + GetArchFromTriple(target.Triple),
 637                 "usr", "include");
 638             parserOptions.AddSystemIncludeDirs(toolchainPath);
 639
 640             parserOptions.NoBuiltinIncludes = true;
 641             parserOptions.NoStandardIncludes = true;
 642             parserOptions.TargetTriple = target.Triple;
 643         }
 644
 645         static uint GetTypeAlign(ParserTargetInfo target, ParserIntType type)
 646         {
 647             switch (type)
 648             {
 649                 case ParserIntType.SignedChar:
 650                 case ParserIntType.UnsignedChar:
 651                     return target.CharAlign;
 652                 case ParserIntType.SignedShort:
 653                 case ParserIntType.UnsignedShort:
 654                     return target.ShortAlign;
 655                 case ParserIntType.SignedInt:
 656                 case ParserIntType.UnsignedInt:
 657                     return target.IntAlign;
 658                 case ParserIntType.SignedLong:
 659                 case ParserIntType.UnsignedLong:
 660                     return target.LongAlign;
 661                 case ParserIntType.SignedLongLong:
 662                 case ParserIntType.UnsignedLongLong:
 663                     return target.LongLongAlign;
 664                 default:
 665                     throw new Exception("Type has no alignment");
 666             }
 667         }
 668
 669         static uint GetTypeSize(ParserTargetInfo target, ParserIntType type)
 670         {
 671             switch (type)
 672             {
 673                 case ParserIntType.SignedChar:
 674                 case ParserIntType.UnsignedChar:
 675                     return target.CharWidth;
 676                 case ParserIntType.SignedShort:
 677                 case ParserIntType.UnsignedShort:
 678                     return target.ShortWidth;
 679                 case ParserIntType.SignedInt:
 680                 case ParserIntType.UnsignedInt:
 681                     return target.IntWidth;
 682                 case ParserIntType.SignedLong:
 683                 case ParserIntType.UnsignedLong:
 684                     return target.LongWidth;
 685                 case ParserIntType.SignedLongLong:
 686                 case ParserIntType.UnsignedLongLong:
 687                     return target.LongLongWidth;
 688                 default:
 689                     throw new Exception("Type has no size");
 690             }
 691         }
 692
 693         static string GetTargetPlatformDefine(TargetPlatform target)
 694         {
 695             switch (target) {
 696             case TargetPlatform.Android:
 697                 return "TARGET_ANDROID";
 698             case TargetPlatform.iOS:
 699                 return "TARGET_IOS";
 700             case TargetPlatform.WatchOS:
 701                 return "TARGET_WATCHOS";
 702             case TargetPlatform.OSX:
 703                 return "TARGET_OSX";
 704             case TargetPlatform.WASM:
 705                 return "TARGET_WASM";
 706             default:
 707                 throw new ArgumentOutOfRangeException ();
 708             }
 709         }
 710
 711         static void Dump(ASTContext ctx, ParserTargetInfo targetInfo, Target target)
 712         {
 713             string targetFile;
 714
 715             if (!string.IsNullOrEmpty (OutputFile)) {
 716                 targetFile = OutputFile;
 717             } else {
 718                 targetFile = target.Triple;
 719
 720                 if (!string.IsNullOrEmpty (OutputDir))
 721                     targetFile = Path.Combine (OutputDir, targetFile);
 722
 723                 targetFile += ".h";
 724             }
 725
 726             using (var writer = new StreamWriter(targetFile))
 727             //using (var writer = Console.Out)
 728             {
 729                 writer.WriteLine("#ifndef USED_CROSS_COMPILER_OFFSETS");
 730                 writer.WriteLine("#ifdef {0}", target.Defines[0]);
 731                 writer.WriteLine ("#ifdef {0}", GetTargetPlatformDefine (target.Platform));
 732                 writer.WriteLine("#ifndef HAVE_BOEHM_GC");
 733                 writer.WriteLine("#define HAS_CROSS_COMPILER_OFFSETS");
 734                 writer.WriteLine("#if defined (USE_CROSS_COMPILE_OFFSETS) || defined (MONO_CROSS_COMPILE)");
 735                 writer.WriteLine("#if !defined (DISABLE_METADATA_OFFSETS)");
 736                 writer.WriteLine("#define USED_CROSS_COMPILER_OFFSETS");
 737
 738                 DumpAligns(writer, targetInfo);
 739                 DumpSizes(writer, targetInfo);
 740                 DumpMetadataOffsets(writer, ctx, target);
 741
 742                 writer.WriteLine("#endif //disable metadata check");
 743
 744                 DumpJITOffsets(writer, ctx);
 745
 746                 writer.WriteLine("#endif //cross compiler checks");
 747                 writer.WriteLine("#endif //gc check");
 748                 writer.WriteLine("#endif //os check");
 749                 writer.WriteLine("#endif //arch check");
 750                 writer.WriteLine("#endif //USED_CROSS_COMPILER_OFFSETS check");
 751             }
 752
 753             Console.WriteLine("Generated offsets file: {0}", targetFile);
 754         }
 755
 756         static void DumpAligns(TextWriter writer, ParserTargetInfo target)
 757         {
 758             var aligns = new[]
 759             {
 760                 new { Name = "gint8", Align = target.CharAlign},
 761                 new { Name = "gint16", Align = target.ShortAlign},
 762                 new { Name = "gint32", Align = target.IntAlign},
 763                 new { Name = "gint64", Align = GetTypeAlign(target, target.Int64Type)},
 764                 new { Name = "float", Align = target.FloatAlign},
 765                 new { Name = "double", Align = target.DoubleAlign},
 766                 new { Name = "gpointer", Align = GetTypeAlign(target, target.IntPtrType)},
 767             };
 768
 769             // Write the alignment info for the basic types.
 770             foreach (var align in aligns)
 771                 writer.WriteLine("DECL_ALIGN2({0},{1})", align.Name, align.Align / 8);
 772         }
 773
 774         static void DumpSizes(TextWriter writer, ParserTargetInfo target)
 775         {
 776             var sizes = new[]
 777             {
 778                 new { Name = "gint8", Size = target.CharWidth},
 779                 new { Name = "gint16", Size = target.ShortWidth},
 780                 new { Name = "gint32", Size = target.IntWidth},
 781                 new { Name = "gint64", Size = GetTypeSize(target, target.Int64Type)},
 782                 new { Name = "float", Size = target.FloatWidth},
 783                 new { Name = "double", Size = target.DoubleWidth},
 784                 new { Name = "gpointer", Size = GetTypeSize(target, target.IntPtrType)},
 785             };
 786
 787             // Write the size info for the basic types.
 788             foreach (var size in sizes)
 789                 writer.WriteLine("DECL_SIZE2({0},{1})", size.Name, size.Size / 8);
 790         }
 791
 792         static Class GetClassFromTypedef(ITypedDecl typedef)
 793         {
 794             var type = typedef.Type.Desugar() as TagType;
 795             if (type == null)
 796                 return null;
 797
 798             var @class = type.Declaration as Class;
 799
 800             return @class.IsIncomplete ?
 801                 (@class.CompleteDeclaration as Class) : @class;
 802         }
 803
 804         static void DumpClasses(TextWriter writer, ASTContext ctx, IEnumerable<string> types,
 805             bool optional = false)
 806         {
 807             foreach (var @struct in types)
 808             {
 809                 var @class = ctx.FindCompleteClass(@struct);
 810                 if (@class == null)
 811                     @class = ctx.FindCompleteClass("_" + @struct);
 812
 813                 if (@class == null)
 814                 {
 815                     var typedef = ctx.FindTypedef(@struct).FirstOrDefault(
 816                         decl => !decl.IsIncomplete);
 817
 818                     if (typedef != null)
 819                         @class = GetClassFromTypedef(typedef);
 820                 }
 821
 822                 if (@class == null && optional)
 823                     continue;
 824
 825                 if (@class == null)
 826                     throw new Exception("Expected to find struct definition for " + @struct);
 827
 828                 DumpStruct(writer, @class);
 829             }
 830         }
 831
 832         static void DumpMetadataOffsets(TextWriter writer, ASTContext ctx, Target target)
 833         {
 834             var types = new List<string>
 835             {
 836                 "MonoObject",
 837                 "MonoClass",
 838                 "MonoVTable",
 839                 "MonoDelegate",
 840                 "MonoInternalThread",
 841                 "MonoMulticastDelegate",
 842                 "MonoTransparentProxy",
 843                 "MonoRealProxy",
 844                 "MonoRemoteClass",
 845                 "MonoArray",
 846                 "MonoArrayBounds",
 847                 "MonoSafeHandle",
 848                 "MonoHandleRef",
 849                 "MonoComInteropProxy",
 850                 "MonoString",
 851                 "MonoException",
 852                 "MonoTypedRef",
 853                 "MonoThreadsSync",
 854                 "SgenThreadInfo",
 855                 "SgenClientThreadInfo",
 856                 "MonoProfilerCallContext"
 857             };
 858
 859             DumpClasses(writer, ctx, types);
 860         }
 861
 862         static void DumpJITOffsets(TextWriter writer, ASTContext ctx)
 863         {
 864             writer.WriteLine("#ifndef DISABLE_JIT_OFFSETS");
 865             writer.WriteLine("#define USED_CROSS_COMPILER_OFFSETS");
 866
 867             var types = new[]
 868             {
 869                 "MonoLMF",
 870                 "MonoMethodRuntimeGenericContext",
 871                 "MonoJitTlsData",
 872                 "MonoGSharedVtMethodRuntimeInfo",
 873                 "MonoContinuation",
 874                 "MonoContext",
 875                 "MonoDelegateTrampInfo",
 876             };
 877
 878             DumpClasses(writer, ctx, types);
 879
 880             var optionalTypes = new[]
 881             {
 882                 "GSharedVtCallInfo",
 883                 "SeqPointInfo",
 884                 "DynCallArgs",
 885                 "MonoLMFTramp",
 886                 "CallContext",
 887                 "MonoFtnDesc"
 888             };
 889
 890             DumpClasses(writer, ctx, optionalTypes, optional: true);
 891
 892             writer.WriteLine("#endif //disable jit check");
 893         }
 894
 895         static void DumpStruct(TextWriter writer, Class @class)
 896         {
 897             var name = @class.Name;
 898             if (name.StartsWith ("_", StringComparison.Ordinal))
 899                 name = name.Substring (1);
 900
 901             writer.WriteLine ("DECL_SIZE2({0},{1})", name, @class.Layout.Size);
 902
 903             foreach (var field in @class.Fields)
 904             {
 905                 if (field.IsBitField) continue;
 906
 907                 if (name == "SgenThreadInfo" && field.Name == "regs")
 908                     continue;
 909
 910                 var layout = @class.Layout.Fields.First(f => f.FieldPtr == field.OriginalPtr);
 911
 912                 writer.WriteLine("DECL_OFFSET2({0},{1},{2})", name, field.Name,
 913                     layout.Offset);
 914             }
 915         }
 916     }
 917 }