The Clang compiler front-end has several additional Clang specific features which are not exposed through the GCC compatibility driver interface. The `-cc1` argument indicates that the compiler front-end is to be used, and not the driver. The clang `-cc1` functionality implements the core compiler functionality.

So, simply speaking. If you do not give `-cc1` then you can expect the &quot;look&amp;feel&quot; of standard GCC. That is the vast majority of compiler flags work just like you would expect them to work with GCC. If you pass the option &quot;-cc1&quot; then you get the Clang compiler flag set. Thus, there might be differences to GCC.

Hope that makes it a little clearer.

The usual compiler consists of so-called compiler driver, which knows how to execute compiler itself, assembler, linker, etc. and compiler itself which just takes the source code (sometimes already preprocessed) and emit assembler/object code.

Clang implements all these components in the single binary, the difference is just the cmdline. Here `clang -cc1` invokes the compiler itself with its internal/undocumented set of options, etc.

I have an Activity with some EditText fields and some buttons as a convenience for what normally would be used to populate those fields.  However when we the user touches one of the EditText fields the Android soft keyboard automatically appears.  I want it to remain hidden by default, **unless** the user long presses the menu button.  I have search for a solution to this and found several answers, but so far I can&#39;t get them to work.

I have tried the following:

1 - In the onCreate method,

    this.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);


2 - Also in the onCreate method,

    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), InputMethodManager.HIDE_IMPLICIT_ONLY);


3 - and fIn the Manifest file,

    &lt;activity android:name=&quot;.activityName&quot; android:windowSoftInputMode=&quot;stateAlwaysHidden&quot;/&gt;

None of these methods work.  Whenever the user clicks on the EditText field, the soft keyboard appears.  I only want the soft keyboard to appear if the user explicitly shows it by long pressing the menu key.

Why isn&#39;t this working?

How to hide Android soft keyboard on EditText

I&#39;m getting the following error even though I currently do have the Bundler gem installed (it appears when I run $gem list).

    ERROR: Gem bundler is not installed, run `gem install bundler` first.

I&#39;m using RVM and my $PATH is as follows:

    /Users/cjstingl/.rvm/gems/ruby-1.9.2-p290@rails3tutorial2ndEd/bin:
    /Users/cjstingl/.rvm/gems/ruby-1.9.2-p290@global/bin:
    /Users/cjstingl/.rvm/rubies/ruby-1.9.2-p290/bin:
    /Users/cjstingl/.rvm/bin:
    /Users/cjstingl/.bin:
    /usr/local/sbin:
    /usr/local/Cellar/php/5.3.6/bin:
    /usr/local/share/python:
    /usr/bin:
    /bin:
    /usr/sbin:
    /sbin:
    /usr/local/bin:
    /usr/X11/bin

Also this is my gem env

    RubyGems Environment:
      - RUBYGEMS VERSION: 1.8.15
      - RUBY VERSION: 1.9.2 (2011-07-09 patchlevel 290) [x86_64-darwin11.2.0]
      - INSTALLATION DIRECTORY: /Users/cjstingl/.rvm/gems/ruby-1.9.2-p290@rails3tutorial2ndEd
      - RUBY EXECUTABLE: /Users/cjstingl/.rvm/rubies/ruby-1.9.2-p290/bin/ruby
      - EXECUTABLE DIRECTORY: /Users/cjstingl/.rvm/gems/ruby-1.9.2-p290@rails3tutorial2ndEd/bin
      - RUBYGEMS PLATFORMS:
        - ruby
        - x86_64-darwin-11
      - GEM PATHS:
         - /Users/cjstingl/.rvm/gems/ruby-1.9.2-p290@rails3tutorial2ndEd
         - /Users/cjstingl/.rvm/gems/ruby-1.9.2-p290@global
      - GEM CONFIGURATION:
         - :update_sources =&gt; true
         - :verbose =&gt; false
         - :benchmark =&gt; false
         - :backtrace =&gt; false
         - :bulk_threshold =&gt; 1000
         - &quot;gem&quot; =&gt; &quot;-n/usr/local/bin --no-ri --no-rdoc --no-user-install&quot;
      - REMOTE SOURCES:
         - http://rubygems.org/

Also: Using the bundle -v command returns the same error


I&#39;ve tried imploding RVM and reinstalling which doesn&#39;t seem to work. I&#39;m stumped and any help would be appreciated.

