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 <algorithm>
  23 #include <cassert>
  24 #include <functional>
  25 #include <stdexcept>
  26 #include <string>
  27 #include <typeinfo>
  28
  29 using namespace llvm;
  30
  31 namespace {
  32
  33 //===----------------------------------------------------------------------===//
  34 /// Typedefs
  35
  36 typedef std::vector<Record*> RecordVector;
  37 typedef std::vector<std::string> StrVector;
  38
  39 //===----------------------------------------------------------------------===//
  40 /// Constants
  41
  42 // Indentation strings.
  43 const char * Indent1 = "    ";
  44 const char * Indent2 = "        ";
  45 const char * Indent3 = "            ";
  46
  47 // Default help string.
  48 const char * DefaultHelpString = "NO HELP MESSAGE PROVIDED";
  49
  50 // Name for the "sink" option.
  51 const char * SinkOptionName = "AutoGeneratedSinkOption";
  52
  53 //===----------------------------------------------------------------------===//
  54 /// Helper functions
  55
  56 /// Id - An 'identity' function object.
  57 struct Id {
  58   template<typename T>
  59   void operator()(const T&) const {
  60   }
  61 };
  62
  63 int InitPtrToInt(const Init* ptr) {
  64   const IntInit& val = dynamic_cast<const IntInit&>(*ptr);
  65   return val.getValue();
  66 }
  67
  68 const std::string& InitPtrToString(const Init* ptr) {
  69   const StringInit& val = dynamic_cast<const StringInit&>(*ptr);
  70   return val.getValue();
  71 }
  72
  73 const ListInit& InitPtrToList(const Init* ptr) {
  74   const ListInit& val = dynamic_cast<const ListInit&>(*ptr);
  75   return val;
  76 }
  77
  78 const DagInit& InitPtrToDag(const Init* ptr) {
  79   const DagInit& val = dynamic_cast<const DagInit&>(*ptr);
  80   return val;
  81 }
  82
  83 // checkNumberOfArguments - Ensure that the number of args in d is
  84 // greater than or equal to min_arguments, otherwise throw an exception.
  85 void checkNumberOfArguments (const DagInit* d, unsigned min_arguments) {
  86   if (!d || d->getNumArgs() < min_arguments)
  87     throw d->getOperator()->getAsString() + ": too few arguments!";
  88 }
  89
  90 // isDagEmpty - is this DAG marked with an empty marker?
  91 bool isDagEmpty (const DagInit* d) {
  92   return d->getOperator()->getAsString() == "empty_dag_marker";
  93 }
  94
  95 // EscapeVariableName - Escape commas and other symbols not allowed
  96 // in the C++ variable names. Makes it possible to use options named
  97 // like "Wa," (useful for prefix options).
  98 std::string EscapeVariableName(const std::string& Var) {
  99   std::string ret;
 100   for (unsigned i = 0; i != Var.size(); ++i) {
 101     char cur_char = Var[i];
 102     if (cur_char == ',') {
 103       ret += "_comma_";
 104     }
 105     else if (cur_char == '+') {
 106       ret += "_plus_";
 107     }
 108     else if (cur_char == '-') {
 109       ret += "_dash_";
 110     }
 111     else {
 112       ret.push_back(cur_char);
 113     }
 114   }
 115   return ret;
 116 }
 117
 118 /// oneOf - Does the input string contain this character?
 119 bool oneOf(const char* lst, char c) {
 120   while (*lst) {
 121     if (*lst++ == c)
 122       return true;
 123   }
 124   return false;
 125 }
 126
 127 template <class I, class S>
 128 void checkedIncrement(I& P, I E, S ErrorString) {
 129   ++P;
 130   if (P == E)
 131     throw ErrorString;
 132 }
 133
 134 //===----------------------------------------------------------------------===//
 135 /// Back-end specific code
 136
 137
 138 /// OptionType - One of six different option types. See the
 139 /// documentation for detailed description of differences.
 140 namespace OptionType {
 141
 142   enum OptionType { Alias, Switch, Parameter, ParameterList,
 143                     Prefix, PrefixList};
 144
 145   bool IsList (OptionType t) {
 146     return (t == ParameterList || t == PrefixList);
 147   }
 148
 149   bool IsSwitch (OptionType t) {
 150     return (t == Switch);
 151   }
 152
 153   bool IsParameter (OptionType t) {
 154     return (t == Parameter || t == Prefix);
 155   }
 156
 157 }
 158
 159 OptionType::OptionType stringToOptionType(const std::string& T) {
 160   if (T == "alias_option")
 161     return OptionType::Alias;
 162   else if (T == "switch_option")
 163     return OptionType::Switch;
 164   else if (T == "parameter_option")
 165     return OptionType::Parameter;
 166   else if (T == "parameter_list_option")
 167     return OptionType::ParameterList;
 168   else if (T == "prefix_option")
 169     return OptionType::Prefix;
 170   else if (T == "prefix_list_option")
 171     return OptionType::PrefixList;
 172   else
 173     throw "Unknown option type: " + T + '!';
 174 }
 175
 176 namespace OptionDescriptionFlags {
 177   enum OptionDescriptionFlags { Required = 0x1, Hidden = 0x2,
 178                                 ReallyHidden = 0x4, Extern = 0x8,
 179                                 OneOrMore = 0x10, ZeroOrOne = 0x20 };
 180 }
 181
 182 /// OptionDescription - Represents data contained in a single
 183 /// OptionList entry.
 184 struct OptionDescription {
 185   OptionType::OptionType Type;
 186   std::string Name;
 187   unsigned Flags;
 188   std::string Help;
 189   unsigned MultiVal;
 190   Init* InitVal;
 191
 192   OptionDescription(OptionType::OptionType t = OptionType::Switch,
 193                     const std::string& n = "",
 194                     const std::string& h = DefaultHelpString)
 195     : Type(t), Name(n), Flags(0x0), Help(h), MultiVal(1), InitVal(0)
 196   {}
 197
 198   /// GenTypeDeclaration - Returns the C++ variable type of this
 199   /// option.
 200   const char* GenTypeDeclaration() const;
 201
 202   /// GenVariableName - Returns the variable name used in the
 203   /// generated C++ code.
 204   std::string GenVariableName() const;
 205
 206   /// Merge - Merge two option descriptions.
 207   void Merge (const OptionDescription& other);
 208
 209   // Misc convenient getters/setters.
 210
 211   bool isAlias() const;
 212
 213   bool isMultiVal() const;
 214
 215   bool isExtern() const;
 216   void setExtern();
 217
 218   bool isRequired() const;
 219   void setRequired();
 220
 221   bool isOneOrMore() const;
 222   void setOneOrMore();
 223
 224   bool isZeroOrOne() const;
 225   void setZeroOrOne();
 226
 227   bool isHidden() const;
 228   void setHidden();
 229
 230   bool isReallyHidden() const;
 231   void setReallyHidden();
 232
 233   bool isParameter() const
 234   { return OptionType::IsParameter(this->Type); }
 235
 236   bool isSwitch() const
 237   { return OptionType::IsSwitch(this->Type); }
 238
 239   bool isList() const
 240   { return OptionType::IsList(this->Type); }
 241
 242 };
 243
 244 void OptionDescription::Merge (const OptionDescription& other)
 245 {
 246   if (other.Type != Type)
 247     throw "Conflicting definitions for the option " + Name + "!";
 248
 249   if (Help == other.Help || Help == DefaultHelpString)
 250     Help = other.Help;
 251   else if (other.Help != DefaultHelpString) {
 252     llvm::errs() << "Warning: several different help strings"
 253       " defined for option " + Name + "\n";
 254   }
 255
 256   Flags |= other.Flags;
 257 }
 258
 259 bool OptionDescription::isAlias() const {
 260   return Type == OptionType::Alias;
 261 }
 262
 263 bool OptionDescription::isMultiVal() const {
 264   return MultiVal > 1;
 265 }
 266
 267 bool OptionDescription::isExtern() const {
 268   return Flags & OptionDescriptionFlags::Extern;
 269 }
 270 void OptionDescription::setExtern() {
 271   Flags |= OptionDescriptionFlags::Extern;
 272 }
 273
 274 bool OptionDescription::isRequired() const {
 275   return Flags & OptionDescriptionFlags::Required;
 276 }
 277 void OptionDescription::setRequired() {
 278   Flags |= OptionDescriptionFlags::Required;
 279 }
 280
 281 bool OptionDescription::isOneOrMore() const {
 282   return Flags & OptionDescriptionFlags::OneOrMore;
 283 }
 284 void OptionDescription::setOneOrMore() {
 285   Flags |= OptionDescriptionFlags::OneOrMore;
 286 }
 287
 288 bool OptionDescription::isZeroOrOne() const {
 289   return Flags & OptionDescriptionFlags::ZeroOrOne;
 290 }
 291 void OptionDescription::setZeroOrOne() {
 292   Flags |= OptionDescriptionFlags::ZeroOrOne;
 293 }
 294
 295 bool OptionDescription::isHidden() const {
 296   return Flags & OptionDescriptionFlags::Hidden;
 297 }
 298 void OptionDescription::setHidden() {
 299   Flags |= OptionDescriptionFlags::Hidden;
 300 }
 301
 302 bool OptionDescription::isReallyHidden() const {
 303   return Flags & OptionDescriptionFlags::ReallyHidden;
 304 }
 305 void OptionDescription::setReallyHidden() {
 306   Flags |= OptionDescriptionFlags::ReallyHidden;
 307 }
 308
 309 const char* OptionDescription::GenTypeDeclaration() const {
 310   switch (Type) {
 311   case OptionType::Alias:
 312     return "cl::alias";
 313   case OptionType::PrefixList:
 314   case OptionType::ParameterList:
 315     return "cl::list<std::string>";
 316   case OptionType::Switch:
 317     return "cl::opt<bool>";
 318   case OptionType::Parameter:
 319   case OptionType::Prefix:
 320   default:
 321     return "cl::opt<std::string>";
 322   }
 323 }
 324
 325 std::string OptionDescription::GenVariableName() const {
 326   const std::string& EscapedName = EscapeVariableName(Name);
 327   switch (Type) {
 328   case OptionType::Alias:
 329     return "AutoGeneratedAlias_" + EscapedName;
 330   case OptionType::PrefixList:
 331   case OptionType::ParameterList:
 332     return "AutoGeneratedList_" + EscapedName;
 333   case OptionType::Switch:
 334     return "AutoGeneratedSwitch_" + EscapedName;
 335   case OptionType::Prefix:
 336   case OptionType::Parameter:
 337   default:
 338     return "AutoGeneratedParameter_" + EscapedName;
 339   }
 340 }
 341
 342 /// OptionDescriptions - An OptionDescription array plus some helper
 343 /// functions.
 344 class OptionDescriptions {
 345   typedef StringMap<OptionDescription> container_type;
 346
 347   /// Descriptions - A list of OptionDescriptions.
 348   container_type Descriptions;
 349
 350 public:
 351   /// FindOption - exception-throwing wrapper for find().
 352   const OptionDescription& FindOption(const std::string& OptName) const;
 353
 354   /// insertDescription - Insert new OptionDescription into
 355   /// OptionDescriptions list
 356   void InsertDescription (const OptionDescription& o);
 357
 358   // Support for STL-style iteration
 359   typedef container_type::const_iterator const_iterator;
 360   const_iterator begin() const { return Descriptions.begin(); }
 361   const_iterator end() const { return Descriptions.end(); }
 362 };
 363
 364 const OptionDescription&
 365 OptionDescriptions::FindOption(const std::string& OptName) const
 366 {
 367   const_iterator I = Descriptions.find(OptName);
 368   if (I != Descriptions.end())
 369     return I->second;
 370   else
 371     throw OptName + ": no such option!";
 372 }
 373
 374 void OptionDescriptions::InsertDescription (const OptionDescription& o)
 375 {
 376   container_type::iterator I = Descriptions.find(o.Name);
 377   if (I != Descriptions.end()) {
 378     OptionDescription& D = I->second;
 379     D.Merge(o);
 380   }
 381   else {
 382     Descriptions[o.Name] = o;
 383   }
 384 }
 385
 386 /// HandlerTable - A base class for function objects implemented as
 387 /// 'tables of handlers'.
 388 template <class T>
 389 class HandlerTable {
 390 protected:
 391   // Implementation details.
 392
 393   /// Handler -
 394   typedef void (T::* Handler) (const DagInit*);
 395   /// HandlerMap - A map from property names to property handlers
 396   typedef StringMap<Handler> HandlerMap;
 397
 398   static HandlerMap Handlers_;
 399   static bool staticMembersInitialized_;
 400
 401   T* childPtr;
 402 public:
 403
 404   HandlerTable(T* cp) : childPtr(cp)
 405   {}
 406
 407   /// operator() - Just forwards to the corresponding property
 408   /// handler.
 409   void operator() (Init* i) {
 410     const DagInit& property = InitPtrToDag(i);
 411     const std::string& property_name = property.getOperator()->getAsString();
 412     typename HandlerMap::iterator method = Handlers_.find(property_name);
 413
 414     if (method != Handlers_.end()) {
 415       Handler h = method->second;
 416       (childPtr->*h)(&property);
 417     }
 418     else {
 419       throw "No handler found for property " + property_name + "!";
 420     }
 421   }
 422
 423   void AddHandler(const char* Property, Handler Handl) {
 424     Handlers_[Property] = Handl;
 425   }
 426 };
 427
 428 template <class T> typename HandlerTable<T>::HandlerMap
 429 HandlerTable<T>::Handlers_;
 430 template <class T> bool HandlerTable<T>::staticMembersInitialized_ = false;
 431
 432
 433 /// CollectOptionProperties - Function object for iterating over an
 434 /// option property list.
 435 class CollectOptionProperties : public HandlerTable<CollectOptionProperties> {
 436 private:
 437
 438   /// optDescs_ - OptionDescriptions table. This is where the
 439   /// information is stored.
 440   OptionDescription& optDesc_;
 441
 442 public:
 443
 444   explicit CollectOptionProperties(OptionDescription& OD)
 445     : HandlerTable<CollectOptionProperties>(this), optDesc_(OD)
 446   {
 447     if (!staticMembersInitialized_) {
 448       AddHandler("extern", &CollectOptionProperties::onExtern);
 449       AddHandler("help", &CollectOptionProperties::onHelp);
 450       AddHandler("hidden", &CollectOptionProperties::onHidden);
 451       AddHandler("init", &CollectOptionProperties::onInit);
 452       AddHandler("multi_val", &CollectOptionProperties::onMultiVal);
 453       AddHandler("one_or_more", &CollectOptionProperties::onOneOrMore);
 454       AddHandler("really_hidden", &CollectOptionProperties::onReallyHidden);
 455       AddHandler("required", &CollectOptionProperties::onRequired);
 456       AddHandler("zero_or_one", &CollectOptionProperties::onZeroOrOne);
 457
 458       staticMembersInitialized_ = true;
 459     }
 460   }
 461
 462 private:
 463
 464   /// Option property handlers --
 465   /// Methods that handle option properties such as (help) or (hidden).
 466
 467   void onExtern (const DagInit* d) {
 468     checkNumberOfArguments(d, 0);
 469     optDesc_.setExtern();
 470   }
 471
 472   void onHelp (const DagInit* d) {
 473     checkNumberOfArguments(d, 1);
 474     optDesc_.Help = InitPtrToString(d->getArg(0));
 475   }
 476
 477   void onHidden (const DagInit* d) {
 478     checkNumberOfArguments(d, 0);
 479     optDesc_.setHidden();
 480   }
 481
 482   void onReallyHidden (const DagInit* d) {
 483     checkNumberOfArguments(d, 0);
 484     optDesc_.setReallyHidden();
 485   }
 486
 487   void onRequired (const DagInit* d) {
 488     checkNumberOfArguments(d, 0);
 489     if (optDesc_.isOneOrMore())
 490       throw std::string("An option can't have both (required) "
 491                         "and (one_or_more) properties!");
 492     optDesc_.setRequired();
 493   }
 494
 495   void onInit (const DagInit* d) {
 496     checkNumberOfArguments(d, 1);
 497     Init* i = d->getArg(0);
 498     const std::string& str = i->getAsString();
 499
 500     bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i);
 501     correct |= (optDesc_.isSwitch() && (str == "true" || str == "false"));
 502
 503     if (!correct)
 504       throw std::string("Incorrect usage of the 'init' option property!");
 505
 506     optDesc_.InitVal = i;
 507   }
 508
 509   void onOneOrMore (const DagInit* d) {
 510     checkNumberOfArguments(d, 0);
 511     if (optDesc_.isRequired() || optDesc_.isZeroOrOne())
 512       throw std::string("Only one of (required), (zero_or_one) or "
 513                         "(one_or_more) properties is allowed!");
 514     if (!OptionType::IsList(optDesc_.Type))
 515       llvm::errs() << "Warning: specifying the 'one_or_more' property "
 516         "on a non-list option will have no effect.\n";
 517     optDesc_.setOneOrMore();
 518   }
 519
 520   void onZeroOrOne (const DagInit* d) {
 521     checkNumberOfArguments(d, 0);
 522     if (optDesc_.isRequired() || optDesc_.isOneOrMore())
 523       throw std::string("Only one of (required), (zero_or_one) or "
 524                         "(one_or_more) properties is allowed!");
 525     if (!OptionType::IsList(optDesc_.Type))
 526       llvm::errs() << "Warning: specifying the 'zero_or_one' property"
 527         "on a non-list option will have no effect.\n";
 528     optDesc_.setZeroOrOne();
 529   }
 530
 531   void onMultiVal (const DagInit* d) {
 532     checkNumberOfArguments(d, 1);
 533     int val = InitPtrToInt(d->getArg(0));
 534     if (val < 2)
 535       throw std::string("Error in the 'multi_val' property: "
 536                         "the value must be greater than 1!");
 537     if (!OptionType::IsList(optDesc_.Type))
 538       throw std::string("The multi_val property is valid only "
 539                         "on list options!");
 540     optDesc_.MultiVal = val;
 541   }
 542
 543 };
 544
 545 /// AddOption - A function object that is applied to every option
 546 /// description. Used by CollectOptionDescriptions.
 547 class AddOption {
 548 private:
 549   OptionDescriptions& OptDescs_;
 550
 551 public:
 552   explicit AddOption(OptionDescriptions& OD) : OptDescs_(OD)
 553   {}
 554
 555   void operator()(const Init* i) {
 556     const DagInit& d = InitPtrToDag(i);
 557     checkNumberOfArguments(&d, 1);
 558
 559     const OptionType::OptionType Type =
 560       stringToOptionType(d.getOperator()->getAsString());
 561     const std::string& Name = InitPtrToString(d.getArg(0));
 562
 563     OptionDescription OD(Type, Name);
 564
 565     if (!OD.isExtern())
 566       checkNumberOfArguments(&d, 2);
 567
 568     if (OD.isAlias()) {
 569       // Aliases store the aliased option name in the 'Help' field.
 570       OD.Help = InitPtrToString(d.getArg(1));
 571     }
 572     else if (!OD.isExtern()) {
 573       processOptionProperties(&d, OD);
 574     }
 575     OptDescs_.InsertDescription(OD);
 576   }
 577
 578 private:
 579   /// processOptionProperties - Go through the list of option
 580   /// properties and call a corresponding handler for each.
 581   static void processOptionProperties (const DagInit* d, OptionDescription& o) {
 582     checkNumberOfArguments(d, 2);
 583     DagInit::const_arg_iterator B = d->arg_begin();
 584     // Skip the first argument: it's always the option name.
 585     ++B;
 586     std::for_each(B, d->arg_end(), CollectOptionProperties(o));
 587   }
 588
 589 };
 590
 591 /// CollectOptionDescriptions - Collects option properties from all
 592 /// OptionLists.
 593 void CollectOptionDescriptions (RecordVector::const_iterator B,
 594                                 RecordVector::const_iterator E,
 595                                 OptionDescriptions& OptDescs)
 596 {
 597   // For every OptionList:
 598   for (; B!=E; ++B) {
 599     RecordVector::value_type T = *B;
 600     // Throws an exception if the value does not exist.
 601     ListInit* PropList = T->getValueAsListInit("options");
 602
 603     // For every option description in this list:
 604     // collect the information and
 605     std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
 606   }
 607 }
 608
 609 // Tool information record
 610
 611 namespace ToolFlags {
 612   enum ToolFlags { Join = 0x1, Sink = 0x2 };
 613 }
 614
 615 struct ToolDescription : public RefCountedBase<ToolDescription> {
 616   std::string Name;
 617   Init* CmdLine;
 618   Init* Actions;
 619   StrVector InLanguage;
 620   std::string OutLanguage;
 621   std::string OutputSuffix;
 622   unsigned Flags;
 623
 624   // Various boolean properties
 625   void setSink()      { Flags |= ToolFlags::Sink; }
 626   bool isSink() const { return Flags & ToolFlags::Sink; }
 627   void setJoin()      { Flags |= ToolFlags::Join; }
 628   bool isJoin() const { return Flags & ToolFlags::Join; }
 629
 630   // Default ctor here is needed because StringMap can only store
 631   // DefaultConstructible objects
 632   ToolDescription() : CmdLine(0), Actions(0), Flags(0) {}
 633   ToolDescription (const std::string& n)
 634   : Name(n), CmdLine(0), Actions(0), Flags(0)
 635   {}
 636 };
 637
 638 /// ToolDescriptions - A list of Tool information records.
 639 typedef std::vector<IntrusiveRefCntPtr<ToolDescription> > ToolDescriptions;
 640
 641
 642 /// CollectToolProperties - Function object for iterating over a list of
 643 /// tool property records.
 644 class CollectToolProperties : public HandlerTable<CollectToolProperties> {
 645 private:
 646
 647   /// toolDesc_ - Properties of the current Tool. This is where the
 648   /// information is stored.
 649   ToolDescription& toolDesc_;
 650
 651 public:
 652
 653   explicit CollectToolProperties (ToolDescription& d)
 654     : HandlerTable<CollectToolProperties>(this) , toolDesc_(d)
 655   {
 656     if (!staticMembersInitialized_) {
 657
 658       AddHandler("actions", &CollectToolProperties::onActions);
 659       AddHandler("cmd_line", &CollectToolProperties::onCmdLine);
 660       AddHandler("in_language", &CollectToolProperties::onInLanguage);
 661       AddHandler("join", &CollectToolProperties::onJoin);
 662       AddHandler("out_language", &CollectToolProperties::onOutLanguage);
 663       AddHandler("output_suffix", &CollectToolProperties::onOutputSuffix);
 664       AddHandler("sink", &CollectToolProperties::onSink);
 665
 666       staticMembersInitialized_ = true;
 667     }
 668   }
 669
 670 private:
 671
 672   /// Property handlers --
 673   /// Functions that extract information about tool properties from
 674   /// DAG representation.
 675
 676   void onActions (const DagInit* d) {
 677     checkNumberOfArguments(d, 1);
 678     Init* Case = d->getArg(0);
 679     if (typeid(*Case) != typeid(DagInit) ||
 680         static_cast<DagInit*>(Case)->getOperator()->getAsString() != "case")
 681       throw
 682         std::string("The argument to (actions) should be a 'case' construct!");
 683     toolDesc_.Actions = Case;
 684   }
 685
 686   void onCmdLine (const DagInit* d) {
 687     checkNumberOfArguments(d, 1);
 688     toolDesc_.CmdLine = d->getArg(0);
 689   }
 690
 691   void onInLanguage (const DagInit* d) {
 692     checkNumberOfArguments(d, 1);
 693     Init* arg = d->getArg(0);
 694
 695     // Find out the argument's type.
 696     if (typeid(*arg) == typeid(StringInit)) {
 697       // It's a string.
 698       toolDesc_.InLanguage.push_back(InitPtrToString(arg));
 699     }
 700     else {
 701       // It's a list.
 702       const ListInit& lst = InitPtrToList(arg);
 703       StrVector& out = toolDesc_.InLanguage;
 704
 705       // Copy strings to the output vector.
 706       for (ListInit::const_iterator B = lst.begin(), E = lst.end();
 707            B != E; ++B) {
 708         out.push_back(InitPtrToString(*B));
 709       }
 710
 711       // Remove duplicates.
 712       std::sort(out.begin(), out.end());
 713       StrVector::iterator newE = std::unique(out.begin(), out.end());
 714       out.erase(newE, out.end());
 715     }
 716   }
 717
 718   void onJoin (const DagInit* d) {
 719     checkNumberOfArguments(d, 0);
 720     toolDesc_.setJoin();
 721   }
 722
 723   void onOutLanguage (const DagInit* d) {
 724     checkNumberOfArguments(d, 1);
 725     toolDesc_.OutLanguage = InitPtrToString(d->getArg(0));
 726   }
 727
 728   void onOutputSuffix (const DagInit* d) {
 729     checkNumberOfArguments(d, 1);
 730     toolDesc_.OutputSuffix = InitPtrToString(d->getArg(0));
 731   }
 732
 733   void onSink (const DagInit* d) {
 734     checkNumberOfArguments(d, 0);
 735     toolDesc_.setSink();
 736   }
 737
 738 };
 739
 740 /// CollectToolDescriptions - Gather information about tool properties
 741 /// from the parsed TableGen data (basically a wrapper for the
 742 /// CollectToolProperties function object).
 743 void CollectToolDescriptions (RecordVector::const_iterator B,
 744                               RecordVector::const_iterator E,
 745                               ToolDescriptions& ToolDescs)
 746 {
 747   // Iterate over a properties list of every Tool definition
 748   for (;B!=E;++B) {
 749     const Record* T = *B;
 750     // Throws an exception if the value does not exist.
 751     ListInit* PropList = T->getValueAsListInit("properties");
 752
 753     IntrusiveRefCntPtr<ToolDescription>
 754       ToolDesc(new ToolDescription(T->getName()));
 755
 756     std::for_each(PropList->begin(), PropList->end(),
 757                   CollectToolProperties(*ToolDesc));
 758     ToolDescs.push_back(ToolDesc);
 759   }
 760 }
 761
 762 /// FillInEdgeVector - Merge all compilation graph definitions into
 763 /// one single edge list.
 764 void FillInEdgeVector(RecordVector::const_iterator B,
 765                       RecordVector::const_iterator E, RecordVector& Out) {
 766   for (; B != E; ++B) {
 767     const ListInit* edges = (*B)->getValueAsListInit("edges");
 768
 769     for (unsigned i = 0; i < edges->size(); ++i)
 770       Out.push_back(edges->getElementAsRecord(i));
 771   }
 772 }
 773
 774 /// CalculatePriority - Calculate the priority of this plugin.
 775 int CalculatePriority(RecordVector::const_iterator B,
 776                       RecordVector::const_iterator E) {
 777   int total = 0;
 778   for (; B!=E; ++B) {
 779     total += static_cast<int>((*B)->getValueAsInt("priority"));
 780   }
 781   return total;
 782 }
 783
 784 /// NotInGraph - Helper function object for FilterNotInGraph.
 785 struct NotInGraph {
 786 private:
 787   const llvm::StringSet<>& ToolsInGraph_;
 788
 789 public:
 790   NotInGraph(const llvm::StringSet<>& ToolsInGraph)
 791   : ToolsInGraph_(ToolsInGraph)
 792   {}
 793
 794   bool operator()(const IntrusiveRefCntPtr<ToolDescription>& x) {
 795     return (ToolsInGraph_.count(x->Name) == 0);
 796   }
 797 };
 798
 799 /// FilterNotInGraph - Filter out from ToolDescs all Tools not
 800 /// mentioned in the compilation graph definition.
 801 void FilterNotInGraph (const RecordVector& EdgeVector,
 802                        ToolDescriptions& ToolDescs) {
 803
 804   // List all tools mentioned in the graph.
 805   llvm::StringSet<> ToolsInGraph;
 806
 807   for (RecordVector::const_iterator B = EdgeVector.begin(),
 808          E = EdgeVector.end(); B != E; ++B) {
 809
 810     const Record* Edge = *B;
 811     const std::string& NodeA = Edge->getValueAsString("a");
 812     const std::string& NodeB = Edge->getValueAsString("b");
 813
 814     if (NodeA != "root")
 815       ToolsInGraph.insert(NodeA);
 816     ToolsInGraph.insert(NodeB);
 817   }
 818
 819   // Filter ToolPropertiesList.
 820   ToolDescriptions::iterator new_end =
 821     std::remove_if(ToolDescs.begin(), ToolDescs.end(),
 822                    NotInGraph(ToolsInGraph));
 823   ToolDescs.erase(new_end, ToolDescs.end());
 824 }
 825
 826 /// FillInToolToLang - Fills in two tables that map tool names to
 827 /// (input, output) languages.  Helper function used by TypecheckGraph().
 828 void FillInToolToLang (const ToolDescriptions& ToolDescs,
 829                        StringMap<StringSet<> >& ToolToInLang,
 830                        StringMap<std::string>& ToolToOutLang) {
 831   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
 832          E = ToolDescs.end(); B != E; ++B) {
 833     const ToolDescription& D = *(*B);
 834     for (StrVector::const_iterator B = D.InLanguage.begin(),
 835            E = D.InLanguage.end(); B != E; ++B)
 836       ToolToInLang[D.Name].insert(*B);
 837     ToolToOutLang[D.Name] = D.OutLanguage;
 838   }
 839 }
 840
 841 /// TypecheckGraph - Check that names for output and input languages
 842 /// on all edges do match. This doesn't do much when the information
 843 /// about the whole graph is not available (i.e. when compiling most
 844 /// plugins).
 845 void TypecheckGraph (const RecordVector& EdgeVector,
 846                      const ToolDescriptions& ToolDescs) {
 847   StringMap<StringSet<> > ToolToInLang;
 848   StringMap<std::string> ToolToOutLang;
 849
 850   FillInToolToLang(ToolDescs, ToolToInLang, ToolToOutLang);
 851   StringMap<std::string>::iterator IAE = ToolToOutLang.end();
 852   StringMap<StringSet<> >::iterator IBE = ToolToInLang.end();
 853
 854   for (RecordVector::const_iterator B = EdgeVector.begin(),
 855          E = EdgeVector.end(); B != E; ++B) {
 856     const Record* Edge = *B;
 857     const std::string& NodeA = Edge->getValueAsString("a");
 858     const std::string& NodeB = Edge->getValueAsString("b");
 859     StringMap<std::string>::iterator IA = ToolToOutLang.find(NodeA);
 860     StringMap<StringSet<> >::iterator IB = ToolToInLang.find(NodeB);
 861
 862     if (NodeA != "root") {
 863       if (IA != IAE && IB != IBE && IB->second.count(IA->second) == 0)
 864         throw "Edge " + NodeA + "->" + NodeB
 865           + ": output->input language mismatch";
 866     }
 867
 868     if (NodeB == "root")
 869       throw std::string("Edges back to the root are not allowed!");
 870   }
 871 }
 872
 873 /// WalkCase - Walks the 'case' expression DAG and invokes
 874 /// TestCallback on every test, and StatementCallback on every
 875 /// statement. Handles 'case' nesting, but not the 'and' and 'or'
 876 /// combinators.
 877 // TODO: Re-implement EmitCaseConstructHandler on top of this function?
 878 template <typename F1, typename F2>
 879 void WalkCase(Init* Case, F1 TestCallback, F2 StatementCallback) {
 880   const DagInit& d = InitPtrToDag(Case);
 881   bool even = false;
 882   for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end();
 883        B != E; ++B) {
 884     Init* arg = *B;
 885     if (even && dynamic_cast<DagInit*>(arg)
 886         && static_cast<DagInit*>(arg)->getOperator()->getAsString() == "case")
 887       WalkCase(arg, TestCallback, StatementCallback);
 888     else if (!even)
 889       TestCallback(arg);
 890     else
 891       StatementCallback(arg);
 892     even = !even;
 893   }
 894 }
 895
 896 /// ExtractOptionNames - A helper function object used by
 897 /// CheckForSuperfluousOptions() to walk the 'case' DAG.
 898 class ExtractOptionNames {
 899   llvm::StringSet<>& OptionNames_;
 900
 901   void processDag(const Init* Statement) {
 902     const DagInit& Stmt = InitPtrToDag(Statement);
 903     const std::string& ActionName = Stmt.getOperator()->getAsString();
 904     if (ActionName == "forward" || ActionName == "forward_as" ||
 905         ActionName == "unpack_values" || ActionName == "switch_on" ||
 906         ActionName == "parameter_equals" || ActionName == "element_in_list" ||
 907         ActionName == "not_empty" || ActionName == "empty") {
 908       checkNumberOfArguments(&Stmt, 1);
 909       const std::string& Name = InitPtrToString(Stmt.getArg(0));
 910       OptionNames_.insert(Name);
 911     }
 912     else if (ActionName == "and" || ActionName == "or") {
 913       for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) {
 914         this->processDag(Stmt.getArg(i));
 915       }
 916     }
 917   }
 918
 919 public:
 920   ExtractOptionNames(llvm::StringSet<>& OptionNames) : OptionNames_(OptionNames)
 921   {}
 922
 923   void operator()(const Init* Statement) {
 924     if (typeid(*Statement) == typeid(ListInit)) {
 925       const ListInit& DagList = *static_cast<const ListInit*>(Statement);
 926       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
 927            B != E; ++B)
 928         this->processDag(*B);
 929     }
 930     else {
 931       this->processDag(Statement);
 932     }
 933   }
 934 };
 935
 936 /// CheckForSuperfluousOptions - Check that there are no side
 937 /// effect-free options (specified only in the OptionList). Otherwise,
 938 /// output a warning.
 939 void CheckForSuperfluousOptions (const RecordVector& Edges,
 940                                  const ToolDescriptions& ToolDescs,
 941                                  const OptionDescriptions& OptDescs) {
 942   llvm::StringSet<> nonSuperfluousOptions;
 943
 944   // Add all options mentioned in the ToolDesc.Actions to the set of
 945   // non-superfluous options.
 946   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
 947          E = ToolDescs.end(); B != E; ++B) {
 948     const ToolDescription& TD = *(*B);
 949     ExtractOptionNames Callback(nonSuperfluousOptions);
 950     if (TD.Actions)
 951       WalkCase(TD.Actions, Callback, Callback);
 952   }
 953
 954   // Add all options mentioned in the 'case' clauses of the
 955   // OptionalEdges of the compilation graph to the set of
 956   // non-superfluous options.
 957   for (RecordVector::const_iterator B = Edges.begin(), E = Edges.end();
 958        B != E; ++B) {
 959     const Record* Edge = *B;
 960     DagInit* Weight = Edge->getValueAsDag("weight");
 961
 962     if (!isDagEmpty(Weight))
 963       WalkCase(Weight, ExtractOptionNames(nonSuperfluousOptions), Id());
 964   }
 965
 966   // Check that all options in OptDescs belong to the set of
 967   // non-superfluous options.
 968   for (OptionDescriptions::const_iterator B = OptDescs.begin(),
 969          E = OptDescs.end(); B != E; ++B) {
 970     const OptionDescription& Val = B->second;
 971     if (!nonSuperfluousOptions.count(Val.Name)
 972         && Val.Type != OptionType::Alias)
 973       llvm::errs() << "Warning: option '-" << Val.Name << "' has no effect! "
 974         "Probable cause: this option is specified only in the OptionList.\n";
 975   }
 976 }
 977
 978 /// EmitCaseTest1Arg - Helper function used by
 979 /// EmitCaseConstructHandler.
 980 bool EmitCaseTest1Arg(const std::string& TestName,
 981                       const DagInit& d,
 982                       const OptionDescriptions& OptDescs,
 983                       raw_ostream& O) {
 984   checkNumberOfArguments(&d, 1);
 985   const std::string& OptName = InitPtrToString(d.getArg(0));
 986
 987   if (TestName == "switch_on") {
 988     const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
 989     if (!OptDesc.isSwitch())
 990       throw OptName + ": incorrect option type - should be a switch!";
 991     O << OptDesc.GenVariableName();
 992     return true;
 993   } else if (TestName == "input_languages_contain") {
 994     O << "InLangs.count(\"" << OptName << "\") != 0";
 995     return true;
 996   } else if (TestName == "in_language") {
 997     // This works only for single-argument Tool::GenerateAction. Join
 998     // tools can process several files in different languages simultaneously.
 999
1000     // TODO: make this work with Edge::Weight (if possible).
1001     O << "LangMap.GetLanguage(inFile) == \"" << OptName << '\"';
1002     return true;
1003   } else if (TestName == "not_empty" || TestName == "empty") {
1004     const char* Test = (TestName == "empty") ? "" : "!";
1005
1006     if (OptName == "o") {
1007       O << Test << "OutputFilename.empty()";
1008       return true;
1009     }
1010     else {
1011       const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
1012       if (OptDesc.isSwitch())
1013         throw OptName
1014           + ": incorrect option type - should be a list or parameter!";
1015       O << Test << OptDesc.GenVariableName() << ".empty()";
1016       return true;
1017     }
1018   }
1019
1020   return false;
1021 }
1022
1023 /// EmitCaseTest2Args - Helper function used by
1024 /// EmitCaseConstructHandler.
1025 bool EmitCaseTest2Args(const std::string& TestName,
1026                        const DagInit& d,
1027                        const char* IndentLevel,
1028                        const OptionDescriptions& OptDescs,
1029                        raw_ostream& O) {
1030   checkNumberOfArguments(&d, 2);
1031   const std::string& OptName = InitPtrToString(d.getArg(0));
1032   const std::string& OptArg = InitPtrToString(d.getArg(1));
1033   const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
1034
1035   if (TestName == "parameter_equals") {
1036     if (!OptDesc.isParameter())
1037       throw OptName + ": incorrect option type - should be a parameter!";
1038     O << OptDesc.GenVariableName() << " == \"" << OptArg << "\"";
1039     return true;
1040   }
1041   else if (TestName == "element_in_list") {
1042     if (!OptDesc.isList())
1043       throw OptName + ": incorrect option type - should be a list!";
1044     const std::string& VarName = OptDesc.GenVariableName();
1045     O << "std::find(" << VarName << ".begin(),\n"
1046       << IndentLevel << Indent1 << VarName << ".end(), \""
1047       << OptArg << "\") != " << VarName << ".end()";
1048     return true;
1049   }
1050
1051   return false;
1052 }
1053
1054 // Forward declaration.
1055 // EmitLogicalOperationTest and EmitCaseTest are mutually recursive.
1056 void EmitCaseTest(const DagInit& d, const char* IndentLevel,
1057                   const OptionDescriptions& OptDescs,
1058                   raw_ostream& O);
1059
1060 /// EmitLogicalOperationTest - Helper function used by
1061 /// EmitCaseConstructHandler.
1062 void EmitLogicalOperationTest(const DagInit& d, const char* LogicOp,
1063                               const char* IndentLevel,
1064                               const OptionDescriptions& OptDescs,
1065                               raw_ostream& O) {
1066   O << '(';
1067   for (unsigned j = 0, NumArgs = d.getNumArgs(); j < NumArgs; ++j) {
1068     const DagInit& InnerTest = InitPtrToDag(d.getArg(j));
1069     EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
1070     if (j != NumArgs - 1)
1071       O << ")\n" << IndentLevel << Indent1 << ' ' << LogicOp << " (";
1072     else
1073       O << ')';
1074   }
1075 }
1076
1077 void EmitLogicalNot(const DagInit& d, const char* IndentLevel,
1078                     const OptionDescriptions& OptDescs, raw_ostream& O)
1079 {
1080   checkNumberOfArguments(&d, 1);
1081   const DagInit& InnerTest = InitPtrToDag(d.getArg(0));
1082   O << "! (";
1083   EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
1084   O << ")";
1085 }
1086
1087 /// EmitCaseTest - Helper function used by EmitCaseConstructHandler.
1088 void EmitCaseTest(const DagInit& d, const char* IndentLevel,
1089                   const OptionDescriptions& OptDescs,
1090                   raw_ostream& O) {
1091   const std::string& TestName = d.getOperator()->getAsString();
1092
1093   if (TestName == "and")
1094     EmitLogicalOperationTest(d, "&&", IndentLevel, OptDescs, O);
1095   else if (TestName == "or")
1096     EmitLogicalOperationTest(d, "||", IndentLevel, OptDescs, O);
1097   else if (TestName == "not")
1098     EmitLogicalNot(d, IndentLevel, OptDescs, O);
1099   else if (EmitCaseTest1Arg(TestName, d, OptDescs, O))
1100     return;
1101   else if (EmitCaseTest2Args(TestName, d, IndentLevel, OptDescs, O))
1102     return;
1103   else
1104     throw TestName + ": unknown edge property!";
1105 }
1106
1107 // Emit code that handles the 'case' construct.
1108 // Takes a function object that should emit code for every case clause.
1109 // Callback's type is
1110 // void F(Init* Statement, const char* IndentLevel, raw_ostream& O).
1111 template <typename F>
1112 void EmitCaseConstructHandler(const Init* Dag, const char* IndentLevel,
1113                               F Callback, bool EmitElseIf,
1114                               const OptionDescriptions& OptDescs,
1115                               raw_ostream& O) {
1116   const DagInit* d = &InitPtrToDag(Dag);
1117   if (d->getOperator()->getAsString() != "case")
1118     throw std::string("EmitCaseConstructHandler should be invoked"
1119                       " only on 'case' expressions!");
1120
1121   unsigned numArgs = d->getNumArgs();
1122   if (d->getNumArgs() < 2)
1123     throw "There should be at least one clause in the 'case' expression:\n"
1124       + d->getAsString();
1125
1126   for (unsigned i = 0; i != numArgs; ++i) {
1127     const DagInit& Test = InitPtrToDag(d->getArg(i));
1128
1129     // Emit the test.
1130     if (Test.getOperator()->getAsString() == "default") {
1131       if (i+2 != numArgs)
1132         throw std::string("The 'default' clause should be the last in the"
1133                           "'case' construct!");
1134       O << IndentLevel << "else {\n";
1135     }
1136     else {
1137       O << IndentLevel << ((i != 0 && EmitElseIf) ? "else if (" : "if (");
1138       EmitCaseTest(Test, IndentLevel, OptDescs, O);
1139       O << ") {\n";
1140     }
1141
1142     // Emit the corresponding statement.
1143     ++i;
1144     if (i == numArgs)
1145       throw "Case construct handler: no corresponding action "
1146         "found for the test " + Test.getAsString() + '!';
1147
1148     Init* arg = d->getArg(i);
1149     const DagInit* nd = dynamic_cast<DagInit*>(arg);
1150     if (nd && (nd->getOperator()->getAsString() == "case")) {
1151       // Handle the nested 'case'.
1152       EmitCaseConstructHandler(nd, (std::string(IndentLevel) + Indent1).c_str(),
1153                                Callback, EmitElseIf, OptDescs, O);
1154     }
1155     else {
1156       Callback(arg, (std::string(IndentLevel) + Indent1).c_str(), O);
1157     }
1158     O << IndentLevel << "}\n";
1159   }
1160 }
1161
1162 /// TokenizeCmdline - converts from "$CALL(HookName, 'Arg1', 'Arg2')/path" to
1163 /// ["$CALL(", "HookName", "Arg1", "Arg2", ")/path"] .
1164 /// Helper function used by EmitCmdLineVecFill and.
1165 void TokenizeCmdline(const std::string& CmdLine, StrVector& Out) {
1166   const char* Delimiters = " \t\n\v\f\r";
1167   enum TokenizerState
1168   { Normal, SpecialCommand, InsideSpecialCommand, InsideQuotationMarks }
1169   cur_st  = Normal;
1170
1171   if (CmdLine.empty())
1172     return;
1173   Out.push_back("");
1174
1175   std::string::size_type B = CmdLine.find_first_not_of(Delimiters),
1176     E = CmdLine.size();
1177
1178   for (; B != E; ++B) {
1179     char cur_ch = CmdLine[B];
1180
1181     switch (cur_st) {
1182     case Normal:
1183       if (cur_ch == '$') {
1184         cur_st = SpecialCommand;
1185         break;
1186       }
1187       if (oneOf(Delimiters, cur_ch)) {
1188         // Skip whitespace
1189         B = CmdLine.find_first_not_of(Delimiters, B);
1190         if (B == std::string::npos) {
1191           B = E-1;
1192           continue;
1193         }
1194         --B;
1195         Out.push_back("");
1196         continue;
1197       }
1198       break;
1199
1200
1201     case SpecialCommand:
1202       if (oneOf(Delimiters, cur_ch)) {
1203         cur_st = Normal;
1204         Out.push_back("");
1205         continue;
1206       }
1207       if (cur_ch == '(') {
1208         Out.push_back("");
1209         cur_st = InsideSpecialCommand;
1210         continue;
1211       }
1212       break;
1213
1214     case InsideSpecialCommand:
1215       if (oneOf(Delimiters, cur_ch)) {
1216         continue;
1217       }
1218       if (cur_ch == '\'') {
1219         cur_st = InsideQuotationMarks;
1220         Out.push_back("");
1221         continue;
1222       }
1223       if (cur_ch == ')') {
1224         cur_st = Normal;
1225         Out.push_back("");
1226       }
1227       if (cur_ch == ',') {
1228         continue;
1229       }
1230
1231       break;
1232
1233     case InsideQuotationMarks:
1234       if (cur_ch == '\'') {
1235         cur_st = InsideSpecialCommand;
1236         continue;
1237       }
1238       break;
1239     }
1240
1241     Out.back().push_back(cur_ch);
1242   }
1243 }
1244
1245 /// SubstituteSpecialCommands - Perform string substitution for $CALL
1246 /// and $ENV. Helper function used by EmitCmdLineVecFill().
1247 StrVector::const_iterator SubstituteSpecialCommands
1248 (StrVector::const_iterator Pos, StrVector::const_iterator End, raw_ostream& O)
1249 {
1250
1251   const std::string& cmd = *Pos;
1252
1253   if (cmd == "$CALL") {
1254     checkedIncrement(Pos, End, "Syntax error in $CALL invocation!");
1255     const std::string& CmdName = *Pos;
1256
1257     if (CmdName == ")")
1258       throw std::string("$CALL invocation: empty argument list!");
1259
1260     O << "hooks::";
1261     O << CmdName << "(";
1262
1263
1264     bool firstIteration = true;
1265     while (true) {
1266       checkedIncrement(Pos, End, "Syntax error in $CALL invocation!");
1267       const std::string& Arg = *Pos;
1268       assert(Arg.size() != 0);
1269
1270       if (Arg[0] == ')')
1271         break;
1272
1273       if (firstIteration)
1274         firstIteration = false;
1275       else
1276         O << ", ";
1277
1278       O << '"' << Arg << '"';
1279     }
1280
1281     O << ')';
1282
1283   }
1284   else if (cmd == "$ENV") {
1285     checkedIncrement(Pos, End, "Syntax error in $ENV invocation!");
1286     const std::string& EnvName = *Pos;
1287
1288     if (EnvName == ")")
1289       throw "$ENV invocation: empty argument list!";
1290
1291     O << "checkCString(std::getenv(\"";
1292     O << EnvName;
1293     O << "\"))";
1294
1295     checkedIncrement(Pos, End, "Syntax error in $ENV invocation!");
1296   }
1297   else {
1298     throw "Unknown special command: " + cmd;
1299   }
1300
1301   const std::string& Leftover = *Pos;
1302   assert(Leftover.at(0) == ')');
1303   if (Leftover.size() != 1)
1304     O << " + std::string(\"" << (Leftover.c_str() + 1) << "\")";
1305
1306   return Pos;
1307 }
1308
1309 /// EmitCmdLineVecFill - Emit code that fills in the command line
1310 /// vector. Helper function used by EmitGenerateActionMethod().
1311 void EmitCmdLineVecFill(const Init* CmdLine, const std::string& ToolName,
1312                         bool IsJoin, const char* IndentLevel,
1313                         raw_ostream& O) {
1314   StrVector StrVec;
1315   TokenizeCmdline(InitPtrToString(CmdLine), StrVec);
1316
1317   if (StrVec.empty())
1318     throw "Tool '" + ToolName + "' has empty command line!";
1319
1320   StrVector::const_iterator I = StrVec.begin(), E = StrVec.end();
1321
1322   // If there is a hook invocation on the place of the first command, skip it.
1323   assert(!StrVec[0].empty());
1324   if (StrVec[0][0] == '$') {
1325     while (I != E && (*I)[0] != ')' )
1326       ++I;
1327
1328     // Skip the ')' symbol.
1329     ++I;
1330   }
1331   else {
1332     ++I;
1333   }
1334
1335   for (; I != E; ++I) {
1336     const std::string& cmd = *I;
1337     assert(!cmd.empty());
1338     O << IndentLevel;
1339     if (cmd.at(0) == '$') {
1340       if (cmd == "$INFILE") {
1341         if (IsJoin)
1342           O << "for (PathVector::const_iterator B = inFiles.begin()"
1343             << ", E = inFiles.end();\n"
1344             << IndentLevel << "B != E; ++B)\n"
1345             << IndentLevel << Indent1 << "vec.push_back(B->str());\n";
1346         else
1347           O << "vec.push_back(inFile.str());\n";
1348       }
1349       else if (cmd == "$OUTFILE") {
1350         O << "vec.push_back(out_file);\n";
1351       }
1352       else {
1353         O << "vec.push_back(";
1354         I = SubstituteSpecialCommands(I, E, O);
1355         O << ");\n";
1356       }
1357     }
1358     else {
1359       O << "vec.push_back(\"" << cmd << "\");\n";
1360     }
1361   }
1362   O << IndentLevel << "cmd = ";
1363
1364   if (StrVec[0][0] == '$')
1365     SubstituteSpecialCommands(StrVec.begin(), StrVec.end(), O);
1366   else
1367     O << '"' << StrVec[0] << '"';
1368   O << ";\n";
1369 }
1370
1371 /// EmitCmdLineVecFillCallback - A function object wrapper around
1372 /// EmitCmdLineVecFill(). Used by EmitGenerateActionMethod() as an
1373 /// argument to EmitCaseConstructHandler().
1374 class EmitCmdLineVecFillCallback {
1375   bool IsJoin;
1376   const std::string& ToolName;
1377  public:
1378   EmitCmdLineVecFillCallback(bool J, const std::string& TN)
1379     : IsJoin(J), ToolName(TN) {}
1380
1381   void operator()(const Init* Statement, const char* IndentLevel,
1382                   raw_ostream& O) const
1383   {
1384     EmitCmdLineVecFill(Statement, ToolName, IsJoin,
1385                        IndentLevel, O);
1386   }
1387 };
1388
1389 /// EmitForwardOptionPropertyHandlingCode - Helper function used to
1390 /// implement EmitActionHandler. Emits code for
1391 /// handling the (forward) and (forward_as) option properties.
1392 void EmitForwardOptionPropertyHandlingCode (const OptionDescription& D,
1393                                             const char* Indent,
1394                                             const std::string& NewName,
1395                                             raw_ostream& O) {
1396   const std::string& Name = NewName.empty()
1397     ? ("-" + D.Name)
1398     : NewName;
1399
1400   switch (D.Type) {
1401   case OptionType::Switch:
1402     O << Indent << "vec.push_back(\"" << Name << "\");\n";
1403     break;
1404   case OptionType::Parameter:
1405     O << Indent << "vec.push_back(\"" << Name << "\");\n";
1406     O << Indent << "vec.push_back(" << D.GenVariableName() << ");\n";
1407     break;
1408   case OptionType::Prefix:
1409     O << Indent << "vec.push_back(\"" << Name << "\" + "
1410       << D.GenVariableName() << ");\n";
1411     break;
1412   case OptionType::PrefixList:
1413     O << Indent << "for (" << D.GenTypeDeclaration()
1414       << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
1415       << Indent << "E = " << D.GenVariableName() << ".end(); B != E;) {\n"
1416       << Indent << Indent1 << "vec.push_back(\"" << Name << "\" + "
1417       << "*B);\n"
1418       << Indent << Indent1 << "++B;\n";
1419
1420     for (int i = 1, j = D.MultiVal; i < j; ++i) {
1421       O << Indent << Indent1 << "vec.push_back(*B);\n"
1422         << Indent << Indent1 << "++B;\n";
1423     }
1424
1425     O << Indent << "}\n";
1426     break;
1427   case OptionType::ParameterList:
1428     O << Indent << "for (" << D.GenTypeDeclaration()
1429       << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
1430       << Indent << "E = " << D.GenVariableName()
1431       << ".end() ; B != E;) {\n"
1432       << Indent << Indent1 << "vec.push_back(\"" << Name << "\");\n";
1433
1434     for (int i = 0, j = D.MultiVal; i < j; ++i) {
1435       O << Indent << Indent1 << "vec.push_back(*B);\n"
1436         << Indent << Indent1 << "++B;\n";
1437     }
1438
1439     O << Indent << "}\n";
1440     break;
1441   case OptionType::Alias:
1442   default:
1443     throw std::string("Aliases are not allowed in tool option descriptions!");
1444   }
1445 }
1446
1447 /// EmitActionHandler - Emit code that handles actions. Used by
1448 /// EmitGenerateActionMethod() as an argument to
1449 /// EmitCaseConstructHandler().
1450 class EmitActionHandler {
1451   const OptionDescriptions& OptDescs;
1452
1453   void processActionDag(const Init* Statement, const char* IndentLevel,
1454                         raw_ostream& O) const
1455   {
1456     const DagInit& Dag = InitPtrToDag(Statement);
1457     const std::string& ActionName = Dag.getOperator()->getAsString();
1458
1459     if (ActionName == "append_cmd") {
1460       checkNumberOfArguments(&Dag, 1);
1461       const std::string& Cmd = InitPtrToString(Dag.getArg(0));
1462       StrVector Out;
1463       llvm::SplitString(Cmd, Out);
1464
1465       for (StrVector::const_iterator B = Out.begin(), E = Out.end();
1466            B != E; ++B)
1467         O << IndentLevel << "vec.push_back(\"" << *B << "\");\n";
1468     }
1469     else if (ActionName == "error") {
1470       O << IndentLevel << "throw std::runtime_error(\"" <<
1471         (Dag.getNumArgs() >= 1 ? InitPtrToString(Dag.getArg(0))
1472          : "Unknown error!")
1473         << "\");\n";
1474     }
1475     else if (ActionName == "forward") {
1476       checkNumberOfArguments(&Dag, 1);
1477       const std::string& Name = InitPtrToString(Dag.getArg(0));
1478       EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
1479                                             IndentLevel, "", O);
1480     }
1481     else if (ActionName == "forward_as") {
1482       checkNumberOfArguments(&Dag, 2);
1483       const std::string& Name = InitPtrToString(Dag.getArg(0));
1484       const std::string& NewName = InitPtrToString(Dag.getArg(1));
1485       EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
1486                                             IndentLevel, NewName, O);
1487     }
1488     else if (ActionName == "output_suffix") {
1489       checkNumberOfArguments(&Dag, 1);
1490       const std::string& OutSuf = InitPtrToString(Dag.getArg(0));
1491       O << IndentLevel << "output_suffix = \"" << OutSuf << "\";\n";
1492     }
1493     else if (ActionName == "stop_compilation") {
1494       O << IndentLevel << "stop_compilation = true;\n";
1495     }
1496     else if (ActionName == "unpack_values") {
1497       checkNumberOfArguments(&Dag, 1);
1498       const std::string& Name = InitPtrToString(Dag.getArg(0));
1499       const OptionDescription& D = OptDescs.FindOption(Name);
1500
1501       if (D.isMultiVal())
1502         throw std::string("Can't use unpack_values with multi-valued options!");
1503
1504       if (D.isList()) {
1505         O << IndentLevel << "for (" << D.GenTypeDeclaration()
1506           << "::iterator B = " << D.GenVariableName() << ".begin(),\n"
1507           << IndentLevel << "E = " << D.GenVariableName()
1508           << ".end(); B != E; ++B)\n"
1509           << IndentLevel << Indent1 << "llvm::SplitString(*B, vec, \",\");\n";
1510       }
1511       else if (D.isParameter()){
1512         O << Indent3 << "llvm::SplitString("
1513           << D.GenVariableName() << ", vec, \",\");\n";
1514       }
1515       else {
1516         throw "Option '" + D.Name +
1517           "': switches can't have the 'unpack_values' property!";
1518       }
1519     }
1520     else {
1521       throw "Unknown action name: " + ActionName + "!";
1522     }
1523   }
1524  public:
1525   EmitActionHandler(const OptionDescriptions& OD)
1526     : OptDescs(OD) {}
1527
1528   void operator()(const Init* Statement, const char* IndentLevel,
1529                   raw_ostream& O) const
1530   {
1531     if (typeid(*Statement) == typeid(ListInit)) {
1532       const ListInit& DagList = *static_cast<const ListInit*>(Statement);
1533       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
1534            B != E; ++B)
1535         this->processActionDag(*B, IndentLevel, O);
1536     }
1537     else {
1538       this->processActionDag(Statement, IndentLevel, O);
1539     }
1540   }
1541 };
1542
1543 // EmitGenerateActionMethod - Emit one of two versions of the
1544 // Tool::GenerateAction() method.
1545 void EmitGenerateActionMethod (const ToolDescription& D,
1546                                const OptionDescriptions& OptDescs,
1547                                bool IsJoin, raw_ostream& O) {
1548   if (IsJoin)
1549     O << Indent1 << "Action GenerateAction(const PathVector& inFiles,\n";
1550   else
1551     O << Indent1 << "Action GenerateAction(const sys::Path& inFile,\n";
1552
1553   O << Indent2 << "bool HasChildren,\n"
1554     << Indent2 << "const llvm::sys::Path& TempDir,\n"
1555     << Indent2 << "const InputLanguagesSet& InLangs,\n"
1556     << Indent2 << "const LanguageMap& LangMap) const\n"
1557     << Indent1 << "{\n"
1558     << Indent2 << "std::string cmd;\n"
1559     << Indent2 << "std::vector<std::string> vec;\n"
1560     << Indent2 << "bool stop_compilation = !HasChildren;\n"
1561     << Indent2 << "const char* output_suffix = \"" << D.OutputSuffix << "\";\n"
1562     << Indent2 << "std::string out_file;\n\n";
1563
1564   // For every understood option, emit handling code.
1565   if (D.Actions)
1566     EmitCaseConstructHandler(D.Actions, Indent2, EmitActionHandler(OptDescs),
1567                              false, OptDescs, O);
1568
1569   O << '\n' << Indent2
1570     << "out_file = OutFilename(" << (IsJoin ? "sys::Path(),\n" : "inFile,\n")
1571     << Indent3 << "TempDir, stop_compilation, output_suffix).str();\n\n";
1572
1573   // cmd_line is either a string or a 'case' construct.
1574   if (!D.CmdLine)
1575     throw "Tool " + D.Name + " has no cmd_line property!";
1576   else if (typeid(*D.CmdLine) == typeid(StringInit))
1577     EmitCmdLineVecFill(D.CmdLine, D.Name, IsJoin, Indent2, O);
1578   else
1579     EmitCaseConstructHandler(D.CmdLine, Indent2,
1580                              EmitCmdLineVecFillCallback(IsJoin, D.Name),
1581                              true, OptDescs, O);
1582
1583   // Handle the Sink property.
1584   if (D.isSink()) {
1585     O << Indent2 << "if (!" << SinkOptionName << ".empty()) {\n"
1586       << Indent3 << "vec.insert(vec.end(), "
1587       << SinkOptionName << ".begin(), " << SinkOptionName << ".end());\n"
1588       << Indent2 << "}\n";
1589   }
1590
1591   O << Indent2 << "return Action(cmd, vec, stop_compilation, out_file);\n"
1592     << Indent1 << "}\n\n";
1593 }
1594
1595 /// EmitGenerateActionMethods - Emit two GenerateAction() methods for
1596 /// a given Tool class.
1597 void EmitGenerateActionMethods (const ToolDescription& ToolDesc,
1598                                 const OptionDescriptions& OptDescs,
1599                                 raw_ostream& O) {
1600   if (!ToolDesc.isJoin())
1601     O << Indent1 << "Action GenerateAction(const PathVector& inFiles,\n"
1602       << Indent2 << "bool HasChildren,\n"
1603       << Indent2 << "const llvm::sys::Path& TempDir,\n"
1604       << Indent2 << "const InputLanguagesSet& InLangs,\n"
1605       << Indent2 << "const LanguageMap& LangMap) const\n"
1606       << Indent1 << "{\n"
1607       << Indent2 << "throw std::runtime_error(\"" << ToolDesc.Name
1608       << " is not a Join tool!\");\n"
1609       << Indent1 << "}\n\n";
1610   else
1611     EmitGenerateActionMethod(ToolDesc, OptDescs, true, O);
1612
1613   EmitGenerateActionMethod(ToolDesc, OptDescs, false, O);
1614 }
1615
1616 /// EmitInOutLanguageMethods - Emit the [Input,Output]Language()
1617 /// methods for a given Tool class.
1618 void EmitInOutLanguageMethods (const ToolDescription& D, raw_ostream& O) {
1619   O << Indent1 << "const char** InputLanguages() const {\n"
1620     << Indent2 << "return InputLanguages_;\n"
1621     << Indent1 << "}\n\n";
1622
1623   if (D.OutLanguage.empty())
1624     throw "Tool " + D.Name + " has no 'out_language' property!";
1625
1626   O << Indent1 << "const char* OutputLanguage() const {\n"
1627     << Indent2 << "return \"" << D.OutLanguage << "\";\n"
1628     << Indent1 << "}\n\n";
1629 }
1630
1631 /// EmitNameMethod - Emit the Name() method for a given Tool class.
1632 void EmitNameMethod (const ToolDescription& D, raw_ostream& O) {
1633   O << Indent1 << "const char* Name() const {\n"
1634     << Indent2 << "return \"" << D.Name << "\";\n"
1635     << Indent1 << "}\n\n";
1636 }
1637
1638 /// EmitIsJoinMethod - Emit the IsJoin() method for a given Tool
1639 /// class.
1640 void EmitIsJoinMethod (const ToolDescription& D, raw_ostream& O) {
1641   O << Indent1 << "bool IsJoin() const {\n";
1642   if (D.isJoin())
1643     O << Indent2 << "return true;\n";
1644   else
1645     O << Indent2 << "return false;\n";
1646   O << Indent1 << "}\n\n";
1647 }
1648
1649 /// EmitStaticMemberDefinitions - Emit static member definitions for a
1650 /// given Tool class.
1651 void EmitStaticMemberDefinitions(const ToolDescription& D, raw_ostream& O) {
1652   if (D.InLanguage.empty())
1653     throw "Tool " + D.Name + " has no 'in_language' property!";
1654
1655   O << "const char* " << D.Name << "::InputLanguages_[] = {";
1656   for (StrVector::const_iterator B = D.InLanguage.begin(),
1657          E = D.InLanguage.end(); B != E; ++B)
1658     O << '\"' << *B << "\", ";
1659   O << "0};\n\n";
1660 }
1661
1662 /// EmitToolClassDefinition - Emit a Tool class definition.
1663 void EmitToolClassDefinition (const ToolDescription& D,
1664                               const OptionDescriptions& OptDescs,
1665                               raw_ostream& O) {
1666   if (D.Name == "root")
1667     return;
1668
1669   // Header
1670   O << "class " << D.Name << " : public ";
1671   if (D.isJoin())
1672     O << "JoinTool";
1673   else
1674     O << "Tool";
1675
1676   O << "{\nprivate:\n"
1677     << Indent1 << "static const char* InputLanguages_[];\n\n";
1678
1679   O << "public:\n";
1680   EmitNameMethod(D, O);
1681   EmitInOutLanguageMethods(D, O);
1682   EmitIsJoinMethod(D, O);
1683   EmitGenerateActionMethods(D, OptDescs, O);
1684
1685   // Close class definition
1686   O << "};\n";
1687
1688   EmitStaticMemberDefinitions(D, O);
1689
1690 }
1691
1692 /// EmitOptionDefinitions - Iterate over a list of option descriptions
1693 /// and emit registration code.
1694 void EmitOptionDefinitions (const OptionDescriptions& descs,
1695                             bool HasSink, bool HasExterns,
1696                             raw_ostream& O)
1697 {
1698   std::vector<OptionDescription> Aliases;
1699
1700   // Emit static cl::Option variables.
1701   for (OptionDescriptions::const_iterator B = descs.begin(),
1702          E = descs.end(); B!=E; ++B) {
1703     const OptionDescription& val = B->second;
1704
1705     if (val.Type == OptionType::Alias) {
1706       Aliases.push_back(val);
1707       continue;
1708     }
1709
1710     if (val.isExtern())
1711       O << "extern ";
1712
1713     O << val.GenTypeDeclaration() << ' '
1714       << val.GenVariableName();
1715
1716     if (val.isExtern()) {
1717       O << ";\n";
1718       continue;
1719     }
1720
1721     O << "(\"" << val.Name << "\"\n";
1722
1723     if (val.Type == OptionType::Prefix || val.Type == OptionType::PrefixList)
1724       O << ", cl::Prefix";
1725
1726     if (val.isRequired()) {
1727       if (val.isList() && !val.isMultiVal())
1728         O << ", cl::OneOrMore";
1729       else
1730         O << ", cl::Required";
1731     }
1732     else if (val.isOneOrMore() && val.isList()) {
1733         O << ", cl::OneOrMore";
1734     }
1735     else if (val.isZeroOrOne() && val.isList()) {
1736         O << ", cl::ZeroOrOne";
1737     }
1738
1739     if (val.isReallyHidden()) {
1740       O << ", cl::ReallyHidden";
1741     }
1742     else if (val.isHidden()) {
1743       O << ", cl::Hidden";
1744     }
1745
1746     if (val.MultiVal > 1)
1747       O << ", cl::multi_val(" << val.MultiVal << ')';
1748
1749     if (val.InitVal) {
1750       const std::string& str = val.InitVal->getAsString();
1751       O << ", cl::init(" << str << ')';
1752     }
1753
1754     if (!val.Help.empty())
1755       O << ", cl::desc(\"" << val.Help << "\")";
1756
1757     O << ");\n\n";
1758   }
1759
1760   // Emit the aliases (they should go after all the 'proper' options).
1761   for (std::vector<OptionDescription>::const_iterator
1762          B = Aliases.begin(), E = Aliases.end(); B != E; ++B) {
1763     const OptionDescription& val = *B;
1764
1765     O << val.GenTypeDeclaration() << ' '
1766       << val.GenVariableName()
1767       << "(\"" << val.Name << '\"';
1768
1769     const OptionDescription& D = descs.FindOption(val.Help);
1770     O << ", cl::aliasopt(" << D.GenVariableName() << ")";
1771
1772     O << ", cl::desc(\"" << "An alias for -" + val.Help  << "\"));\n";
1773   }
1774
1775   // Emit the sink option.
1776   if (HasSink)
1777     O << (HasExterns ? "extern cl" : "cl")
1778       << "::list<std::string> " << SinkOptionName
1779       << (HasExterns ? ";\n" : "(cl::Sink);\n");
1780
1781   O << '\n';
1782 }
1783
1784 /// EmitPopulateLanguageMap - Emit the PopulateLanguageMap() function.
1785 void EmitPopulateLanguageMap (const RecordKeeper& Records, raw_ostream& O)
1786 {
1787   // Generate code
1788   O << "void PopulateLanguageMapLocal(LanguageMap& langMap) {\n";
1789
1790   // Get the relevant field out of RecordKeeper
1791   const Record* LangMapRecord = Records.getDef("LanguageMap");
1792
1793   // It is allowed for a plugin to have no language map.
1794   if (LangMapRecord) {
1795
1796     ListInit* LangsToSuffixesList = LangMapRecord->getValueAsListInit("map");
1797     if (!LangsToSuffixesList)
1798       throw std::string("Error in the language map definition!");
1799
1800     for (unsigned i = 0; i < LangsToSuffixesList->size(); ++i) {
1801       const Record* LangToSuffixes = LangsToSuffixesList->getElementAsRecord(i);
1802
1803       const std::string& Lang = LangToSuffixes->getValueAsString("lang");
1804       const ListInit* Suffixes = LangToSuffixes->getValueAsListInit("suffixes");
1805
1806       for (unsigned i = 0; i < Suffixes->size(); ++i)
1807         O << Indent1 << "langMap[\""
1808           << InitPtrToString(Suffixes->getElement(i))
1809           << "\"] = \"" << Lang << "\";\n";
1810     }
1811   }
1812
1813   O << "}\n\n";
1814 }
1815
1816 /// IncDecWeight - Helper function passed to EmitCaseConstructHandler()
1817 /// by EmitEdgeClass().
1818 void IncDecWeight (const Init* i, const char* IndentLevel,
1819                    raw_ostream& O) {
1820   const DagInit& d = InitPtrToDag(i);
1821   const std::string& OpName = d.getOperator()->getAsString();
1822
1823   if (OpName == "inc_weight") {
1824     O << IndentLevel << "ret += ";
1825   }
1826   else if (OpName == "dec_weight") {
1827     O << IndentLevel << "ret -= ";
1828   }
1829   else if (OpName == "error") {
1830     O << IndentLevel << "throw std::runtime_error(\"" <<
1831         (d.getNumArgs() >= 1 ? InitPtrToString(d.getArg(0))
1832          : "Unknown error!")
1833       << "\");\n";
1834     return;
1835   }
1836
1837   else
1838     throw "Unknown operator in edge properties list: " + OpName + '!' +
1839       "\nOnly 'inc_weight', 'dec_weight' and 'error' are allowed.";
1840
1841   if (d.getNumArgs() > 0)
1842     O << InitPtrToInt(d.getArg(0)) << ";\n";
1843   else
1844     O << "2;\n";
1845
1846 }
1847
1848 /// EmitEdgeClass - Emit a single Edge# class.
1849 void EmitEdgeClass (unsigned N, const std::string& Target,
1850                     DagInit* Case, const OptionDescriptions& OptDescs,
1851                     raw_ostream& O) {
1852
1853   // Class constructor.
1854   O << "class Edge" << N << ": public Edge {\n"
1855     << "public:\n"
1856     << Indent1 << "Edge" << N << "() : Edge(\"" << Target
1857     << "\") {}\n\n"
1858
1859   // Function Weight().
1860     << Indent1 << "unsigned Weight(const InputLanguagesSet& InLangs) const {\n"
1861     << Indent2 << "unsigned ret = 0;\n";
1862
1863   // Handle the 'case' construct.
1864   EmitCaseConstructHandler(Case, Indent2, IncDecWeight, false, OptDescs, O);
1865
1866   O << Indent2 << "return ret;\n"
1867     << Indent1 << "};\n\n};\n\n";
1868 }
1869
1870 /// EmitEdgeClasses - Emit Edge* classes that represent graph edges.
1871 void EmitEdgeClasses (const RecordVector& EdgeVector,
1872                       const OptionDescriptions& OptDescs,
1873                       raw_ostream& O) {
1874   int i = 0;
1875   for (RecordVector::const_iterator B = EdgeVector.begin(),
1876          E = EdgeVector.end(); B != E; ++B) {
1877     const Record* Edge = *B;
1878     const std::string& NodeB = Edge->getValueAsString("b");
1879     DagInit* Weight = Edge->getValueAsDag("weight");
1880
1881     if (!isDagEmpty(Weight))
1882       EmitEdgeClass(i, NodeB, Weight, OptDescs, O);
1883     ++i;
1884   }
1885 }
1886
1887 /// EmitPopulateCompilationGraph - Emit the PopulateCompilationGraph()
1888 /// function.
1889 void EmitPopulateCompilationGraph (const RecordVector& EdgeVector,
1890                                    const ToolDescriptions& ToolDescs,
1891                                    raw_ostream& O)
1892 {
1893   O << "void PopulateCompilationGraphLocal(CompilationGraph& G) {\n";
1894
1895   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
1896          E = ToolDescs.end(); B != E; ++B)
1897     O << Indent1 << "G.insertNode(new " << (*B)->Name << "());\n";
1898
1899   O << '\n';
1900
1901   // Insert edges.
1902
1903   int i = 0;
1904   for (RecordVector::const_iterator B = EdgeVector.begin(),
1905          E = EdgeVector.end(); B != E; ++B) {
1906     const Record* Edge = *B;
1907     const std::string& NodeA = Edge->getValueAsString("a");
1908     const std::string& NodeB = Edge->getValueAsString("b");
1909     DagInit* Weight = Edge->getValueAsDag("weight");
1910
1911     O << Indent1 << "G.insertEdge(\"" << NodeA << "\", ";
1912
1913     if (isDagEmpty(Weight))
1914       O << "new SimpleEdge(\"" << NodeB << "\")";
1915     else
1916       O << "new Edge" << i << "()";
1917
1918     O << ");\n";
1919     ++i;
1920   }
1921
1922   O << "}\n\n";
1923 }
1924
1925 /// ExtractHookNames - Extract the hook names from all instances of
1926 /// $CALL(HookName) in the provided command line string. Helper
1927 /// function used by FillInHookNames().
1928 class ExtractHookNames {
1929   llvm::StringMap<unsigned>& HookNames_;
1930 public:
1931   ExtractHookNames(llvm::StringMap<unsigned>& HookNames)
1932   : HookNames_(HookNames) {}
1933
1934   void operator()(const Init* CmdLine) {
1935     StrVector cmds;
1936     TokenizeCmdline(InitPtrToString(CmdLine), cmds);
1937     for (StrVector::const_iterator B = cmds.begin(), E = cmds.end();
1938          B != E; ++B) {
1939       const std::string& cmd = *B;
1940
1941       if (cmd == "$CALL") {
1942         unsigned NumArgs = 0;
1943         checkedIncrement(B, E, "Syntax error in $CALL invocation!");
1944         const std::string& HookName = *B;
1945
1946
1947         if (HookName.at(0) == ')')
1948           throw "$CALL invoked with no arguments!";
1949
1950         while (++B != E && B->at(0) != ')') {
1951           ++NumArgs;
1952         }
1953
1954         StringMap<unsigned>::const_iterator H = HookNames_.find(HookName);
1955
1956         if (H != HookNames_.end() && H->second != NumArgs)
1957           throw "Overloading of hooks is not allowed. Overloaded hook: "
1958             + HookName;
1959         else
1960           HookNames_[HookName] = NumArgs;
1961
1962       }
1963     }
1964   }
1965 };
1966
1967 /// FillInHookNames - Actually extract the hook names from all command
1968 /// line strings. Helper function used by EmitHookDeclarations().
1969 void FillInHookNames(const ToolDescriptions& ToolDescs,
1970                      llvm::StringMap<unsigned>& HookNames)
1971 {
1972   // For all command lines:
1973   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
1974          E = ToolDescs.end(); B != E; ++B) {
1975     const ToolDescription& D = *(*B);
1976     if (!D.CmdLine)
1977       continue;
1978     if (dynamic_cast<StringInit*>(D.CmdLine))
1979       // This is a string.
1980       ExtractHookNames(HookNames).operator()(D.CmdLine);
1981     else
1982       // This is a 'case' construct.
1983       WalkCase(D.CmdLine, Id(), ExtractHookNames(HookNames));
1984   }
1985 }
1986
1987 /// EmitHookDeclarations - Parse CmdLine fields of all the tool
1988 /// property records and emit hook function declaration for each
1989 /// instance of $CALL(HookName).
1990 void EmitHookDeclarations(const ToolDescriptions& ToolDescs, raw_ostream& O) {
1991   llvm::StringMap<unsigned> HookNames;
1992
1993   FillInHookNames(ToolDescs, HookNames);
1994   if (HookNames.empty())
1995     return;
1996
1997   O << "namespace hooks {\n";
1998   for (StringMap<unsigned>::const_iterator B = HookNames.begin(),
1999          E = HookNames.end(); B != E; ++B) {
2000     O << Indent1 << "std::string " << B->first() << "(";
2001
2002     for (unsigned i = 0, j = B->second; i < j; ++i) {
2003       O << "const char* Arg" << i << (i+1 == j ? "" : ", ");
2004     }
2005
2006     O <<");\n";
2007   }
2008   O << "}\n\n";
2009 }
2010
2011 /// EmitRegisterPlugin - Emit code to register this plugin.
2012 void EmitRegisterPlugin(int Priority, raw_ostream& O) {
2013   O << "struct Plugin : public llvmc::BasePlugin {\n\n"
2014     << Indent1 << "int Priority() const { return " << Priority << "; }\n\n"
2015     << Indent1 << "void PopulateLanguageMap(LanguageMap& langMap) const\n"
2016     << Indent1 << "{ PopulateLanguageMapLocal(langMap); }\n\n"
2017     << Indent1
2018     << "void PopulateCompilationGraph(CompilationGraph& graph) const\n"
2019     << Indent1 << "{ PopulateCompilationGraphLocal(graph); }\n"
2020     << "};\n\n"
2021
2022     << "static llvmc::RegisterPlugin<Plugin> RP;\n\n";
2023 }
2024
2025 /// EmitIncludes - Emit necessary #include directives and some
2026 /// additional declarations.
2027 void EmitIncludes(raw_ostream& O) {
2028   O << "#include \"llvm/CompilerDriver/CompilationGraph.h\"\n"
2029     << "#include \"llvm/CompilerDriver/ForceLinkageMacros.h\"\n"
2030     << "#include \"llvm/CompilerDriver/Plugin.h\"\n"
2031     << "#include \"llvm/CompilerDriver/Tool.h\"\n\n"
2032
2033     << "#include \"llvm/ADT/StringExtras.h\"\n"
2034     << "#include \"llvm/Support/CommandLine.h\"\n\n"
2035
2036     << "#include <cstdlib>\n"
2037     << "#include <stdexcept>\n\n"
2038
2039     << "using namespace llvm;\n"
2040     << "using namespace llvmc;\n\n"
2041
2042     << "extern cl::opt<std::string> OutputFilename;\n\n"
2043
2044     << "inline const char* checkCString(const char* s)\n"
2045     << "{ return s == NULL ? \"\" : s; }\n\n";
2046 }
2047
2048
2049 /// PluginData - Holds all information about a plugin.
2050 struct PluginData {
2051   OptionDescriptions OptDescs;
2052   bool HasSink;
2053   bool HasExterns;
2054   ToolDescriptions ToolDescs;
2055   RecordVector Edges;
2056   int Priority;
2057 };
2058
2059 /// HasSink - Go through the list of tool descriptions and check if
2060 /// there are any with the 'sink' property set.
2061 bool HasSink(const ToolDescriptions& ToolDescs) {
2062   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
2063          E = ToolDescs.end(); B != E; ++B)
2064     if ((*B)->isSink())
2065       return true;
2066
2067   return false;
2068 }
2069
2070 /// HasExterns - Go through the list of option descriptions and check
2071 /// if there are any external options.
2072 bool HasExterns(const OptionDescriptions& OptDescs) {
2073  for (OptionDescriptions::const_iterator B = OptDescs.begin(),
2074          E = OptDescs.end(); B != E; ++B)
2075     if (B->second.isExtern())
2076       return true;
2077
2078   return false;
2079 }
2080
2081 /// CollectPluginData - Collect tool and option properties,
2082 /// compilation graph edges and plugin priority from the parse tree.
2083 void CollectPluginData (const RecordKeeper& Records, PluginData& Data) {
2084   // Collect option properties.
2085   const RecordVector& OptionLists =
2086     Records.getAllDerivedDefinitions("OptionList");
2087   CollectOptionDescriptions(OptionLists.begin(), OptionLists.end(),
2088                             Data.OptDescs);
2089
2090   // Collect tool properties.
2091   const RecordVector& Tools = Records.getAllDerivedDefinitions("Tool");
2092   CollectToolDescriptions(Tools.begin(), Tools.end(), Data.ToolDescs);
2093   Data.HasSink = HasSink(Data.ToolDescs);
2094   Data.HasExterns = HasExterns(Data.OptDescs);
2095
2096   // Collect compilation graph edges.
2097   const RecordVector& CompilationGraphs =
2098     Records.getAllDerivedDefinitions("CompilationGraph");
2099   FillInEdgeVector(CompilationGraphs.begin(), CompilationGraphs.end(),
2100                    Data.Edges);
2101
2102   // Calculate the priority of this plugin.
2103   const RecordVector& Priorities =
2104     Records.getAllDerivedDefinitions("PluginPriority");
2105   Data.Priority = CalculatePriority(Priorities.begin(), Priorities.end());
2106 }
2107
2108 /// CheckPluginData - Perform some sanity checks on the collected data.
2109 void CheckPluginData(PluginData& Data) {
2110   // Filter out all tools not mentioned in the compilation graph.
2111   FilterNotInGraph(Data.Edges, Data.ToolDescs);
2112
2113   // Typecheck the compilation graph.
2114   TypecheckGraph(Data.Edges, Data.ToolDescs);
2115
2116   // Check that there are no options without side effects (specified
2117   // only in the OptionList).
2118   CheckForSuperfluousOptions(Data.Edges, Data.ToolDescs, Data.OptDescs);
2119
2120 }
2121
2122 void EmitPluginCode(const PluginData& Data, raw_ostream& O) {
2123   // Emit file header.
2124   EmitIncludes(O);
2125
2126   // Emit global option registration code.
2127   EmitOptionDefinitions(Data.OptDescs, Data.HasSink, Data.HasExterns, O);
2128
2129   // Emit hook declarations.
2130   EmitHookDeclarations(Data.ToolDescs, O);
2131
2132   O << "namespace {\n\n";
2133
2134   // Emit PopulateLanguageMap() function
2135   // (a language map maps from file extensions to language names).
2136   EmitPopulateLanguageMap(Records, O);
2137
2138   // Emit Tool classes.
2139   for (ToolDescriptions::const_iterator B = Data.ToolDescs.begin(),
2140          E = Data.ToolDescs.end(); B!=E; ++B)
2141     EmitToolClassDefinition(*(*B), Data.OptDescs, O);
2142
2143   // Emit Edge# classes.
2144   EmitEdgeClasses(Data.Edges, Data.OptDescs, O);
2145
2146   // Emit PopulateCompilationGraph() function.
2147   EmitPopulateCompilationGraph(Data.Edges, Data.ToolDescs, O);
2148
2149   // Emit code for plugin registration.
2150   EmitRegisterPlugin(Data.Priority, O);
2151
2152   O << "} // End anonymous namespace.\n\n";
2153
2154   // Force linkage magic.
2155   O << "namespace llvmc {\n";
2156   O << "LLVMC_FORCE_LINKAGE_DECL(LLVMC_PLUGIN_NAME) {}\n";
2157   O << "}\n";
2158
2159   // EOF
2160 }
2161
2162
2163 // End of anonymous namespace
2164 }
2165
2166 /// run - The back-end entry point.
2167 void LLVMCConfigurationEmitter::run (raw_ostream &O) {
2168   try {
2169   PluginData Data;
2170
2171   CollectPluginData(Records, Data);
2172   CheckPluginData(Data);
2173
2174   EmitSourceFileHeader("LLVMC Configuration Library", O);
2175   EmitPluginCode(Data, O);
2176
2177   } catch (std::exception& Error) {
2178     throw Error.what() + std::string(" - usually this means a syntax error.");
2179   }
2180 }