utils/TableGen/LLVMCConfigurationEmitter.cpp

   1 //===- LLVMCConfigurationEmitter.cpp - Generate LLVMC config ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open
   6 // Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This tablegen backend is responsible for emitting LLVMC configuration code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "LLVMCConfigurationEmitter.h"
  15 #include "Record.h"
  16
  17 #include "llvm/ADT/IntrusiveRefCntPtr.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/StringExtras.h"
  20 #include "llvm/ADT/StringMap.h"
  21 #include "llvm/ADT/StringSet.h"
  22 #include "llvm/Support/Streams.h"
  23
  24 #include <algorithm>
  25 #include <cassert>
  26 #include <functional>
  27 #include <stdexcept>
  28 #include <string>
  29
  30 using namespace llvm;
  31
  32 namespace {
  33
  34 //===----------------------------------------------------------------------===//
  35 /// Typedefs
  36
  37 typedef std::vector<Record*> RecordVector;
  38 typedef std::vector<std::string> StrVector;
  39
  40 //===----------------------------------------------------------------------===//
  41 /// Constants
  42
  43 // Indentation strings.
  44 const char * Indent1 = "    ";
  45 const char * Indent2 = "        ";
  46 const char * Indent3 = "            ";
  47 const char * Indent4 = "                ";
  48
  49 // Default help string.
  50 const char * DefaultHelpString = "NO HELP MESSAGE PROVIDED";
  51
  52 // Name for the "sink" option.
  53 const char * SinkOptionName = "AutoGeneratedSinkOption";
  54
  55 //===----------------------------------------------------------------------===//
  56 /// Helper functions
  57
  58 int InitPtrToInt(const Init* ptr) {
  59   const IntInit& val = dynamic_cast<const IntInit&>(*ptr);
  60   return val.getValue();
  61 }
  62
  63 const std::string& InitPtrToString(const Init* ptr) {
  64   const StringInit& val = dynamic_cast<const StringInit&>(*ptr);
  65   return val.getValue();
  66 }
  67
  68 const ListInit& InitPtrToList(const Init* ptr) {
  69   const ListInit& val = dynamic_cast<const ListInit&>(*ptr);
  70   return val;
  71 }
  72
  73 const DagInit& InitPtrToDag(const Init* ptr) {
  74   const DagInit& val = dynamic_cast<const DagInit&>(*ptr);
  75   return val;
  76 }
  77
  78 // checkNumberOfArguments - Ensure that the number of args in d is
  79 // less than or equal to min_arguments, otherwise throw an exception.
  80 void checkNumberOfArguments (const DagInit* d, unsigned min_arguments) {
  81   if (d->getNumArgs() < min_arguments)
  82     throw "Property " + d->getOperator()->getAsString()
  83       + " has too few arguments!";
  84 }
  85
  86 // isDagEmpty - is this DAG marked with an empty marker?
  87 bool isDagEmpty (const DagInit* d) {
  88   return d->getOperator()->getAsString() == "empty";
  89 }
  90
  91 //===----------------------------------------------------------------------===//
  92 /// Back-end specific code
  93
  94 // A command-line option can have one of the following types:
  95 //
  96 // Alias - an alias for another option.
  97 //
  98 // Switch - a simple switch without arguments, e.g. -O2
  99 //
 100 // Parameter - an option that takes one(and only one) argument, e.g. -o file,
 101 // --output=file
 102 //
 103 // ParameterList - same as Parameter, but more than one occurence
 104 // of the option is allowed, e.g. -lm -lpthread
 105 //
 106 // Prefix - argument is everything after the prefix,
 107 // e.g. -Wa,-foo,-bar, -DNAME=VALUE
 108 //
 109 // PrefixList - same as Prefix, but more than one option occurence is
 110 // allowed.
 111
 112 namespace OptionType {
 113   enum OptionType { Alias, Switch,
 114                     Parameter, ParameterList, Prefix, PrefixList};
 115 }
 116
 117 bool IsListOptionType (OptionType::OptionType t) {
 118   return (t == OptionType::ParameterList || t == OptionType::PrefixList);
 119 }
 120
 121 // Code duplication here is necessary because one option can affect
 122 // several tools and those tools may have different actions associated
 123 // with this option. GlobalOptionDescriptions are used to generate
 124 // the option registration code, while ToolOptionDescriptions are used
 125 // to generate tool-specific code.
 126
 127 /// OptionDescription - Base class for option descriptions.
 128 struct OptionDescription {
 129   OptionType::OptionType Type;
 130   std::string Name;
 131
 132   OptionDescription(OptionType::OptionType t = OptionType::Switch,
 133                     const std::string& n = "")
 134   : Type(t), Name(n)
 135   {}
 136
 137   const char* GenTypeDeclaration() const {
 138     switch (Type) {
 139     case OptionType::Alias:
 140       return "cl::alias";
 141     case OptionType::PrefixList:
 142     case OptionType::ParameterList:
 143       return "cl::list<std::string>";
 144     case OptionType::Switch:
 145       return "cl::opt<bool>";
 146     case OptionType::Parameter:
 147     case OptionType::Prefix:
 148     default:
 149       return "cl::opt<std::string>";
 150     }
 151   }
 152
 153   // Escape commas and other symbols not allowed in the C++ variable
 154   // names. Makes it possible to use options with names like "Wa,"
 155   // (useful for prefix options).
 156   std::string EscapeVariableName(const std::string& Var) const {
 157     std::string ret;
 158     for (unsigned i = 0; i != Var.size(); ++i) {
 159       if (Var[i] == ',') {
 160         ret += "_comma_";
 161       }
 162       else {
 163         ret.push_back(Var[i]);
 164       }
 165     }
 166     return ret;
 167   }
 168
 169   std::string GenVariableName() const {
 170     const std::string& EscapedName = EscapeVariableName(Name);
 171     switch (Type) {
 172     case OptionType::Alias:
 173      return "AutoGeneratedAlias" + EscapedName;
 174     case OptionType::Switch:
 175       return "AutoGeneratedSwitch" + EscapedName;
 176     case OptionType::Prefix:
 177       return "AutoGeneratedPrefix" + EscapedName;
 178     case OptionType::PrefixList:
 179       return "AutoGeneratedPrefixList" + EscapedName;
 180     case OptionType::Parameter:
 181       return "AutoGeneratedParameter" + EscapedName;
 182     case OptionType::ParameterList:
 183     default:
 184       return "AutoGeneratedParameterList" + EscapedName;
 185     }
 186   }
 187
 188 };
 189
 190 // Global option description.
 191
 192 namespace GlobalOptionDescriptionFlags {
 193   enum GlobalOptionDescriptionFlags { Required = 0x1 };
 194 }
 195
 196 struct GlobalOptionDescription : public OptionDescription {
 197   std::string Help;
 198   unsigned Flags;
 199
 200   // We need to provide a default constructor because
 201   // StringMap can only store DefaultConstructible objects.
 202   GlobalOptionDescription() : OptionDescription(), Flags(0)
 203   {}
 204
 205   GlobalOptionDescription (OptionType::OptionType t, const std::string& n,
 206                            const std::string& h = DefaultHelpString)
 207     : OptionDescription(t, n), Help(h), Flags(0)
 208   {}
 209
 210   bool isRequired() const {
 211     return Flags & GlobalOptionDescriptionFlags::Required;
 212   }
 213   void setRequired() {
 214     Flags |= GlobalOptionDescriptionFlags::Required;
 215   }
 216
 217   /// Merge - Merge two option descriptions.
 218   void Merge (const GlobalOptionDescription& other)
 219   {
 220     if (other.Type != Type)
 221       throw "Conflicting definitions for the option " + Name + "!";
 222
 223     if (Help == DefaultHelpString)
 224       Help = other.Help;
 225     else if (other.Help != DefaultHelpString) {
 226       llvm::cerr << "Warning: more than one help string defined for option "
 227         + Name + "\n";
 228     }
 229
 230     Flags |= other.Flags;
 231   }
 232 };
 233
 234 /// GlobalOptionDescriptions - A GlobalOptionDescription array
 235 /// together with some flags affecting generation of option
 236 /// declarations.
 237 struct GlobalOptionDescriptions {
 238   typedef StringMap<GlobalOptionDescription> container_type;
 239   typedef container_type::const_iterator const_iterator;
 240
 241   /// Descriptions - A list of GlobalOptionDescriptions.
 242   container_type Descriptions;
 243   /// HasSink - Should the emitter generate a "cl::sink" option?
 244   bool HasSink;
 245
 246   const GlobalOptionDescription& FindOption(const std::string& OptName) const {
 247     const_iterator I = Descriptions.find(OptName);
 248     if (I != Descriptions.end())
 249       return I->second;
 250     else
 251       throw OptName + ": no such option!";
 252   }
 253
 254   // Insert new GlobalOptionDescription into GlobalOptionDescriptions list
 255   void insertDescription (const GlobalOptionDescription& o)
 256   {
 257     container_type::iterator I = Descriptions.find(o.Name);
 258     if (I != Descriptions.end()) {
 259       GlobalOptionDescription& D = I->second;
 260       D.Merge(o);
 261     }
 262     else {
 263       Descriptions[o.Name] = o;
 264     }
 265   }
 266
 267   // Support for STL-style iteration
 268   const_iterator begin() const { return Descriptions.begin(); }
 269   const_iterator end() const { return Descriptions.end(); }
 270 };
 271
 272
 273 // Tool-local option description.
 274
 275 // Properties without arguments are implemented as flags.
 276 namespace ToolOptionDescriptionFlags {
 277   enum ToolOptionDescriptionFlags { StopCompilation = 0x1,
 278                                     Forward = 0x2, UnpackValues = 0x4};
 279 }
 280 namespace OptionPropertyType {
 281   enum OptionPropertyType { AppendCmd, OutputSuffix };
 282 }
 283
 284 typedef std::pair<OptionPropertyType::OptionPropertyType, std::string>
 285 OptionProperty;
 286 typedef SmallVector<OptionProperty, 4> OptionPropertyList;
 287
 288 struct ToolOptionDescription : public OptionDescription {
 289   unsigned Flags;
 290   OptionPropertyList Props;
 291
 292   // StringMap can only store DefaultConstructible objects
 293   ToolOptionDescription() : OptionDescription(), Flags(0) {}
 294
 295   ToolOptionDescription (OptionType::OptionType t, const std::string& n)
 296     : OptionDescription(t, n)
 297   {}
 298
 299   // Various boolean properties
 300   bool isStopCompilation() const {
 301     return Flags & ToolOptionDescriptionFlags::StopCompilation;
 302   }
 303   void setStopCompilation() {
 304     Flags |= ToolOptionDescriptionFlags::StopCompilation;
 305   }
 306
 307   bool isForward() const {
 308     return Flags & ToolOptionDescriptionFlags::Forward;
 309   }
 310   void setForward() {
 311     Flags |= ToolOptionDescriptionFlags::Forward;
 312   }
 313
 314   bool isUnpackValues() const {
 315     return Flags & ToolOptionDescriptionFlags::UnpackValues;
 316   }
 317   void setUnpackValues() {
 318     Flags |= ToolOptionDescriptionFlags::UnpackValues;
 319   }
 320
 321   void AddProperty (OptionPropertyType::OptionPropertyType t,
 322                     const std::string& val)
 323   {
 324     Props.push_back(std::make_pair(t, val));
 325   }
 326 };
 327
 328 typedef StringMap<ToolOptionDescription> ToolOptionDescriptions;
 329
 330 // Tool information record
 331
 332 namespace ToolFlags {
 333   enum ToolFlags { Join = 0x1, Sink = 0x2 };
 334 }
 335
 336 struct ToolProperties : public RefCountedBase<ToolProperties> {
 337   std::string Name;
 338   Init* CmdLine;
 339   StrVector InLanguage;
 340   std::string OutLanguage;
 341   std::string OutputSuffix;
 342   unsigned Flags;
 343   ToolOptionDescriptions OptDescs;
 344
 345   // Various boolean properties
 346   void setSink()      { Flags |= ToolFlags::Sink; }
 347   bool isSink() const { return Flags & ToolFlags::Sink; }
 348   void setJoin()      { Flags |= ToolFlags::Join; }
 349   bool isJoin() const { return Flags & ToolFlags::Join; }
 350
 351   // Default ctor here is needed because StringMap can only store
 352   // DefaultConstructible objects
 353   ToolProperties() : Flags(0) {}
 354   ToolProperties (const std::string& n) : Name(n), Flags(0) {}
 355 };
 356
 357
 358 /// ToolPropertiesList - A list of Tool information records
 359 /// IntrusiveRefCntPtrs are used here because StringMap has no copy
 360 /// constructor (and we want to avoid copying ToolProperties anyway).
 361 typedef std::vector<IntrusiveRefCntPtr<ToolProperties> > ToolPropertiesList;
 362
 363
 364 /// CollectOptionProperties - Function object for iterating over a
 365 /// list (usually, a DAG) of option property records.
 366 class CollectOptionProperties {
 367 private:
 368   // Implementation details.
 369
 370   /// OptionPropertyHandler - a function that extracts information
 371   /// about a given option property from its DAG representation.
 372   typedef void (CollectOptionProperties::* OptionPropertyHandler)
 373   (const DagInit*);
 374
 375   /// OptionPropertyHandlerMap - A map from option property names to
 376   /// option property handlers
 377   typedef StringMap<OptionPropertyHandler> OptionPropertyHandlerMap;
 378
 379   static OptionPropertyHandlerMap optionPropertyHandlers_;
 380   static bool staticMembersInitialized_;
 381
 382   /// This is where the information is stored
 383
 384   /// toolProps_ -  Properties of the current Tool.
 385   ToolProperties* toolProps_;
 386   /// optDescs_ - OptionDescriptions table (used to register options
 387   /// globally).
 388   GlobalOptionDescription& optDesc_;
 389
 390 public:
 391
 392   explicit CollectOptionProperties(ToolProperties* TP,
 393                                    GlobalOptionDescription& OD)
 394     : toolProps_(TP), optDesc_(OD)
 395   {
 396     if (!staticMembersInitialized_) {
 397       optionPropertyHandlers_["append_cmd"] =
 398         &CollectOptionProperties::onAppendCmd;
 399       optionPropertyHandlers_["forward"] =
 400         &CollectOptionProperties::onForward;
 401       optionPropertyHandlers_["help"] =
 402         &CollectOptionProperties::onHelp;
 403       optionPropertyHandlers_["output_suffix"] =
 404         &CollectOptionProperties::onOutputSuffix;
 405       optionPropertyHandlers_["required"] =
 406         &CollectOptionProperties::onRequired;
 407       optionPropertyHandlers_["stop_compilation"] =
 408         &CollectOptionProperties::onStopCompilation;
 409       optionPropertyHandlers_["unpack_values"] =
 410         &CollectOptionProperties::onUnpackValues;
 411
 412       staticMembersInitialized_ = true;
 413     }
 414   }
 415
 416   /// operator() - Gets called for every option property; Just forwards
 417   /// to the corresponding property handler.
 418   void operator() (Init* i) {
 419     const DagInit& option_property = InitPtrToDag(i);
 420     const std::string& option_property_name
 421       = option_property.getOperator()->getAsString();
 422     OptionPropertyHandlerMap::iterator method
 423       = optionPropertyHandlers_.find(option_property_name);
 424
 425     if (method != optionPropertyHandlers_.end()) {
 426       OptionPropertyHandler h = method->second;
 427       (this->*h)(&option_property);
 428     }
 429     else {
 430       throw "Unknown option property: " + option_property_name + "!";
 431     }
 432   }
 433
 434 private:
 435
 436   /// Option property handlers --
 437   /// Methods that handle properties that are common for all types of
 438   /// options (like append_cmd, stop_compilation)
 439
 440   void onAppendCmd (const DagInit* d) {
 441     checkNumberOfArguments(d, 1);
 442     checkToolProps(d);
 443     const std::string& cmd = InitPtrToString(d->getArg(0));
 444
 445     toolProps_->OptDescs[optDesc_.Name].
 446       AddProperty(OptionPropertyType::AppendCmd, cmd);
 447   }
 448
 449   void onOutputSuffix (const DagInit* d) {
 450     checkNumberOfArguments(d, 1);
 451     checkToolProps(d);
 452     const std::string& suf = InitPtrToString(d->getArg(0));
 453
 454     if (toolProps_->OptDescs[optDesc_.Name].Type != OptionType::Switch)
 455       throw "Option " + optDesc_.Name
 456         + " can't have 'output_suffix' property since it isn't a switch!";
 457
 458     toolProps_->OptDescs[optDesc_.Name].AddProperty
 459       (OptionPropertyType::OutputSuffix, suf);
 460   }
 461
 462   void onForward (const DagInit* d) {
 463     checkNumberOfArguments(d, 0);
 464     checkToolProps(d);
 465     toolProps_->OptDescs[optDesc_.Name].setForward();
 466   }
 467
 468   void onHelp (const DagInit* d) {
 469     checkNumberOfArguments(d, 1);
 470     const std::string& help_message = InitPtrToString(d->getArg(0));
 471
 472     optDesc_.Help = help_message;
 473   }
 474
 475   void onRequired (const DagInit* d) {
 476     checkNumberOfArguments(d, 0);
 477     checkToolProps(d);
 478     optDesc_.setRequired();
 479   }
 480
 481   void onStopCompilation (const DagInit* d) {
 482     checkNumberOfArguments(d, 0);
 483     checkToolProps(d);
 484     if (optDesc_.Type != OptionType::Switch)
 485       throw std::string("Only options of type Switch can stop compilation!");
 486     toolProps_->OptDescs[optDesc_.Name].setStopCompilation();
 487   }
 488
 489   void onUnpackValues (const DagInit* d) {
 490     checkNumberOfArguments(d, 0);
 491     checkToolProps(d);
 492     toolProps_->OptDescs[optDesc_.Name].setUnpackValues();
 493   }
 494
 495   // Helper functions
 496
 497   /// checkToolProps - Throw an error if toolProps_ == 0.
 498   void checkToolProps(const DagInit* d) {
 499     if (!d)
 500       throw "Option property " + d->getOperator()->getAsString()
 501         + " can't be used in this context";
 502   }
 503
 504 };
 505
 506 CollectOptionProperties::OptionPropertyHandlerMap
 507 CollectOptionProperties::optionPropertyHandlers_;
 508
 509 bool CollectOptionProperties::staticMembersInitialized_ = false;
 510
 511
 512 /// processOptionProperties - Go through the list of option
 513 /// properties and call a corresponding handler for each.
 514 void processOptionProperties (const DagInit* d, ToolProperties* t,
 515                               GlobalOptionDescription& o) {
 516   checkNumberOfArguments(d, 2);
 517   DagInit::const_arg_iterator B = d->arg_begin();
 518   // Skip the first argument: it's always the option name.
 519   ++B;
 520   std::for_each(B, d->arg_end(), CollectOptionProperties(t, o));
 521 }
 522
 523 /// AddOption - A function object wrapper for
 524 /// processOptionProperties. Used by CollectProperties and
 525 /// CollectPropertiesFromOptionList.
 526 class AddOption {
 527 private:
 528   GlobalOptionDescriptions& OptDescs_;
 529   ToolProperties* ToolProps_;
 530
 531 public:
 532   explicit AddOption(GlobalOptionDescriptions& OD, ToolProperties* TP = 0)
 533     : OptDescs_(OD), ToolProps_(TP)
 534   {}
 535
 536   void operator()(const Init* i) {
 537     const DagInit& d = InitPtrToDag(i);
 538     checkNumberOfArguments(&d, 2);
 539
 540     const OptionType::OptionType Type =
 541       getOptionType(d.getOperator()->getAsString());
 542     const std::string& Name = InitPtrToString(d.getArg(0));
 543
 544     GlobalOptionDescription OD(Type, Name);
 545     if (Type != OptionType::Alias) {
 546       processOptionProperties(&d, ToolProps_, OD);
 547       if (ToolProps_) {
 548         ToolProps_->OptDescs[Name].Type = Type;
 549         ToolProps_->OptDescs[Name].Name = Name;
 550       }
 551     }
 552     else {
 553       OD.Help = InitPtrToString(d.getArg(1));
 554     }
 555     OptDescs_.insertDescription(OD);
 556   }
 557
 558 private:
 559   OptionType::OptionType getOptionType(const std::string& T) const {
 560     if (T == "alias_option")
 561       return OptionType::Alias;
 562     else if (T == "switch_option")
 563       return OptionType::Switch;
 564     else if (T == "parameter_option")
 565       return OptionType::Parameter;
 566     else if (T == "parameter_list_option")
 567       return OptionType::ParameterList;
 568     else if (T == "prefix_option")
 569       return OptionType::Prefix;
 570     else if (T == "prefix_list_option")
 571       return OptionType::PrefixList;
 572     else
 573       throw "Unknown option type: " + T + '!';
 574   }
 575 };
 576
 577
 578 /// CollectProperties - Function object for iterating over a list of
 579 /// tool property records.
 580 class CollectProperties {
 581 private:
 582
 583   // Implementation details
 584
 585   /// PropertyHandler - a function that extracts information
 586   /// about a given tool property from its DAG representation
 587   typedef void (CollectProperties::*PropertyHandler)(const DagInit*);
 588
 589   /// PropertyHandlerMap - A map from property names to property
 590   /// handlers.
 591   typedef StringMap<PropertyHandler> PropertyHandlerMap;
 592
 593   // Static maps from strings to CollectProperties methods("handlers")
 594   static PropertyHandlerMap propertyHandlers_;
 595   static bool staticMembersInitialized_;
 596
 597
 598   /// This is where the information is stored
 599
 600   /// toolProps_ -  Properties of the current Tool.
 601   ToolProperties& toolProps_;
 602   /// optDescs_ - OptionDescriptions table (used to register options
 603   /// globally).
 604   GlobalOptionDescriptions& optDescs_;
 605
 606 public:
 607
 608   explicit CollectProperties (ToolProperties& p, GlobalOptionDescriptions& d)
 609     : toolProps_(p), optDescs_(d)
 610   {
 611     if (!staticMembersInitialized_) {
 612       propertyHandlers_["cmd_line"] = &CollectProperties::onCmdLine;
 613       propertyHandlers_["in_language"] = &CollectProperties::onInLanguage;
 614       propertyHandlers_["join"] = &CollectProperties::onJoin;
 615       propertyHandlers_["out_language"] = &CollectProperties::onOutLanguage;
 616       propertyHandlers_["output_suffix"] = &CollectProperties::onOutputSuffix;
 617       propertyHandlers_["parameter_option"]
 618         = &CollectProperties::addOption;
 619       propertyHandlers_["parameter_list_option"] =
 620         &CollectProperties::addOption;
 621       propertyHandlers_["prefix_option"] = &CollectProperties::addOption;
 622       propertyHandlers_["prefix_list_option"] =
 623         &CollectProperties::addOption;
 624       propertyHandlers_["sink"] = &CollectProperties::onSink;
 625       propertyHandlers_["switch_option"] = &CollectProperties::addOption;
 626       propertyHandlers_["alias_option"] = &CollectProperties::addOption;
 627
 628       staticMembersInitialized_ = true;
 629     }
 630   }
 631
 632   /// operator() - Gets called for every tool property; Just forwards
 633   /// to the corresponding property handler.
 634   void operator() (Init* i) {
 635     const DagInit& d = InitPtrToDag(i);
 636     const std::string& property_name = d.getOperator()->getAsString();
 637     PropertyHandlerMap::iterator method
 638       = propertyHandlers_.find(property_name);
 639
 640     if (method != propertyHandlers_.end()) {
 641       PropertyHandler h = method->second;
 642       (this->*h)(&d);
 643     }
 644     else {
 645       throw "Unknown tool property: " + property_name + "!";
 646     }
 647   }
 648
 649 private:
 650
 651   /// Property handlers --
 652   /// Functions that extract information about tool properties from
 653   /// DAG representation.
 654
 655   void onCmdLine (const DagInit* d) {
 656     checkNumberOfArguments(d, 1);
 657     toolProps_.CmdLine = d->getArg(0);
 658   }
 659
 660   void onInLanguage (const DagInit* d) {
 661     checkNumberOfArguments(d, 1);
 662     Init* arg = d->getArg(0);
 663
 664     // Find out the argument's type.
 665     if (typeid(*arg) == typeid(StringInit)) {
 666       // It's a string.
 667       toolProps_.InLanguage.push_back(InitPtrToString(arg));
 668     }
 669     else {
 670       // It's a list.
 671       const ListInit& lst = InitPtrToList(arg);
 672       StrVector& out = toolProps_.InLanguage;
 673
 674       // Copy strings to the output vector.
 675       for (ListInit::const_iterator B = lst.begin(), E = lst.end();
 676            B != E; ++B) {
 677         out.push_back(InitPtrToString(*B));
 678       }
 679
 680       // Remove duplicates.
 681       std::sort(out.begin(), out.end());
 682       StrVector::iterator newE = std::unique(out.begin(), out.end());
 683       out.erase(newE, out.end());
 684     }
 685   }
 686
 687   void onJoin (const DagInit* d) {
 688     checkNumberOfArguments(d, 0);
 689     toolProps_.setJoin();
 690   }
 691
 692   void onOutLanguage (const DagInit* d) {
 693     checkNumberOfArguments(d, 1);
 694     toolProps_.OutLanguage = InitPtrToString(d->getArg(0));
 695   }
 696
 697   void onOutputSuffix (const DagInit* d) {
 698     checkNumberOfArguments(d, 1);
 699     toolProps_.OutputSuffix = InitPtrToString(d->getArg(0));
 700   }
 701
 702   void onSink (const DagInit* d) {
 703     checkNumberOfArguments(d, 0);
 704     optDescs_.HasSink = true;
 705     toolProps_.setSink();
 706   }
 707
 708   // Just forwards to the AddOption function object. Somewhat
 709   // non-optimal, but avoids code duplication.
 710   void addOption (const DagInit* d) {
 711     checkNumberOfArguments(d, 2);
 712     AddOption(optDescs_, &toolProps_)(d);
 713   }
 714
 715 };
 716
 717 // Defintions of static members of CollectProperties.
 718 CollectProperties::PropertyHandlerMap CollectProperties::propertyHandlers_;
 719 bool CollectProperties::staticMembersInitialized_ = false;
 720
 721
 722 /// CollectToolProperties - Gather information about tool properties
 723 /// from the parsed TableGen data (basically a wrapper for the
 724 /// CollectProperties function object).
 725 void CollectToolProperties (RecordVector::const_iterator B,
 726                             RecordVector::const_iterator E,
 727                             ToolPropertiesList& TPList,
 728                             GlobalOptionDescriptions& OptDescs)
 729 {
 730   // Iterate over a properties list of every Tool definition
 731   for (;B!=E;++B) {
 732     Record* T = *B;
 733     // Throws an exception if the value does not exist.
 734     ListInit* PropList = T->getValueAsListInit("properties");
 735
 736     IntrusiveRefCntPtr<ToolProperties>
 737       ToolProps(new ToolProperties(T->getName()));
 738
 739     std::for_each(PropList->begin(), PropList->end(),
 740                   CollectProperties(*ToolProps, OptDescs));
 741     TPList.push_back(ToolProps);
 742   }
 743 }
 744
 745
 746 /// CollectPropertiesFromOptionList - Gather information about
 747 /// *global* option properties from the OptionList.
 748 void CollectPropertiesFromOptionList (RecordVector::const_iterator B,
 749                                       RecordVector::const_iterator E,
 750                                       GlobalOptionDescriptions& OptDescs)
 751 {
 752   // Iterate over a properties list of every Tool definition
 753
 754   for (;B!=E;++B) {
 755     RecordVector::value_type T = *B;
 756     // Throws an exception if the value does not exist.
 757     ListInit* PropList = T->getValueAsListInit("options");
 758
 759     std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
 760   }
 761 }
 762
 763 /// EmitCaseTest1Arg - Helper function used by
 764 /// EmitCaseConstructHandler.
 765 bool EmitCaseTest1Arg(const std::string& TestName,
 766                       const DagInit& d,
 767                       const GlobalOptionDescriptions& OptDescs,
 768                       std::ostream& O) {
 769   checkNumberOfArguments(&d, 1);
 770   const std::string& OptName = InitPtrToString(d.getArg(0));
 771   if (TestName == "switch_on") {
 772     const GlobalOptionDescription& OptDesc = OptDescs.FindOption(OptName);
 773     if (OptDesc.Type != OptionType::Switch)
 774       throw OptName + ": incorrect option type!";
 775     O << OptDesc.GenVariableName();
 776     return true;
 777   } else if (TestName == "input_languages_contain") {
 778     O << "InLangs.count(\"" << OptName << "\") != 0";
 779     return true;
 780   } else if (TestName == "in_language") {
 781     // Works only for cmd_line!
 782     O << "GetLanguage(inFile) == \"" << OptName << '\"';
 783     return true;
 784   } else if (TestName == "not_empty") {
 785     if (OptName == "o") {
 786       O << "!OutputFilename.empty()";
 787       return true;
 788     }
 789     else {
 790       const GlobalOptionDescription& OptDesc = OptDescs.FindOption(OptName);
 791       if (OptDesc.Type == OptionType::Switch)
 792         throw OptName + ": incorrect option type!";
 793       O << '!' << OptDesc.GenVariableName() << ".empty()";
 794       return true;
 795     }
 796   }
 797
 798   return false;
 799 }
 800
 801 /// EmitCaseTest2Args - Helper function used by
 802 /// EmitCaseConstructHandler.
 803 bool EmitCaseTest2Args(const std::string& TestName,
 804                        const DagInit& d,
 805                        const char* IndentLevel,
 806                        const GlobalOptionDescriptions& OptDescs,
 807                        std::ostream& O) {
 808   checkNumberOfArguments(&d, 2);
 809   const std::string& OptName = InitPtrToString(d.getArg(0));
 810   const std::string& OptArg = InitPtrToString(d.getArg(1));
 811   const GlobalOptionDescription& OptDesc = OptDescs.FindOption(OptName);
 812
 813   if (TestName == "parameter_equals") {
 814     if (OptDesc.Type != OptionType::Parameter
 815         && OptDesc.Type != OptionType::Prefix)
 816       throw OptName + ": incorrect option type!";
 817     O << OptDesc.GenVariableName() << " == \"" << OptArg << "\"";
 818     return true;
 819   }
 820   else if (TestName == "element_in_list") {
 821     if (OptDesc.Type != OptionType::ParameterList
 822         && OptDesc.Type != OptionType::PrefixList)
 823       throw OptName + ": incorrect option type!";
 824     const std::string& VarName = OptDesc.GenVariableName();
 825     O << "std::find(" << VarName << ".begin(),\n"
 826       << IndentLevel << Indent1 << VarName << ".end(), \""
 827       << OptArg << "\") != " << VarName << ".end()";
 828     return true;
 829   }
 830
 831   return false;
 832 }
 833
 834 // Forward declaration.
 835 // EmitLogicalOperationTest and EmitCaseTest are mutually recursive.
 836 void EmitCaseTest(const DagInit& d, const char* IndentLevel,
 837                   const GlobalOptionDescriptions& OptDescs,
 838                   std::ostream& O);
 839
 840 /// EmitLogicalOperationTest - Helper function used by
 841 /// EmitCaseConstructHandler.
 842 void EmitLogicalOperationTest(const DagInit& d, const char* LogicOp,
 843                               const char* IndentLevel,
 844                               const GlobalOptionDescriptions& OptDescs,
 845                               std::ostream& O) {
 846   O << '(';
 847   for (unsigned j = 0, NumArgs = d.getNumArgs(); j < NumArgs; ++j) {
 848     const DagInit& InnerTest = InitPtrToDag(d.getArg(j));
 849     EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
 850     if (j != NumArgs - 1)
 851       O << ")\n" << IndentLevel << Indent1 << ' ' << LogicOp << " (";
 852     else
 853       O << ')';
 854   }
 855 }
 856
 857 /// EmitCaseTest - Helper function used by EmitCaseConstructHandler.
 858 void EmitCaseTest(const DagInit& d, const char* IndentLevel,
 859                   const GlobalOptionDescriptions& OptDescs,
 860                   std::ostream& O) {
 861   const std::string& TestName = d.getOperator()->getAsString();
 862
 863   if (TestName == "and")
 864     EmitLogicalOperationTest(d, "&&", IndentLevel, OptDescs, O);
 865   else if (TestName == "or")
 866     EmitLogicalOperationTest(d, "||", IndentLevel, OptDescs, O);
 867   else if (EmitCaseTest1Arg(TestName, d, OptDescs, O))
 868     return;
 869   else if (EmitCaseTest2Args(TestName, d, IndentLevel, OptDescs, O))
 870     return;
 871   else
 872     throw TestName + ": unknown edge property!";
 873 }
 874
 875 // Emit code that handles the 'case' construct.
 876 // Takes a function object that should emit code for every case clause.
 877 // Callback's type is
 878 // void F(Init* Statement, const char* IndentLevel, std::ostream& O).
 879 template <typename F>
 880 void EmitCaseConstructHandler(const DagInit* d, const char* IndentLevel,
 881                               const F& Callback, bool EmitElseIf,
 882                               const GlobalOptionDescriptions& OptDescs,
 883                               std::ostream& O) {
 884   assert(d->getOperator()->getAsString() == "case");
 885
 886   unsigned numArgs = d->getNumArgs();
 887   if (d->getNumArgs() < 2)
 888     throw "There should be at least one clause in the 'case' expression:\n"
 889       + d->getAsString();
 890
 891   for (unsigned i = 0; i != numArgs; ++i) {
 892     const DagInit& Test = InitPtrToDag(d->getArg(i));
 893
 894     // Emit the test.
 895     if (Test.getOperator()->getAsString() == "default") {
 896       if (i+2 != numArgs)
 897         throw std::string("The 'default' clause should be the last in the"
 898                           "'case' construct!");
 899       O << IndentLevel << "else {\n";
 900     }
 901     else {
 902       O << IndentLevel << ((i != 0 && EmitElseIf) ? "else if (" : "if (");
 903       EmitCaseTest(Test, IndentLevel, OptDescs, O);
 904       O << ") {\n";
 905     }
 906
 907     // Emit the corresponding statement.
 908     ++i;
 909     if (i == numArgs)
 910       throw "Case construct handler: no corresponding action "
 911         "found for the test " + Test.getAsString() + '!';
 912
 913     Init* arg = d->getArg(i);
 914     if (dynamic_cast<DagInit*>(arg)
 915         && static_cast<DagInit*>(arg)->getOperator()->getAsString() == "case") {
 916       EmitCaseConstructHandler(static_cast<DagInit*>(arg),
 917                                (std::string(IndentLevel) + Indent1).c_str(),
 918                                Callback, EmitElseIf, OptDescs, O);
 919     }
 920     else {
 921       Callback(arg, IndentLevel, O);
 922     }
 923     O << IndentLevel << "}\n";
 924   }
 925 }
 926
 927 /// EmitForwardOptionPropertyHandlingCode - Helper function used to
 928 /// implement EmitOptionPropertyHandlingCode(). Emits code for
 929 /// handling the (forward) option property.
 930 void EmitForwardOptionPropertyHandlingCode (const ToolOptionDescription& D,
 931                                             std::ostream& O) {
 932   switch (D.Type) {
 933   case OptionType::Switch:
 934     O << Indent3 << "vec.push_back(\"-" << D.Name << "\");\n";
 935     break;
 936   case OptionType::Parameter:
 937     O << Indent3 << "vec.push_back(\"-" << D.Name << "\");\n";
 938     O << Indent3 << "vec.push_back(" << D.GenVariableName() << ");\n";
 939     break;
 940   case OptionType::Prefix:
 941     O << Indent3 << "vec.push_back(\"-" << D.Name << "\" + "
 942       << D.GenVariableName() << ");\n";
 943     break;
 944   case OptionType::PrefixList:
 945     O << Indent3 << "for (" << D.GenTypeDeclaration()
 946       << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
 947       << Indent3 << "E = " << D.GenVariableName() << ".end(); B != E; ++B)\n"
 948       << Indent4 << "vec.push_back(\"-" << D.Name << "\" + "
 949       << "*B);\n";
 950     break;
 951   case OptionType::ParameterList:
 952     O << Indent3 << "for (" << D.GenTypeDeclaration()
 953       << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
 954       << Indent3 << "E = " << D.GenVariableName()
 955       << ".end() ; B != E; ++B) {\n"
 956       << Indent4 << "vec.push_back(\"-" << D.Name << "\");\n"
 957       << Indent4 << "vec.push_back(*B);\n"
 958       << Indent3 << "}\n";
 959     break;
 960   case OptionType::Alias:
 961   default:
 962     throw std::string("Aliases are not allowed in tool option descriptions!");
 963   }
 964 }
 965
 966 // ToolOptionHasInterestingProperties - A helper function used by
 967 // EmitOptionPropertyHandlingCode() that tells us whether we should
 968 // emit any property handling code at all.
 969 bool ToolOptionHasInterestingProperties(const ToolOptionDescription& D) {
 970   bool ret = false;
 971   for (OptionPropertyList::const_iterator B = D.Props.begin(),
 972          E = D.Props.end(); B != E; ++B) {
 973       const OptionProperty& OptProp = *B;
 974       if (OptProp.first == OptionPropertyType::AppendCmd)
 975         ret = true;
 976     }
 977   if (D.isForward() || D.isUnpackValues())
 978     ret = true;
 979   return ret;
 980 }
 981
 982 /// EmitOptionPropertyHandlingCode - Helper function used by
 983 /// EmitGenerateActionMethod(). Emits code that handles option
 984 /// properties.
 985 void EmitOptionPropertyHandlingCode (const ToolOptionDescription& D,
 986                                      std::ostream& O)
 987 {
 988   if (!ToolOptionHasInterestingProperties(D))
 989     return;
 990   // Start of the if-clause.
 991   O << Indent2 << "if (";
 992   if (D.Type == OptionType::Switch)
 993     O << D.GenVariableName();
 994   else
 995     O << '!' << D.GenVariableName() << ".empty()";
 996
 997   O <<") {\n";
 998
 999   // Handle option properties that take an argument.
1000   for (OptionPropertyList::const_iterator B = D.Props.begin(),
1001         E = D.Props.end(); B!=E; ++B) {
1002     const OptionProperty& val = *B;
1003
1004     switch (val.first) {
1005       // (append_cmd cmd) property
1006     case OptionPropertyType::AppendCmd:
1007       O << Indent3 << "vec.push_back(\"" << val.second << "\");\n";
1008       break;
1009       // Other properties with argument
1010     default:
1011       break;
1012     }
1013   }
1014
1015   // Handle flags
1016
1017   // (forward) property
1018   if (D.isForward())
1019     EmitForwardOptionPropertyHandlingCode(D, O);
1020
1021   // (unpack_values) property
1022   if (D.isUnpackValues()) {
1023     if (IsListOptionType(D.Type)) {
1024       O << Indent3 << "for (" << D.GenTypeDeclaration()
1025         << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
1026         << Indent3 << "E = " << D.GenVariableName()
1027         << ".end(); B != E; ++B)\n"
1028         << Indent4 << "llvm::SplitString(*B, vec, \",\");\n";
1029     }
1030     else if (D.Type == OptionType::Prefix || D.Type == OptionType::Parameter){
1031       O << Indent3 << "llvm::SplitString("
1032         << D.GenVariableName() << ", vec, \",\");\n";
1033     }
1034     else {
1035       throw std::string("Switches can't have unpack_values property!");
1036     }
1037   }
1038
1039   // End of the if-clause.
1040   O << Indent2 << "}\n";
1041 }
1042
1043 /// SubstituteSpecialCommands - Perform string substitution for $CALL
1044 /// and $ENV. Helper function used by EmitCmdLineVecFill().
1045 std::string SubstituteSpecialCommands(const std::string& cmd) {
1046   size_t cparen = cmd.find(")");
1047   std::string ret;
1048
1049   if (cmd.find("$CALL(") == 0) {
1050     if (cmd.size() == 6)
1051       throw std::string("$CALL invocation: empty argument list!");
1052
1053     ret += "hooks::";
1054     ret += std::string(cmd.begin() + 6, cmd.begin() + cparen);
1055     ret += "()";
1056   }
1057   else if (cmd.find("$ENV(") == 0) {
1058     if (cmd.size() == 5)
1059       throw std::string("$ENV invocation: empty argument list!");
1060
1061     ret += "std::getenv(\"";
1062     ret += std::string(cmd.begin() + 5, cmd.begin() + cparen);
1063     ret += "\")";
1064   }
1065   else {
1066     throw "Unknown special command: " + cmd;
1067   }
1068
1069   if (cmd.begin() + cparen + 1 != cmd.end()) {
1070     ret += " + std::string(\"";
1071     ret += (cmd.c_str() + cparen + 1);
1072     ret += "\")";
1073   }
1074
1075   return ret;
1076 }
1077
1078 /// EmitCmdLineVecFill - Emit code that fills in the command line
1079 /// vector. Helper function used by EmitGenerateActionMethod().
1080 void EmitCmdLineVecFill(const Init* CmdLine, const std::string& ToolName,
1081                         bool Version, const char* IndentLevel,
1082                         std::ostream& O) {
1083   StrVector StrVec;
1084   SplitString(InitPtrToString(CmdLine), StrVec);
1085   if (StrVec.empty())
1086     throw "Tool " + ToolName + " has empty command line!";
1087
1088   StrVector::const_iterator I = StrVec.begin();
1089   ++I;
1090   for (StrVector::const_iterator E = StrVec.end(); I != E; ++I) {
1091     const std::string& cmd = *I;
1092     O << IndentLevel;
1093     if (cmd.at(0) == '$') {
1094       if (cmd == "$INFILE") {
1095         if (Version)
1096           O << "for (PathVector::const_iterator B = inFiles.begin()"
1097             << ", E = inFiles.end();\n"
1098             << IndentLevel << "B != E; ++B)\n"
1099             << IndentLevel << Indent1 << "vec.push_back(B->toString());\n";
1100         else
1101           O << "vec.push_back(inFile.toString());\n";
1102       }
1103       else if (cmd == "$OUTFILE") {
1104         O << "vec.push_back(outFile.toString());\n";
1105       }
1106       else {
1107         O << "vec.push_back(" << SubstituteSpecialCommands(cmd);
1108         O << ");\n";
1109       }
1110     }
1111     else {
1112       O << "vec.push_back(\"" << cmd << "\");\n";
1113     }
1114   }
1115   O << IndentLevel << "cmd = "
1116     << ((StrVec[0][0] == '$') ? SubstituteSpecialCommands(StrVec[0])
1117         : "\"" + StrVec[0] + "\"")
1118     << ";\n";
1119 }
1120
1121 /// EmitCmdLineVecFillCallback - A function object wrapper around
1122 /// EmitCmdLineVecFill(). Used by EmitGenerateActionMethod() as an
1123 /// argument to EmitCaseConstructHandler().
1124 class EmitCmdLineVecFillCallback {
1125   bool Version;
1126   const std::string& ToolName;
1127  public:
1128   EmitCmdLineVecFillCallback(bool Ver, const std::string& TN)
1129     : Version(Ver), ToolName(TN) {}
1130
1131   void operator()(const Init* Statement, const char* IndentLevel,
1132                   std::ostream& O) const
1133   {
1134     EmitCmdLineVecFill(Statement, ToolName, Version,
1135                        (std::string(IndentLevel) + Indent1).c_str(), O);
1136   }
1137 };
1138
1139 // EmitGenerateActionMethod - Emit one of two versions of the
1140 // Tool::GenerateAction() method.
1141 void EmitGenerateActionMethod (const ToolProperties& P,
1142                                const GlobalOptionDescriptions& OptDescs,
1143                                bool Version, std::ostream& O) {
1144   if (Version)
1145     O << Indent1 << "Action GenerateAction(const PathVector& inFiles,\n";
1146   else
1147     O << Indent1 << "Action GenerateAction(const sys::Path& inFile,\n";
1148
1149   O << Indent2 << "const sys::Path& outFile,\n"
1150     << Indent2 << "const InputLanguagesSet& InLangs) const\n"
1151     << Indent1 << "{\n"
1152     << Indent2 << "const char* cmd;\n"
1153     << Indent2 << "std::vector<std::string> vec;\n";
1154
1155   // cmd_line is either a string or a 'case' construct.
1156   if (typeid(*P.CmdLine) == typeid(StringInit))
1157     EmitCmdLineVecFill(P.CmdLine, P.Name, Version, Indent2, O);
1158   else
1159     EmitCaseConstructHandler(&InitPtrToDag(P.CmdLine), Indent2,
1160                              EmitCmdLineVecFillCallback(Version, P.Name),
1161                              true, OptDescs, O);
1162
1163   // For every understood option, emit handling code.
1164   for (ToolOptionDescriptions::const_iterator B = P.OptDescs.begin(),
1165         E = P.OptDescs.end(); B != E; ++B) {
1166     const ToolOptionDescription& val = B->second;
1167     EmitOptionPropertyHandlingCode(val, O);
1168   }
1169
1170   // Handle the Sink property.
1171   if (P.isSink()) {
1172     O << Indent2 << "if (!" << SinkOptionName << ".empty()) {\n"
1173       << Indent3 << "vec.insert(vec.end(), "
1174       << SinkOptionName << ".begin(), " << SinkOptionName << ".end());\n"
1175       << Indent2 << "}\n";
1176   }
1177
1178   O << Indent2 << "return Action(cmd, vec);\n"
1179     << Indent1 << "}\n\n";
1180 }
1181
1182 /// EmitGenerateActionMethods - Emit two GenerateAction() methods for
1183 /// a given Tool class.
1184 void EmitGenerateActionMethods (const ToolProperties& P,
1185                                 const GlobalOptionDescriptions& OptDescs,
1186                                 std::ostream& O) {
1187   if (!P.isJoin())
1188     O << Indent1 << "Action GenerateAction(const PathVector& inFiles,\n"
1189       << Indent2 << "const llvm::sys::Path& outFile,\n"
1190       << Indent2 << "const InputLanguagesSet& InLangs) const\n"
1191       << Indent1 << "{\n"
1192       << Indent2 << "throw std::runtime_error(\"" << P.Name
1193       << " is not a Join tool!\");\n"
1194       << Indent1 << "}\n\n";
1195   else
1196     EmitGenerateActionMethod(P, OptDescs, true, O);
1197
1198   EmitGenerateActionMethod(P, OptDescs, false, O);
1199 }
1200
1201 /// EmitIsLastMethod - Emit the IsLast() method for a given Tool
1202 /// class.
1203 void EmitIsLastMethod (const ToolProperties& P, std::ostream& O) {
1204   O << Indent1 << "bool IsLast() const {\n"
1205     << Indent2 << "bool last = false;\n";
1206
1207   for (ToolOptionDescriptions::const_iterator B = P.OptDescs.begin(),
1208         E = P.OptDescs.end(); B != E; ++B) {
1209     const ToolOptionDescription& val = B->second;
1210
1211     if (val.isStopCompilation())
1212       O << Indent2
1213         << "if (" << val.GenVariableName()
1214         << ")\n" << Indent3 << "last = true;\n";
1215   }
1216
1217   O << Indent2 << "return last;\n"
1218     << Indent1 <<  "}\n\n";
1219 }
1220
1221 /// EmitInOutLanguageMethods - Emit the [Input,Output]Language()
1222 /// methods for a given Tool class.
1223 void EmitInOutLanguageMethods (const ToolProperties& P, std::ostream& O) {
1224   O << Indent1 << "const char** InputLanguages() const {\n"
1225     << Indent2 << "return InputLanguages_;\n"
1226     << Indent1 << "}\n\n";
1227
1228   O << Indent1 << "const char* OutputLanguage() const {\n"
1229     << Indent2 << "return \"" << P.OutLanguage << "\";\n"
1230     << Indent1 << "}\n\n";
1231 }
1232
1233 /// EmitOutputSuffixMethod - Emit the OutputSuffix() method for a
1234 /// given Tool class.
1235 void EmitOutputSuffixMethod (const ToolProperties& P, std::ostream& O) {
1236   O << Indent1 << "const char* OutputSuffix() const {\n"
1237     << Indent2 << "const char* ret = \"" << P.OutputSuffix << "\";\n";
1238
1239   for (ToolOptionDescriptions::const_iterator B = P.OptDescs.begin(),
1240          E = P.OptDescs.end(); B != E; ++B) {
1241     const ToolOptionDescription& OptDesc = B->second;
1242     for (OptionPropertyList::const_iterator B = OptDesc.Props.begin(),
1243            E = OptDesc.Props.end(); B != E; ++B) {
1244       const OptionProperty& OptProp = *B;
1245       if (OptProp.first == OptionPropertyType::OutputSuffix) {
1246         O << Indent2 << "if (" << OptDesc.GenVariableName() << ")\n"
1247           << Indent3 << "ret = \"" << OptProp.second << "\";\n";
1248       }
1249     }
1250   }
1251
1252   O << Indent2 << "return ret;\n"
1253     << Indent1 << "}\n\n";
1254 }
1255
1256 /// EmitNameMethod - Emit the Name() method for a given Tool class.
1257 void EmitNameMethod (const ToolProperties& P, std::ostream& O) {
1258   O << Indent1 << "const char* Name() const {\n"
1259     << Indent2 << "return \"" << P.Name << "\";\n"
1260     << Indent1 << "}\n\n";
1261 }
1262
1263 /// EmitIsJoinMethod - Emit the IsJoin() method for a given Tool
1264 /// class.
1265 void EmitIsJoinMethod (const ToolProperties& P, std::ostream& O) {
1266   O << Indent1 << "bool IsJoin() const {\n";
1267   if (P.isJoin())
1268     O << Indent2 << "return true;\n";
1269   else
1270     O << Indent2 << "return false;\n";
1271   O << Indent1 << "}\n\n";
1272 }
1273
1274 /// EmitStaticMemberDefinitions - Emit static member definitions for a
1275 /// given Tool class.
1276 void EmitStaticMemberDefinitions(const ToolProperties& P, std::ostream& O) {
1277   O << "const char* " << P.Name << "::InputLanguages_[] = {";
1278   for (StrVector::const_iterator B = P.InLanguage.begin(),
1279          E = P.InLanguage.end(); B != E; ++B)
1280     O << '\"' << *B << "\", ";
1281   O << "0};\n\n";
1282 }
1283
1284 /// EmitToolClassDefinition - Emit a Tool class definition.
1285 void EmitToolClassDefinition (const ToolProperties& P,
1286                               const GlobalOptionDescriptions& OptDescs,
1287                               std::ostream& O) {
1288   if (P.Name == "root")
1289     return;
1290
1291   // Header
1292   O << "class " << P.Name << " : public ";
1293   if (P.isJoin())
1294     O << "JoinTool";
1295   else
1296     O << "Tool";
1297
1298   O << "{\nprivate:\n"
1299     << Indent1 << "static const char* InputLanguages_[];\n\n";
1300
1301   O << "public:\n";
1302   EmitNameMethod(P, O);
1303   EmitInOutLanguageMethods(P, O);
1304   EmitOutputSuffixMethod(P, O);
1305   EmitIsJoinMethod(P, O);
1306   EmitGenerateActionMethods(P, OptDescs, O);
1307   EmitIsLastMethod(P, O);
1308
1309   // Close class definition
1310   O << "};\n";
1311
1312   EmitStaticMemberDefinitions(P, O);
1313
1314 }
1315
1316 /// EmitOptionDescriptions - Iterate over a list of option
1317 /// descriptions and emit registration code.
1318 void EmitOptionDescriptions (const GlobalOptionDescriptions& descs,
1319                              std::ostream& O)
1320 {
1321   std::vector<GlobalOptionDescription> Aliases;
1322
1323   // Emit static cl::Option variables.
1324   for (GlobalOptionDescriptions::const_iterator B = descs.begin(),
1325          E = descs.end(); B!=E; ++B) {
1326     const GlobalOptionDescription& val = B->second;
1327
1328     if (val.Type == OptionType::Alias) {
1329       Aliases.push_back(val);
1330       continue;
1331     }
1332
1333     O << val.GenTypeDeclaration() << ' '
1334       << val.GenVariableName()
1335       << "(\"" << val.Name << '\"';
1336
1337     if (val.Type == OptionType::Prefix || val.Type == OptionType::PrefixList)
1338       O << ", cl::Prefix";
1339
1340     if (val.isRequired()) {
1341       switch (val.Type) {
1342       case OptionType::PrefixList:
1343       case OptionType::ParameterList:
1344         O << ", cl::OneOrMore";
1345         break;
1346       default:
1347         O << ", cl::Required";
1348       }
1349     }
1350
1351     if (!val.Help.empty())
1352       O << ", cl::desc(\"" << val.Help << "\")";
1353
1354     O << ");\n";
1355   }
1356
1357   // Emit the aliases (they should go after all the 'proper' options).
1358   for (std::vector<GlobalOptionDescription>::const_iterator
1359          B = Aliases.begin(), E = Aliases.end(); B != E; ++B) {
1360     const GlobalOptionDescription& val = *B;
1361
1362     O << val.GenTypeDeclaration() << ' '
1363       << val.GenVariableName()
1364       << "(\"" << val.Name << '\"';
1365
1366     GlobalOptionDescriptions::container_type
1367       ::const_iterator F = descs.Descriptions.find(val.Help);
1368     if (F != descs.Descriptions.end())
1369       O << ", cl::aliasopt(" << F->second.GenVariableName() << ")";
1370     else
1371       throw val.Name + ": alias to an unknown option!";
1372
1373     O << ", cl::desc(\"" << "An alias for -" + val.Help  << "\"));\n";
1374   }
1375
1376   // Emit the sink option.
1377   if (descs.HasSink)
1378     O << "cl::list<std::string> " << SinkOptionName << "(cl::Sink);\n";
1379
1380   O << '\n';
1381 }
1382
1383 /// EmitPopulateLanguageMap - Emit the PopulateLanguageMap() function.
1384 void EmitPopulateLanguageMap (const RecordKeeper& Records, std::ostream& O)
1385 {
1386   // Get the relevant field out of RecordKeeper
1387   Record* LangMapRecord = Records.getDef("LanguageMap");
1388   if (!LangMapRecord)
1389     throw std::string("Language map definition not found!");
1390
1391   ListInit* LangsToSuffixesList = LangMapRecord->getValueAsListInit("map");
1392   if (!LangsToSuffixesList)
1393     throw std::string("Error in the language map definition!");
1394
1395   // Generate code
1396   O << "void llvmc::PopulateLanguageMap() {\n";
1397
1398   for (unsigned i = 0; i < LangsToSuffixesList->size(); ++i) {
1399     Record* LangToSuffixes = LangsToSuffixesList->getElementAsRecord(i);
1400
1401     const std::string& Lang = LangToSuffixes->getValueAsString("lang");
1402     const ListInit* Suffixes = LangToSuffixes->getValueAsListInit("suffixes");
1403
1404     for (unsigned i = 0; i < Suffixes->size(); ++i)
1405       O << Indent1 << "GlobalLanguageMap[\""
1406         << InitPtrToString(Suffixes->getElement(i))
1407         << "\"] = \"" << Lang << "\";\n";
1408   }
1409
1410   O << "}\n\n";
1411 }
1412
1413 /// FillInToolToLang - Fills in two tables that map tool names to
1414 /// (input, output) languages.  Used by the typechecker.
1415 void FillInToolToLang (const ToolPropertiesList& TPList,
1416                        StringMap<StringSet<> >& ToolToInLang,
1417                        StringMap<std::string>& ToolToOutLang) {
1418   for (ToolPropertiesList::const_iterator B = TPList.begin(), E = TPList.end();
1419        B != E; ++B) {
1420     const ToolProperties& P = *(*B);
1421     for (StrVector::const_iterator B = P.InLanguage.begin(),
1422            E = P.InLanguage.end(); B != E; ++B)
1423       ToolToInLang[P.Name].insert(*B);
1424     ToolToOutLang[P.Name] = P.OutLanguage;
1425   }
1426 }
1427
1428 /// TypecheckGraph - Check that names for output and input languages
1429 /// on all edges do match.
1430 // TOFIX: It would be nice if this function also checked for cycles
1431 // and multiple default edges in the graph (better error
1432 // reporting). Unfortunately, it is awkward to do right now because
1433 // our intermediate representation is not sufficiently
1434 // sofisticated. Algorithms like these should be run on a real graph
1435 // instead of AST.
1436 void TypecheckGraph (Record* CompilationGraph,
1437                      const ToolPropertiesList& TPList) {
1438   StringMap<StringSet<> > ToolToInLang;
1439   StringMap<std::string> ToolToOutLang;
1440
1441   FillInToolToLang(TPList, ToolToInLang, ToolToOutLang);
1442   ListInit* edges = CompilationGraph->getValueAsListInit("edges");
1443   StringMap<std::string>::iterator IAE = ToolToOutLang.end();
1444   StringMap<StringSet<> >::iterator IBE = ToolToInLang.end();
1445
1446   for (unsigned i = 0; i < edges->size(); ++i) {
1447     Record* Edge = edges->getElementAsRecord(i);
1448     Record* A = Edge->getValueAsDef("a");
1449     Record* B = Edge->getValueAsDef("b");
1450     StringMap<std::string>::iterator IA = ToolToOutLang.find(A->getName());
1451     StringMap<StringSet<> >::iterator IB = ToolToInLang.find(B->getName());
1452     if (IA == IAE)
1453       throw A->getName() + ": no such tool!";
1454     if (IB == IBE)
1455       throw B->getName() + ": no such tool!";
1456     if (A->getName() != "root" && IB->second.count(IA->second) == 0)
1457       throw "Edge " + A->getName() + "->" + B->getName()
1458         + ": output->input language mismatch";
1459     if (B->getName() == "root")
1460       throw std::string("Edges back to the root are not allowed!");
1461   }
1462 }
1463
1464 /// IncDecWeight - Helper function passed to EmitCaseConstructHandler()
1465 /// by EmitEdgeClass().
1466 void IncDecWeight (const Init* i, const char* IndentLevel,
1467                    std::ostream& O) {
1468   const DagInit& d = InitPtrToDag(i);
1469   const std::string& OpName = d.getOperator()->getAsString();
1470
1471   if (OpName == "inc_weight")
1472     O << IndentLevel << Indent1 << "ret += ";
1473   else if (OpName == "dec_weight")
1474     O << IndentLevel << Indent1 << "ret -= ";
1475   else
1476     throw "Unknown operator in edge properties list: " + OpName + '!';
1477
1478   if (d.getNumArgs() > 0)
1479     O << InitPtrToInt(d.getArg(0)) << ";\n";
1480   else
1481     O << "2;\n";
1482
1483 }
1484
1485 /// EmitEdgeClass - Emit a single Edge# class.
1486 void EmitEdgeClass (unsigned N, const std::string& Target,
1487                     DagInit* Case, const GlobalOptionDescriptions& OptDescs,
1488                     std::ostream& O) {
1489
1490   // Class constructor.
1491   O << "class Edge" << N << ": public Edge {\n"
1492     << "public:\n"
1493     << Indent1 << "Edge" << N << "() : Edge(\"" << Target
1494     << "\") {}\n\n"
1495
1496   // Function Weight().
1497     << Indent1 << "unsigned Weight(const InputLanguagesSet& InLangs) const {\n"
1498     << Indent2 << "unsigned ret = 0;\n";
1499
1500   // Handle the 'case' construct.
1501   EmitCaseConstructHandler(Case, Indent2, IncDecWeight, false, OptDescs, O);
1502
1503   O << Indent2 << "return ret;\n"
1504     << Indent1 << "};\n\n};\n\n";
1505 }
1506
1507 /// EmitEdgeClasses - Emit Edge* classes that represent graph edges.
1508 void EmitEdgeClasses (Record* CompilationGraph,
1509                       const GlobalOptionDescriptions& OptDescs,
1510                       std::ostream& O) {
1511   ListInit* edges = CompilationGraph->getValueAsListInit("edges");
1512
1513   for (unsigned i = 0; i < edges->size(); ++i) {
1514     Record* Edge = edges->getElementAsRecord(i);
1515     Record* B = Edge->getValueAsDef("b");
1516     DagInit* Weight = Edge->getValueAsDag("weight");
1517
1518     if (isDagEmpty(Weight))
1519       continue;
1520
1521     EmitEdgeClass(i, B->getName(), Weight, OptDescs, O);
1522   }
1523 }
1524
1525 /// EmitPopulateCompilationGraph - Emit the PopulateCompilationGraph()
1526 /// function.
1527 void EmitPopulateCompilationGraph (Record* CompilationGraph,
1528                                    std::ostream& O)
1529 {
1530   ListInit* edges = CompilationGraph->getValueAsListInit("edges");
1531
1532   // Generate code
1533   O << "void llvmc::PopulateCompilationGraph(CompilationGraph& G) {\n"
1534     << Indent1 << "PopulateLanguageMap();\n\n";
1535
1536   // Insert vertices
1537
1538   RecordVector Tools = Records.getAllDerivedDefinitions("Tool");
1539   if (Tools.empty())
1540     throw std::string("No tool definitions found!");
1541
1542   for (RecordVector::iterator B = Tools.begin(), E = Tools.end(); B != E; ++B) {
1543     const std::string& Name = (*B)->getName();
1544     if (Name != "root")
1545       O << Indent1 << "G.insertNode(new "
1546         << Name << "());\n";
1547   }
1548
1549   O << '\n';
1550
1551   // Insert edges
1552   for (unsigned i = 0; i < edges->size(); ++i) {
1553     Record* Edge = edges->getElementAsRecord(i);
1554     Record* A = Edge->getValueAsDef("a");
1555     Record* B = Edge->getValueAsDef("b");
1556     DagInit* Weight = Edge->getValueAsDag("weight");
1557
1558     O << Indent1 << "G.insertEdge(\"" << A->getName() << "\", ";
1559
1560     if (isDagEmpty(Weight))
1561       O << "new SimpleEdge(\"" << B->getName() << "\")";
1562     else
1563       O << "new Edge" << i << "()";
1564
1565     O << ");\n";
1566   }
1567
1568   O << "}\n\n";
1569 }
1570
1571 /// ExtractHookNames - Extract the hook names from all instances of
1572 /// $CALL(HookName) in the provided command line string. Helper
1573 /// function used by FillInHookNames().
1574 void ExtractHookNames(const Init* CmdLine, StrVector& HookNames) {
1575   StrVector cmds;
1576   llvm::SplitString(InitPtrToString(CmdLine), cmds);
1577   for (StrVector::const_iterator B = cmds.begin(), E = cmds.end();
1578        B != E; ++B) {
1579     const std::string& cmd = *B;
1580     if (cmd.find("$CALL(") == 0) {
1581       if (cmd.size() == 6)
1582         throw std::string("$CALL invocation: empty argument list!");
1583       HookNames.push_back(std::string(cmd.begin() + 6,
1584                                       cmd.begin() + cmd.find(")")));
1585     }
1586   }
1587 }
1588
1589 /// ExtractHookNamesFromCaseConstruct - Extract hook names from the
1590 /// 'case' expression, handle nesting. Helper function used by
1591 /// FillInHookNames().
1592 void ExtractHookNamesFromCaseConstruct(Init* Case, StrVector& HookNames) {
1593   const DagInit& d = InitPtrToDag(Case);
1594   bool even = false;
1595   for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end();
1596        B != E; ++B) {
1597     Init* arg = *B;
1598     if (even && dynamic_cast<DagInit*>(arg)
1599         && static_cast<DagInit*>(arg)->getOperator()->getAsString() == "case")
1600       ExtractHookNamesFromCaseConstruct(arg, HookNames);
1601     else if (even)
1602       ExtractHookNames(arg, HookNames);
1603     even = !even;
1604   }
1605 }
1606
1607 /// FillInHookNames - Actually extract the hook names from all command
1608 /// line strings. Helper function used by EmitHookDeclarations().
1609 void FillInHookNames(const ToolPropertiesList& TPList,
1610                      StrVector& HookNames) {
1611   // For all command lines:
1612   for (ToolPropertiesList::const_iterator B = TPList.begin(),
1613          E = TPList.end(); B != E; ++B) {
1614     const ToolProperties& P = *(*B);
1615     if (!P.CmdLine)
1616       continue;
1617     if (dynamic_cast<StringInit*>(P.CmdLine))
1618       // This is a string.
1619       ExtractHookNames(P.CmdLine, HookNames);
1620     else
1621       // This is a 'case' construct.
1622       ExtractHookNamesFromCaseConstruct(P.CmdLine, HookNames);
1623   }
1624 }
1625
1626 /// EmitHookDeclarations - Parse CmdLine fields of all the tool
1627 /// property records and emit hook function declaration for each
1628 /// instance of $CALL(HookName).
1629 void EmitHookDeclarations(const ToolPropertiesList& ToolProps,
1630                           std::ostream& O) {
1631   StrVector HookNames;
1632   FillInHookNames(ToolProps, HookNames);
1633   if (HookNames.empty())
1634     return;
1635   std::sort(HookNames.begin(), HookNames.end());
1636   StrVector::const_iterator E = std::unique(HookNames.begin(), HookNames.end());
1637
1638   O << "namespace hooks {\n";
1639   for (StrVector::const_iterator B = HookNames.begin(); B != E; ++B)
1640     O << Indent1 << "std::string " << *B << "();\n";
1641
1642   O << "}\n\n";
1643 }
1644
1645 // End of anonymous namespace
1646 }
1647
1648 /// run - The back-end entry point.
1649 void LLVMCConfigurationEmitter::run (std::ostream &O) {
1650   try {
1651
1652   // Emit file header.
1653   EmitSourceFileHeader("LLVMC Configuration Library", O);
1654
1655   // Get a list of all defined Tools.
1656   RecordVector Tools = Records.getAllDerivedDefinitions("Tool");
1657   if (Tools.empty())
1658     throw std::string("No tool definitions found!");
1659
1660   // Gather information from the Tool description dags.
1661   ToolPropertiesList tool_props;
1662   GlobalOptionDescriptions opt_descs;
1663   CollectToolProperties(Tools.begin(), Tools.end(), tool_props, opt_descs);
1664
1665   RecordVector OptionLists = Records.getAllDerivedDefinitions("OptionList");
1666   CollectPropertiesFromOptionList(OptionLists.begin(), OptionLists.end(),
1667                                   opt_descs);
1668
1669   // Emit global option registration code.
1670   EmitOptionDescriptions(opt_descs, O);
1671
1672   // Emit hook declarations.
1673   EmitHookDeclarations(tool_props, O);
1674
1675   // Emit PopulateLanguageMap() function
1676   // (a language map maps from file extensions to language names).
1677   EmitPopulateLanguageMap(Records, O);
1678
1679   // Emit Tool classes.
1680   for (ToolPropertiesList::const_iterator B = tool_props.begin(),
1681          E = tool_props.end(); B!=E; ++B)
1682     EmitToolClassDefinition(*(*B), opt_descs, O);
1683
1684   Record* CompilationGraphRecord = Records.getDef("CompilationGraph");
1685   if (!CompilationGraphRecord)
1686     throw std::string("Compilation graph description not found!");
1687
1688   // Typecheck the compilation graph.
1689   TypecheckGraph(CompilationGraphRecord, tool_props);
1690
1691   // Emit Edge# classes.
1692   EmitEdgeClasses(CompilationGraphRecord, opt_descs, O);
1693
1694   // Emit PopulateCompilationGraph() function.
1695   EmitPopulateCompilationGraph(CompilationGraphRecord, O);
1696
1697   // EOF
1698   } catch (std::exception& Error) {
1699     throw Error.what() + std::string(" - usually this means a syntax error.");
1700   }
1701 }