RVM Bundle Install Missing Gem Error even though gem is installed

I&#39;m a newbie in `clang`. I have read a paper about source to source transformation from `cuda` to `opencl` using `clang` compiler front end.

Can anyone tell me why the option `-cc1` is sometimes used?


What does the clang -cc1 option do?

<p>I'm a newbie in <code>clang</code>. I have read a paper about source to source transformation from <code>cuda</code> to <code>opencl</code> using <code>clang</code> compiler front end.</p>
<p>Can anyone tell me why the option <code>-cc1</code> is sometimes used?</p>


Both of them pretty much do the same thing. Identify that the method is hot and compile it instead of interpreting. With OSR, you just move to the compiled version right after it gets compiled, unlike with JIT, where the compiled code gets called when the method is called for the second time. 

Other than this, are there any other differences?

Differences between Just in Time compilation and On Stack Replacement

Suppose I have an `if` statement with a `return`. From the efficiency perspective, should I use

    if(A &gt; B):
        return A+1
    return A-1

or

    if(A &gt; B):
        return A+1
    else:
        return A-1

Should I prefer one or another when using a compiled language (C) or a scripted one (Python)?

It is more efficient to use if-return-return or if-else-return?

This has been bugging me for a while. How do GCC and g++ compile themselves?

I&#39;m guessing that every revision gets compiled with a previously built revision. Is this true? And if it is, does it mean that the oldest g++ and GCC versions were written in assembly?



How are GCC and g++ bootstrapped?

What I know is that global and static variables are stored in the `.data` segment, and uninitialized data are in the `.bss` segment. What I don&#39;t understand is why do we have dedicated segment for uninitialized variables?  If an uninitialised variable has a value assigned at run time, does the variable exist still in the `.bss` segment only?

In the following program,  `a` is in the `.data` segment, and `b` is in the `.bss` segment; is that correct? Kindly correct me if my understanding is wrong.


    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;

    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9};
    int b[20]; /* Uninitialized, so in the .bss and will not occupy space for 20 * sizeof (int) */

    int main ()
    {
       ;
    }  


Also, consider following program, 


    #include &lt;stdio.h&gt;
    #include &lt;stdlib.h&gt;
    int var[10];  /* Uninitialized so in .bss */
    int main ()
    {
       var[0] = 20  /* **Initialized, where this &#39;var&#39; will be ?** */
    }

      
    


Why is the .bss segment required?

I am trying to compile 2 classes in C++ with the following command:

`g++ Cat.cpp Cat_main.cpp -o Cat`

But I receive the following error:

`Cat.cpp:10:10: error: variable ‘Cat Joey’ has initializer but incomplete type`

Could someone explain to me what this means? What my files basically do is create a class (`Cat.cpp`) and create an instance (`Cat_main.cpp`). Here is my source code:

**Cat.cpp:**

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    class Cat;
    
    using namespace std;
    
    int main()
    {
    	Cat Joey(&quot;Joey&quot;);
    	Joey.Meow();
    
    	return 0;
    }

**Cat_main.cpp:**

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    using namespace std;
    
    class Cat
    {
    	public:
    		Cat(string str);
    	// Variables
    		string name;
    	// Functions
    		void Meow();
    };
    
    Cat::Cat(string str)
    {
    	this-&gt;name = str;
    }
    
    void Cat::Meow()
    {
    	cout &lt;&lt; &quot;Meow!&quot; &lt;&lt; endl;
    	return;
    }

C++ variable has initializer but incomplete type?

In Haskell [LLVM bindings](https://github.com/bos/llvm), I am trying to define a function with a variable number of arguments (actually I mean a constant number that is not known at compile time). I found [this question](https://stackoverflow.com/questions/6448705/adding-a-function-in-llvm-haskell-bindings-when-the-number-of-parameters-is-no) and I am trying to follow the answer.

I do not want to fall back completely to using the FFI for generating LLVM, I want to use the DSL as much as I could and use FFI to only do the things I cannot do via the DSL.

I managed to define a type via functionType, I am still unable to add a function to a module created by calling &lt;code&gt;defineModule&lt;/code&gt;. I also think that the next step is to add the basic blocks to the function via &lt;code&gt;FFI.appendBasicBlock&lt;/code&gt; which I think is easy, but how do I get the arguments via &lt;code&gt;FFI.getParam&lt;/code&gt; inside of a do block in the &lt;code&gt;CodeGenFunction&lt;/code&gt; monad.

Binding FFI and DSL

I want clang to compile my C/C++ code to LLVM bitcode rather than a binary executable. How can I achieve that?

And if I have the LLVM bitcode, how can I further compile it to a binary executable?

I want to add some of my own code to the LLVM bitcode before compiling to a binary executable.

How to make clang compile to llvm IR

It&#39;s always been possible to create NSArrays (and NSDictionaries/NSNumber) with vararg method calls, like:

    [NSArray arrayWithObjects: @&quot;a&quot;, @&quot;b&quot;, @&quot;c&quot;, nil];

Can these be created with in-line literals in a new improvement to LLVM and Clang?

Is there some literal dictionary or array syntax in Objective-C?

My application needs to run many separate contexts in the same (single-threaded) process. They all share a single `LLVMContext`. 

The process will run many contexts (in the thread sense); that is, each one runs a function in a continuation object based on `boost::context` (still on vault, pre-approved lib) it means that each context can yield, but they basically run in the same single-threaded process. Each one should run basically independent of the other, and more importantly, a compilation error in each one should not affect the execution of the others.

Each of these contexts, will invoke code dynamically that spans multiple translation units (TU). some Translation units may be shared across many of these contexts. compilation errors in a new or modified translation unit should not affect other contexts.

**Clarification Edit:**
For example, T.U. A might be shared among two contexts, context X and Y. just for the sake of having a full picture, lets say that X will also be running code from other translations units, I.e B and D, while Y will have also C. At some point, X decides to make a modification to A, so it creates a new T.U A.1, which is a copy of A, and applies the modification there, so those will not affect context Y. Hope this example makes it clear the requirement. 

My initial impulse was to associate one `llvm::Module` for each context, but since its undefined in LLVM what happens with a module in an intermediate state of compilation, I decided to add one `llvm::Module` for each translation unit (see [this question for the reason][1]), plus the copy-on-write policy I explained before for when modifications of a translation unit happen locally to a context, in order to avoid a modification affecting other contexts.

The main two-fold question I&#39;ve have is:

* How do I link together the different modules in a context in order to invoke them as an unified library? I&#39;m using the C++ api. I&#39;m particularly wary of [this nasty, old bug][2] affecting this functionality. Would this bug still affect me if I transferred ownership of all the modules to the JIT with `ExecutionEngine::addModule()`?

* What are the required steps once a modification on a translation unit forces the update of one of the modules? do I need to drop/delete the old module object and create a new one? is there a recycling policy that I haven&#39;t read about?

A secondary question I have about this is:

* How many `ExecutionEngine` do I need? one for the whole application? one per context? one per module? 


Hope the scope of the question is not too overwhelming.



  [1]: https://stackoverflow.com/q/9843177/170521
  [2]: http://llvm.org/bugs/show_bug.cgi?id=2606

design suggestion: llvm multiple runtime contexts

From what I&#39;ve read, there is a llvm program that converts java bytecode to llvm&#39;s intermediate form called class2llvm. My question is, how do I access this. What front end do I have to install in order to access this. 

VMkit is their implementation of a JVM, but I am looking for how to compile the java source code with llvm, not how to run it.

Is there a llvm java front end that converts java source to llvm&#39;s intermediate form?

I have installed [Clang][1] by using apt-get in Ubuntu, and I can successfully compile C files using it. However, I have no idea how to compile C++ through it. What do I need to do to compile C++?

  [1]: http://clang.llvm.org/


How do I compile C++ with Clang?

I&#39;m writing C++ code on a mac. Why do I get this error when compiling?:

&gt; Undefined symbols for architecture i386:   &quot;Log::theString&quot;,
&gt; referenced from:
&gt;       Log::method(std::string) in libTest.a(Log.o) ld: symbol(s) not found for architecture i386 clang: error: linker command failed with
&gt; exit code 1 (use -v to see invocation)

Not sure if my code is wrong or I have to add additional flags to Xcode. My current XCode configurations are the default ones for a &#39;static library&#39; project.

My code:  

Log.h------------

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    using namespace std;
    
    class Log{
    public:
        static void method(string arg);
    private:
        static string theString ;
    };

Log.cpp ----

    #include &quot;Log.h&quot;
    #include &lt;ostream&gt;
    
    void Log::method(string arg){
        theString = &quot;hola&quot;;
        cout   &lt;&lt; theString &lt;&lt; endl; 
    }

I&#39;m calling the &#39;method&#39; from a test code, in this way:
&#39;Log::method(&quot;asd&quot;):&#39;

thanks for your help.

static variable link error

I was experimenting with `shared_ptr` and `make_shared` from C++11 and programmed a little toy example to see what is actually happening when calling `make_shared`. As infrastructure I was using llvm/clang 3.0 along with the llvm std c++ library within XCode4.

    class Object
    {
    public:
        Object(const string&amp; str)
        {
            cout &lt;&lt; &quot;Constructor &quot; &lt;&lt; str &lt;&lt; endl;
        }
        
        Object()
        {
            cout &lt;&lt; &quot;Default constructor&quot; &lt;&lt; endl;
            
        }
        
        ~Object()
        {
            cout &lt;&lt; &quot;Destructor&quot; &lt;&lt; endl;
        }
        
        Object(const Object&amp; rhs)
        {
            cout &lt;&lt; &quot;Copy constructor...&quot; &lt;&lt; endl;
        }
    };

    void make_shared_example()
    {
        cout &lt;&lt; &quot;Create smart_ptr using make_shared...&quot; &lt;&lt; endl;
        auto ptr_res1 = make_shared&lt;Object&gt;(&quot;make_shared&quot;);
        cout &lt;&lt; &quot;Create smart_ptr using make_shared: done.&quot; &lt;&lt; endl;
        
        cout &lt;&lt; &quot;Create smart_ptr using new...&quot; &lt;&lt; endl;
        shared_ptr&lt;Object&gt; ptr_res2(new Object(&quot;new&quot;));
        cout &lt;&lt; &quot;Create smart_ptr using new: done.&quot; &lt;&lt; endl;
    }

Now have a look at the output, please:

&gt; Create smart_ptr using make_shared...
&gt; 
&gt; Constructor make_shared
&gt; 
&gt; Copy constructor...
&gt; 
&gt; Copy constructor...
&gt; 
&gt; Destructor
&gt; 
&gt; Destructor
&gt; 
&gt; Create smart_ptr using make_shared: done.
&gt; 
&gt; Create smart_ptr using new... 
&gt; 
&gt; Constructor new
&gt; 
&gt; Create smart_ptr using new: done.
&gt; 
&gt; Destructor
&gt; 
&gt; Destructor



It appears that `make_shared` is calling the copy constructor two times. If I allocate memory for an `Object` using a regular `new` this does not happen, only one `Object` is constructed.

What I am wondering about is the following. I heard that `make_shared` is supposed to be more efficient than using `new`&lt;sup&gt;([1], [2])&lt;/sup&gt;. One reason is because `make_shared` allocates the reference count together with the object to be managed in the same block of memory. OK, I got the point. This is of course more efficient than two separate allocation operations.

On the contrary I don&#39;t understand why this has to come with the cost of two calls to the copy constructor of `Object`. Because of this I am not convinced that `make_shared` is more efficient than allocation using `new` in *every* case. Am I wrong here? Well OK, One could implement a move constructor for `Object` but still I am not sure whether this this is more efficient than just allocating `Object` through `new`. At least not in every case. It would be true if copying `Object` is less expensive than allocating memory for a reference counter. But the `shared_ptr`-internal reference counter could be implemented using a couple of primitive data types, right?

Can you help and explain why `make_shared` is the way to go in terms of efficiency, despite the outlined copy overhead? 

  [1]: http://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared

  [2]: http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/STL11-Magic-Secrets (around minute 10)


Is make_shared really more efficient than new?

I was wondering how to suppress the warning:

&gt; Category is implementing a method which will also be implemented by
&gt; its primary class.

I have this for a specific code category:


    + (UIFont *)systemFontOfSize:(CGFloat)fontSize {
	    return [self aCustomFontOfSize:fontSize];
    }


Content Type	Original Author	Original Content on Stackoverflow
Question	sp497	View Question on Stackoverflow
Solution 1 - Compiler Construction	ritter	View Answer on Stackoverflow
Solution 2 - Compiler Construction	Anton Korobeynikov	View Answer on Stackoverflow

What does the clang -cc1 option do?

Compiler Construction Problem Overview

Compiler Construction Solutions

Solution 1 - Compiler Construction

Solution 2 - Compiler Construction

RVM Bundle Install Missing Gem Error even though gem is installed

How to hide Android soft keyboard on EditText

Attributions